vagrant-mutate 0.3.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54e5e005e1846633e4c584acf141a277121c6673
-  data.tar.gz: 9bdc4f4c11effa683d6e245671d55a34951ec04b
+  metadata.gz: 0f11d1d281c5163c1fb94808679865f70fdc064e
+  data.tar.gz: eb2f7a13d0d995e1bfb4bd8118341c7a8e66222e
 SHA512:
-  metadata.gz: ba0c34d684ae47140c2f4723204ed662a8958fbdf1aa2fab97eb842e05f9f5e751ca32c676f7778d2175eaf805001579261d702e2ef5e0422f6611edaaf18366
-  data.tar.gz: b2a019365f16ee2ebb92362d1df3a2fdabd39c66fb647a90d9ee1a714a099869b99c7eb5772928e517980b227971658738a441537b4c0caa6c940aa272868c5f
+  metadata.gz: 96f137bd296afdfbcc8c5c12ef19dc966bc73ebc291abd1e88c45e26e2292940a01f52b3263193197bbb16c368ac64ad1a761234d06909c996ebd7dbb0e6055c
+  data.tar.gz: d8ff920d3b9c5d818b0b57179bf74382cb5c02972f2b609046e616edfee738447c07c57e5452742d863f9c4453c2a78d4344b9f68a3413d10699fffe7c41bf1d

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 1.0.0 (2015-05-20)
+* Support versioned boxes (#51)
+* Support boxes with slash in name (#52)
+* Rename input provider option (#68)
+* Allow hyphen in box name when loading from url (#70)
+
 # 0.3.2 (2015-03-03)
 * Specify qcow compat instead of using default (#59)
 * Provide clearer error when qemu-img missing (#62)

data/Gemfile

@@ -1,4 +1,15 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in vagrant-mutate.gemspec
 gemspec
+
+group :development do
+  # We depend on Vagrant for development, but we don't add it as a
+  # gem dependency because we expect to be installed within the
+  # Vagrant environment itself using `vagrant plugin`.
+  gem "vagrant", git: "https://github.com/mitchellh/vagrant.git"
+end
+
+group :plugins do
+  gem "vagrant-mutate", path: "."
+end
+

data/README.md

@@ -17,25 +17,23 @@ Throughout its development vagrant-mutate has been tested against the following
 * [vagrant-kvm](https://github.com/adrahon/vagrant-kvm) 0.1.4
 * [vagrant-libvirt](https://github.com/pradels/vagrant-libvirt) 0.0.11
 
-Vagrant-mutate does not yet fully support [versioned boxes](http://docs.vagrantup.com/v2/boxes/versioning.html). It always assumes a box has the version *0*.
-
 ## Installation
 
-### qemu-img
+### qemu-img and libvirt development
 
-First, you must install [qemu-img](http://wiki.qemu.org/Main_Page). Information on supported versions is listed at [QEMU Version Compatibility](https://github.com/sciurus/vagrant-mutate/wiki/QEMU-Version-Compatibility).
+First, you must install [qemu-img](http://wiki.qemu.org/Main_Page) and the libvirt development libraries. Information on supported versions is listed at [QEMU Version Compatibility](https://github.com/sciurus/vagrant-mutate/wiki/QEMU-Version-Compatibility).
 
 #### Debian and derivatives
 
-    apt-get install qemu-utils
+    apt-get install qemu-utils libvirt-dev
 
 #### Red Hat and derivatives
 
-    yum install qemu-img
+    yum install qemu-img libvirt-devel
 
 #### OS X
 
-QEMU is available from [homebrew](http://brew.sh/)
+QEMU and libvirt are available from [homebrew](http://brew.sh/)
 
 #### Windows
 
@@ -67,7 +65,13 @@ Or if you had already added the box to vagrant and now want to use it with libvi
 
     vagrant mutate precise32 libvirt
 
-If you have a box for multiple providers, you must specify the provider to use for input using the *--input_provider* option, e.g.
+The latter syntax works for boxes you added from Vagrant Cloud or Atlas too. If you have installed multiple versions of these boxes, vagrant-mutate will always use the latest one.
+
+    $ vagrant box list
+    hashicorp/precise64  (virtualbox, 1.1.0)
+    $ vagrant mutate hashicorp/precise32 libvirt
+
+If you have a box for multiple providers, you must specify the provider to use for input using the *--input-provider* option, e.g.
 
     $ vagrant box list
     precise32  (kvm)

data/lib/vagrant-mutate/box/box.rb

@@ -1,22 +1,22 @@
 module VagrantMutate
   module Box
     class Box
+      attr_reader :name, :dir, :version, :provider_name, :supported_input, :supported_output, :image_format, :image_name
 
-      attr_reader :name, :dir, :provider_name, :supported_input, :supported_output, :image_format, :image_name
-
-      def initialize(env, name, dir)
-        @env = env
-        @name = name
-        @dir = dir
-        @logger = Log4r::Logger.new('vagrant::mutate')
+      def initialize(env, name, version, dir)
+        @env     = env
+        @name    = name
+        @dir     = dir
+        @version = version
+        @logger  = Log4r::Logger.new('vagrant::mutate')
       end
 
       def virtual_size
-        extract_from_qemu_info( /(\d+) bytes/ )
+        extract_from_qemu_info(/(\d+) bytes/)
       end
 
       def verify_format
-        format_found = extract_from_qemu_info( /file format: (\w+)/ )
+        format_found = extract_from_qemu_info(/file format: (\w+)/)
         unless format_found == @image_format
           @env.ui.warn "Expected input image format to be #{@image_format} but "\
             "it is #{format_found}. Attempting conversion anyway."
@@ -24,16 +24,15 @@ module VagrantMutate
       end
 
       def extract_from_qemu_info(expression)
-        input_file = File.join( @dir, image_name )
+        input_file = File.join(@dir, image_name)
         info = `qemu-img info #{input_file}`
         @logger.debug "qemu-img info output\n#{info}"
         if info =~ expression
-          return $1
+          return Regexp.last_match[1]
         else
-          raise Errors::QemuInfoFailed
+          fail Errors::QemuInfoFailed
         end
       end
-
     end
   end
 end

data/lib/vagrant-mutate/box/kvm.rb

@@ -4,8 +4,7 @@ require 'rexml/document'
 module VagrantMutate
   module Box
     class Kvm < Box
-
-      def initialize(env, name, dir)
+      def initialize(env, name, version, dir)
         super
         @provider_name    = 'kvm'
         @supported_input  = true
@@ -14,20 +13,19 @@ module VagrantMutate
         @image_name       = 'box-disk1.img'
       end
 
-      # TODO implement these methods
-      # architecture, mac_address, cpus, memory
-      # to support converting to providers besides libvirt
+      # TODO: implement these methods
+      #  architecture, mac_address, cpus, memory
+      #  to support converting to providers besides libvirt
 
       def disk_interface
-        domain_file = File.join( @dir, 'box.xml' )
+        domain_file = File.join(@dir, 'box.xml')
         begin
-          domain = REXML::Document.new( File.read(domain_file) )
+          domain = REXML::Document.new(File.read(domain_file))
           domain.elements['/domain/devices/disk/target'].attributes['bus']
         rescue => e
-          raise Errors::BoxAttributeError, :error_message => e.message
+          raise Errors::BoxAttributeError, error_message: e.message
         end
       end
-
     end
   end
 end

data/lib/vagrant-mutate/box/libvirt.rb

@@ -3,8 +3,7 @@ require_relative 'box'
 module VagrantMutate
   module Box
     class Libvirt < Box
-
-      def initialize(env, name, dir)
+      def initialize(env, name, version, dir)
         super
         @provider_name    = 'libvirt'
         @supported_input  = true
@@ -18,7 +17,7 @@ module VagrantMutate
       # we just generate sane values
 
       def architecture
-        return 'x86_64'
+        'x86_64'
       end
 
       # kvm prefix is 52:54:00
@@ -27,21 +26,20 @@ module VagrantMutate
           octets = 3.times.map { rand(255).to_s(16) }
           @mac = "525400#{octets[0]}#{octets[1]}#{octets[2]}"
         end
-        return @mac
+        @mac
       end
 
       def cpus
-        return 1
+        1
       end
 
       def memory
-        return 536870912
+        536_870_912
       end
 
       def disk_interface
-        return 'virtio'
+        'virtio'
       end
-
     end
   end
 end

data/lib/vagrant-mutate/box/virtualbox.rb

@@ -1,13 +1,12 @@
-require "rexml/document"
+require 'rexml/document'
 require_relative 'box'
 
 module VagrantMutate
   module Box
     class Virtualbox < Box
-
-      def initialize(env, name, dir)
+      def initialize(env, name, version, dir)
         super
-        @provider_name     = 'virtualbox'
+        @provider_name    = 'virtualbox'
         @supported_input  = true
         @supported_output = false
         @image_format     = 'vmdk'
@@ -25,14 +24,14 @@ module VagrantMutate
       # because we try to run in 32-bit vm.
       # in contrast, running 32-bit box in a 64-bit vm should work.
       def architecture
-        return 'x86_64'
+        'x86_64'
       end
 
       # use mac from the first enabled nic
       def mac_address
         mac = nil
 
-        ovf.elements.each("//vbox:Machine/Hardware//Adapter") do |ele|
+        ovf.elements.each('//vbox:Machine/Hardware//Adapter') do |ele|
           if ele.attributes['enabled'] == 'true'
             mac = ele.attributes['MACAddress']
             break
@@ -42,64 +41,64 @@ module VagrantMutate
         if mac
           return mac
         else
-          raise Errors::BoxAttributeError, :error_message => 'Could not determine mac address'
+          fail Errors::BoxAttributeError, error_message: 'Could not determine mac address'
         end
       end
 
       def cpus
         cpu_count = nil
 
-        ovf.elements.each("//VirtualHardwareSection/Item") do |device|
-          if device.elements["rasd:ResourceType"].text == '3'
-            cpu_count = device.elements["rasd:VirtualQuantity"].text
+        ovf.elements.each('//VirtualHardwareSection/Item') do |device|
+          if device.elements['rasd:ResourceType'].text == '3'
+            cpu_count = device.elements['rasd:VirtualQuantity'].text
           end
         end
 
         if cpu_count
           return cpu_count
         else
-          raise Errors::BoxAttributeError, :error_message => 'Could not determine number of CPUs'
+          fail Errors::BoxAttributeError, error_message: 'Could not determine number of CPUs'
         end
       end
 
       def memory
         memory_in_bytes = nil
 
-        ovf.elements.each("//VirtualHardwareSection/Item") do |device|
-          if device.elements["rasd:ResourceType"].text == '4'
-            memory_in_bytes = size_in_bytes(device.elements["rasd:VirtualQuantity"].text,
-              device.elements["rasd:AllocationUnits"].text)
+        ovf.elements.each('//VirtualHardwareSection/Item') do |device|
+          if device.elements['rasd:ResourceType'].text == '4'
+            memory_in_bytes = size_in_bytes(device.elements['rasd:VirtualQuantity'].text,
+                                            device.elements['rasd:AllocationUnits'].text)
           end
         end
 
         if memory_in_bytes
           return memory_in_bytes
         else
-          raise Errors::BoxAttributeError, :error_message => 'Could not determine amount of memory'
+          fail Errors::BoxAttributeError, error_message: 'Could not determine amount of memory'
         end
       end
 
       def disk_interface
         controller_type = {}
         controller_used_by_disk = nil
-        ovf.elements.each("//VirtualHardwareSection/Item") do |device|
+        ovf.elements.each('//VirtualHardwareSection/Item') do |device|
           # when we find a controller, store its ID and type
           # when we find a disk, store the ID of the controller it is connected to
-          case device.elements["rasd:ResourceType"].text
-          when "5"
-             controller_type[device.elements["rasd:InstanceID"].text] = 'ide'
-           when "6"
-             controller_type[device.elements["rasd:InstanceID"].text] = 'scsi'
-           when "20"
-             controller_type[device.elements["rasd:InstanceID"].text] = 'sata'
-           when "17"
-             controller_used_by_disk = device.elements["rasd:Parent"].text
+          case device.elements['rasd:ResourceType'].text
+          when '5'
+            controller_type[device.elements['rasd:InstanceID'].text] = 'ide'
+           when '6'
+             controller_type[device.elements['rasd:InstanceID'].text] = 'scsi'
+           when '20'
+             controller_type[device.elements['rasd:InstanceID'].text] = 'sata'
+           when '17'
+             controller_used_by_disk = device.elements['rasd:Parent'].text
           end
         end
         if controller_used_by_disk and controller_type[controller_used_by_disk]
           return controller_type[controller_used_by_disk]
         else
-          raise Errors::BoxAttributeError, :error_message => 'Could not determine disk interface'
+          fail Errors::BoxAttributeError, error_message: 'Could not determine disk interface'
         end
       end
 
@@ -110,11 +109,11 @@ module VagrantMutate
           return @ovf
         end
 
-        ovf_file = File.join( @dir, 'box.ovf')
+        ovf_file = File.join(@dir, 'box.ovf')
         begin
-          @ovf = REXML::Document.new( File.read(ovf_file) )
+          @ovf = REXML::Document.new(File.read(ovf_file))
         rescue => e
-          raise Errors::BoxAttributeError, :error_message => e.message
+          raise Errors::BoxAttributeError, error_message: e.message
         end
       end
 
@@ -122,40 +121,38 @@ module VagrantMutate
       # returns quantity in bytes
       # mib = true to use mebibytes, etc
       # defaults to false because ovf MB != megabytes
-      def size_in_bytes(qty, unit, mib=false)
+      def size_in_bytes(qty, unit, mib = false)
         qty = qty.to_i
         unit = unit.downcase
-        if !mib
+        unless mib
           case unit
-          when "kb", "kilobytes"
-            unit = "kib"
-          when "mb", "megabytes"
-            unit = "mib"
-          when "gb", "gigabytes"
-            unit = "gib"
+          when 'kb', 'kilobytes'
+            unit = 'kib'
+          when 'mb', 'megabytes'
+            unit = 'mib'
+          when 'gb', 'gigabytes'
+            unit = 'gib'
           end
         end
         case unit
-        when "b", "bytes"
+        when 'b', 'bytes'
           qty
-        when "kb", "kilobytes"
+        when 'kb', 'kilobytes'
           (qty * 1000)
-        when "kib", "kibibytes"
+        when 'kib', 'kibibytes'
           (qty * 1024)
-        when "mb", "megabytes"
-          (qty * 1000000)
-        when "m", "mib", "mebibytes"
-          (qty * 1048576)
-        when "gb", "gigabytes"
-          (qty * 1000000000)
-        when "g", "gib", "gibibytes"
-          (qty * 1073741824)
+        when 'mb', 'megabytes'
+          (qty * 1_000_000)
+        when 'm', 'mib', 'mebibytes'
+          (qty * 1_048_576)
+        when 'gb', 'gigabytes'
+          (qty * 1_000_000_000)
+        when 'g', 'gib', 'gibibytes'
+          (qty * 1_073_741_824)
         else
-          raise ArgumentError, "Unknown unit #{unit}"
+          fail ArgumentError, "Unknown unit #{unit}"
         end
       end
-
     end
-
   end
 end

data/lib/vagrant-mutate/box_loader.rb

@@ -1,45 +1,45 @@
 require 'fileutils'
 require 'json'
 require 'uri'
-require "vagrant/util/subprocess"
-require "vagrant/util/downloader"
+require 'vagrant/util/subprocess'
+require 'vagrant/util/downloader'
+require 'vagrant/box'
+require 'vagrant/box_metadata'
 
 module VagrantMutate
   class BoxLoader
-
-    def initialize( env )
+    def initialize(env)
       @env = env
       @logger = Log4r::Logger.new('vagrant::mutate')
       @tmp_files = []
     end
 
-    def prepare_for_output(name, provider_name)
-      @logger.info "Preparing #{name} for output as #{provider_name}"
-      dir = create_output_dir(name, provider_name)
-      box = create_box(provider_name, name, dir)
+    def prepare_for_output(name, provider_name, version)
+      @logger.info "Preparing #{name} for output as #{provider_name} with version #{version}."
+      safe_name = sanitize_name(name)
+      dir = create_output_dir(safe_name, provider_name, version)
+      box = create_box(provider_name, name, version, dir)
 
       if box.supported_output
         return box
       else
-        raise Errors::ProviderNotSupported, :provider => provider_name, :direction => 'output'
+        fail Errors::ProviderNotSupported, provider: provider_name, direction: 'output'
       end
     end
 
-    def load(box_arg, provider_name)
+    def load(box_arg, provider_name, input_version)
       if box_arg =~ /:\/\//
         box = load_from_url(box_arg)
       elsif File.file?(box_arg)
         box = load_from_file(box_arg)
-      elsif box_arg =~ /\//
-        raise Errors::CloudNotSupported
       else
-        box = load_from_boxes_path(box_arg, provider_name)
+        box = load_from_boxes_path(box_arg, provider_name, input_version)
       end
 
       if box.supported_input
         return box
       else
-        raise Errors::ProviderNotSupported, :provider => box.provider_name, :direction => 'input'
+        fail Errors::ProviderNotSupported, provider: box.provider_name, direction: 'input'
       end
     end
 
@@ -49,20 +49,29 @@ module VagrantMutate
       # test that we have a valid url
       url = URI(url)
       unless url.scheme and url.host and url.path
-        raise Errors::URLError, :url => url
+        fail Errors::URLError, url: url
       end
 
       # extract the name of the box from the url
       # if it ends in .box remove that extension
       # if not just remove leading slash
       name = nil
-      if url.path =~ /(\w+).box$/
-        name = $1
+      if url.path =~ /([-\w]+).box$/
+        name = Regexp.last_match[1]
       else
         name = url.path.sub(/^\//, '')
       end
       if name.empty?
-        raise Errors::URLError, :url => url
+        fail Errors::URLError, url: url
+      end
+
+      # Extract the version of the box from the URL
+      if url.path =~ /\/([\d.]+)\//
+        version = Regexp.last_match[1]
+        @logger.info "Pulled version from URL (#{version})"
+      else
+        version = '0'
+        @logger.info "No version found in URL, assuming '0'"
       end
 
       # using same path as in vagrants box add action
@@ -71,38 +80,51 @@ module VagrantMutate
 
       # if this fails it will raise an error and we'll quit
       @env.ui.info "Downloading box #{name} from #{url}"
-      downloader = Vagrant::Util::Downloader.new(url, download_path, { :ui => @env.ui })
+      downloader = Vagrant::Util::Downloader.new(url, download_path,  ui: @env.ui)
       downloader.download!
 
       dir = unpack(download_path)
-
       provider_name = determine_provider(dir)
 
-      box = create_box(provider_name, name, dir)
+      create_box(provider_name, name, version, dir)
     end
 
     def load_from_file(file)
       @logger.info "Loading box from file #{file}"
-      name = File.basename( file, File.extname(file) )
+      name = File.basename(file, File.extname(file))
+
       dir = unpack(file)
       provider_name = determine_provider(dir)
+      version = determine_version(dir)
 
-      box = create_box(provider_name, name, dir)
+      create_box(provider_name, name, version, dir)
     end
 
-    def load_from_boxes_path(name, provider_name)
-      @logger.info "Loading box #{name} from vagrants box path"
+    def load_from_boxes_path(name, provider_name, input_version)
+      @logger.info "Loading box #{name} from vagrants box path using provider #{provider_name} and version #{input_version}."
+      safe_name = sanitize_name(name)
       if provider_name
-        dir = verify_input_dir(provider_name, name)
+        @logger.info "Checking directory for provider #{provider_name}."
+        if input_version
+          @logger.info 'Input version provided, using it.'
+          version = input_version
+        else
+          @logger.info 'No version provided, getting it.'
+          version = get_version(safe_name)
+          @logger.info "Version = #{version}"
+        end
+        dir = verify_input_dir(provider_name, safe_name, version)
       else
-        provider_name, dir = find_input_dir(name)
+        @logger.info 'Working out provider, version and directory...'
+        provider_name, version, dir = find_input_dir(safe_name)
       end
-      box = create_box(provider_name, name, dir)
+      @logger.info "Creating #{name} box using provider #{provider_name} with version #{version} in #{dir}."
+      create_box(provider_name, name, version, dir)
     end
 
     def cleanup
       unless @tmp_files.empty?
-        @env.ui.info "Cleaning up temporary files."
+        @env.ui.info 'Cleaning up temporary files.'
         @tmp_files.each do |f|
           @logger.info "Deleting #{f}"
           FileUtils.remove_entry_secure(f)
@@ -112,82 +134,113 @@ module VagrantMutate
 
     private
 
-    def create_box(provider_name, name, dir)
-        @logger.info "Creating box #{name} with provider #{provider_name} in #{dir}"
-        case provider_name
-        when 'kvm'
-          require_relative 'box/kvm'
-          Box::Kvm.new(@env, name, dir)
-        when 'libvirt'
-          require_relative 'box/libvirt'
-          Box::Libvirt.new(@env, name, dir)
-        when 'virtualbox'
-          require_relative 'box/virtualbox'
-          Box::Virtualbox.new(@env, name, dir)
-        else
-          raise Errors::ProviderNotSupported, :provider => provider_name, :direction => 'input or output'
-        end
+    def create_box(provider_name, name, version, dir)
+      @logger.info "Creating box #{name} with provider #{provider_name} and version #{version} in #{dir}"
+      case provider_name
+      when 'kvm'
+        require_relative 'box/kvm'
+        Box::Kvm.new(@env, name, version, dir)
+      when 'libvirt'
+        require_relative 'box/libvirt'
+        Box::Libvirt.new(@env, name, version, dir)
+      when 'virtualbox'
+        require_relative 'box/virtualbox'
+        Box::Virtualbox.new(@env, name, version, dir)
+      else
+        fail Errors::ProviderNotSupported, provider: provider_name, direction: 'input or output'
+      end
     end
 
-    def create_output_dir(name, provider_name)
+    def create_output_dir(name, provider_name, version)
       # e.g. $HOME/.vagrant.d/boxes/fedora-19/0/libvirt
-      # TODO support versioned boxes
-      out_dir = File.join( @env.boxes_path, name, '0', provider_name )
+      @logger.info "Attempting to create output dir for #{name} with version #{version} and provider #{provider_name}."
+      out_dir = File.join(@env.boxes_path, name, version, provider_name)
+      @logger.info "Creating out_dir #{out_dir}."
       begin
         FileUtils.mkdir_p(out_dir)
       rescue => e
-        raise Errors::CreateBoxDirFailed, :error_message => e.message
+        raise Errors::CreateBoxDirFailed, error_message: e.message
       end
       @logger.info "Created output directory #{out_dir}"
-      return out_dir
+      out_dir
     end
 
     def unpack(file)
-      @env.ui.info "Extracting box file to a temporary directory."
+      @env.ui.info 'Extracting box file to a temporary directory.'
       unless File.exist? file
-        raise Errors::BoxNotFound, :box => file
+        fail Errors::BoxNotFound, box: file
       end
       tmp_dir = Dir.mktmpdir(nil, @env.tmp_path)
       @tmp_files << tmp_dir
       result = Vagrant::Util::Subprocess.execute(
-       "bsdtar", "-v", "-x", "-m", "-C", tmp_dir.to_s, "-f", file)
+       'bsdtar', '-v', '-x', '-m', '-C', tmp_dir.to_s, '-f', file)
       if result.exit_code != 0
-        raise Errors::ExtractBoxFailed, :error_message => result.stderr.to_s
+        fail Errors::ExtractBoxFailed, error_message: result.stderr.to_s
       end
       @logger.info "Unpacked box to #{tmp_dir}"
-      return tmp_dir
+      tmp_dir
     end
 
     def determine_provider(dir)
       metadata_file = File.join(dir, 'metadata.json')
       if File.exist? metadata_file
         begin
-          metadata = JSON.load( File.new( metadata_file, 'r') )
+          metadata = JSON.load(File.new(metadata_file, 'r'))
         rescue => e
-          raise Errors::DetermineProviderFailed, :error_message => e.message
+          raise Errors::LoadMetadataFailed, error_message: e.message
         end
         @logger.info "Determined input provider is #{metadata['provider']}"
         return metadata['provider']
       else
-        @logger.info "No metadata found, so assuming input provider is virtualbox"
+        @logger.info 'No metadata found, so assuming input provider is virtualbox'
         return 'virtualbox'
       end
     end
 
-    def verify_input_dir(provider_name, name)
-      # TODO support versioned boxes
-      input_dir = File.join( @env.boxes_path, name, '0', provider_name)
+    def determine_version(dir)
+      metadata_file = File.join(dir, 'metadata.json')
+      if File.exist? metadata_file
+        begin
+          metadata = JSON.load(File.new(metadata_file, 'r'))
+        rescue => e
+          raise Errors::LoadMetadataFailed, error_message: e.message
+        end
+        # Handle single or multiple versions
+        if metadata['versions'].nil?
+          @logger.info 'No versions provided by metadata, asuming version 0'
+          version = '0'
+        elsif metadata['versions'].length > 1
+          metadata['versions'].each do |metadata_version|
+            @logger.info 'Itterating available metadata versions for active version.'
+            next unless metadata_version['status'] == 'active'
+            version = metadata_version['version']
+          end
+        else
+          @logger.info 'Only one metadata version, grabbing version.'
+          version = metadata['versions'][0]['version']
+        end
+        @logger.info "Determined input version is #{version}"
+        return version
+      else
+        @logger.info 'No metadata found, so assuming version is 0'
+        return '0'
+      end
+    end
+
+    def verify_input_dir(provider_name, name, version)
+      input_dir = File.join(@env.boxes_path, name, version, provider_name)
       if File.directory?(input_dir)
         @logger.info "Found input directory #{input_dir}"
         return input_dir
       else
-        raise Errors::BoxNotFound, :box => input_dir
+        fail Errors::BoxNotFound, box: input_dir
       end
     end
 
     def find_input_dir(name)
-      # TODO support versioned boxes
-      box_parent_dir = File.join( @env.boxes_path, name, '0')
+      @logger.info "Looking for input dir for box #{name}."
+      version = get_version(name)
+      box_parent_dir = File.join(@env.boxes_path, name, version)
 
       if Dir.exist?(box_parent_dir)
         providers = Dir.entries(box_parent_dir).reject { |entry| entry =~ /^\./ }
@@ -198,16 +251,46 @@ module VagrantMutate
 
       case
       when providers.length < 1
-        raise Errors::BoxNotFound, :box => name
+        fail Errors::BoxNotFound, box: name
       when providers.length > 1
-        raise Errors::TooManyBoxesFound, :box => name
+        fail Errors::TooManyBoxesFound, box: name
       else
         provider_name = providers.first
-        input_dir = File.join( box_parent_dir, provider_name)
-        @logger.info "Found source for box #{name} from provider #{provider_name} at #{input_dir}"
-        return provider_name, input_dir
+        input_dir = File.join(box_parent_dir, provider_name)
+        @logger.info "Found source for box #{name} from provider #{provider_name} with version #{version} at #{input_dir}"
+        return provider_name, version, input_dir
+      end
+    end
+
+    def get_version(name)
+      # Get a list of directories for this box
+      @logger.info "Getting versions for #{name}."
+
+      box_dir = File.join(@env.boxes_path, name, '*')
+      possible_versions = Dir.glob(box_dir).select { |f| File.directory? f }.map { |x| x.split('/').last }
+
+      @logger.info "Possible_versions = #{possible_versions.inspect}"
+
+      if possible_versions.length > 1
+        @logger.info 'Got multiple possible versions, selecting max value'
+        version = possible_versions.max
+      else
+        @logger.info 'Got a single version, so returning it'
+        version = possible_versions.first
       end
+
+      @logger.info "Found version #{version}"
+      version
     end
 
+    def sanitize_name(name)
+      if name =~ /\//
+        @logger.info 'Replacing / with -VAGRANTSLASH-.'
+        name = name.dup
+        name.gsub!('/', '-VAGRANTSLASH-')
+        @logger.info "New name = #{name}."
+      end
+      name
+    end
   end
 end

data/lib/vagrant-mutate/converter/converter.rb

@@ -3,7 +3,6 @@ require 'fileutils'
 module VagrantMutate
   module Converter
     class Converter
-
       def self.create(env, input_box, output_box)
         case output_box.provider_name
         when 'kvm'
@@ -13,7 +12,7 @@ module VagrantMutate
           require_relative 'libvirt'
           Libvirt.new(env, input_box, output_box)
         else
-          raise Errors::ProviderNotSupported, :provider => output_box.provider_name, :direction => 'output'
+          fail Errors::ProviderNotSupported, provider: output_box.provider_name, direction: 'output'
         end
       end
 
@@ -24,9 +23,9 @@ module VagrantMutate
         @logger = Log4r::Logger.new('vagrant::mutate')
       end
 
-      def convert()
+      def convert
         if @input_box.provider_name == @output_box.provider_name
-          raise Errors::ProvidersMatch
+          fail Errors::ProvidersMatch
         end
 
         @env.ui.info "Converting #{@input_box.name} from #{@input_box.provider_name} "\
@@ -44,27 +43,27 @@ module VagrantMutate
       def write_metadata
         metadata = generate_metadata
         begin
-          File.open( File.join( @output_box.dir, 'metadata.json'), 'w') do |f|
-            f.write( JSON.generate(metadata) )
+          File.open(File.join(@output_box.dir, 'metadata.json'), 'w') do |f|
+            f.write(JSON.generate(metadata))
           end
         rescue => e
-          raise Errors::WriteMetadataFailed, :error_message => e.message
+          raise Errors::WriteMetadataFailed, error_message: e.message
         end
-        @logger.info "Wrote metadata"
+        @logger.info 'Wrote metadata'
       end
 
       def write_vagrantfile
         body = generate_vagrantfile
         begin
-          File.open( File.join( @output_box.dir, 'Vagrantfile'), 'w') do |f|
-            f.puts( 'Vagrant.configure("2") do |config|' )
-            f.puts( body )
-            f.puts( 'end' )
+          File.open(File.join(@output_box.dir, 'Vagrantfile'), 'w') do |f|
+            f.puts('Vagrant.configure("2") do |config|')
+            f.puts(body)
+            f.puts('end')
           end
         rescue => e
-          raise Errors::WriteVagrantfileFailed, :error_message => e.message
+          raise Errors::WriteVagrantfileFailed, error_message: e.message
         end
-        @logger.info "Wrote vagrantfile"
+        @logger.info 'Wrote vagrantfile'
       end
 
       def write_disk
@@ -76,20 +75,19 @@ module VagrantMutate
       end
 
       def copy_disk
-        input = File.join( @input_box.dir, @input_box.image_name )
-        output = File.join( @output_box.dir, @output_box.image_name )
+        input = File.join(@input_box.dir, @input_box.image_name)
+        output = File.join(@output_box.dir, @output_box.image_name)
         @logger.info "Copying #{input} to #{output}"
         begin
           FileUtils.copy_file(input, output)
         rescue => e
-          raise Errors::WriteDiskFailed, :error_message => e.message
+          raise Errors::WriteDiskFailed, error_message: e.message
         end
       end
 
       def convert_disk
-        input_file    = File.join( @input_box.dir, @input_box.image_name )
-        output_file   = File.join( @output_box.dir, @output_box.image_name )
-        input_format  = @input_box.image_format
+        input_file    = File.join(@input_box.dir, @input_box.image_name)
+        output_file   = File.join(@output_box.dir, @output_box.image_name)
         output_format = @output_box.image_format
 
         # p for progress bar
@@ -99,10 +97,9 @@ module VagrantMutate
         command = "qemu-img convert #{qemu_options} -O #{output_format} -o compat=1.1 #{input_file} #{output_file}"
         @logger.info "Running #{command}"
         unless system(command)
-          raise Errors::WriteDiskFailed, :error_message => "qemu-img exited with status #{$?.exitstatus}"
+          fail Errors::WriteDiskFailed, error_message: "qemu-img exited with status #{$CHILD_STATUS.exitstatus}"
         end
       end
-
     end
   end
 end

data/lib/vagrant-mutate/converter/kvm.rb

@@ -3,11 +3,8 @@ require 'erb'
 module VagrantMutate
   module Converter
     class Kvm < Converter
-
       def generate_metadata
-        metadata = {
-          'provider' => @output_box.provider_name,
-        }
+        { 'provider' => @output_box.provider_name }
       end
 
       def generate_vagrantfile
@@ -28,36 +25,35 @@ module VagrantMutate
         name = @input_box.name
         memory = @input_box.memory / 1024 # convert bytes to kib
         cpus = @input_box.cpus
-        mac = format_mac( @input_box.mac_address )
+        mac = format_mac(@input_box.mac_address)
         arch = @input_box.architecture
 
         qemu_bin = find_kvm
 
-        File.open( File.join( @output_box.dir, 'box.xml'), 'w') do |f|
-          f.write( ERB.new(template).result(binding) )
+        File.open(File.join(@output_box.dir, 'box.xml'), 'w') do |f|
+          f.write(ERB.new(template).result(binding))
         end
       end
 
       private
 
       def find_kvm
-        qemu_bin_list = [ '/usr/bin/qemu-system-x86_64',
-                          '/usr/bin/qemu-system-i386',
-                          '/usr/bin/qemu-kvm',
-                          '/usr/libexec/qemu-kvm',
-                          '/usr/bin/kvm' ]
-        qemu_bin = qemu_bin_list.detect { |binary| File.exist? binary }
+        qemu_bin_list = ['/usr/bin/qemu-system-x86_64',
+                         '/usr/bin/qemu-system-i386',
+                         '/usr/bin/qemu-kvm',
+                         '/usr/libexec/qemu-kvm',
+                         '/usr/bin/kvm']
+        qemu_bin = qemu_bin_list.find { |binary| File.exist? binary }
         unless qemu_bin
-          raise Errors::QemuNotFound
+          fail Errors::QemuNotFound
         end
-        return qemu_bin
+        qemu_bin
       end
 
       # convert to format with colons
       def format_mac(mac)
         mac.scan(/(.{2})/).join(':')
       end
-
     end
   end
 end

data/lib/vagrant-mutate/converter/libvirt.rb

@@ -1,12 +1,11 @@
 module VagrantMutate
   module Converter
     class Libvirt < Converter
-
       def generate_metadata
-        metadata = {
+        {
           'provider' => @output_box.provider_name,
           'format'   => @output_box.image_format,
-          'virtual_size' => ( @input_box.virtual_size.to_f / (1024 * 1024 * 1024) ).ceil
+          'virtual_size' => ( @input_box.virtual_size.to_f / (1024 * 1024 * 1024)).ceil
         }
       end
 
@@ -21,7 +20,6 @@ module VagrantMutate
       def write_specific_files
         # nothing to do here
       end
-
     end
   end
 end

data/lib/vagrant-mutate/errors.rb

@@ -6,10 +6,6 @@ module VagrantMutate
       error_namespace('vagrant_mutate.errors')
     end
 
-    class CloudNotSupported < VagrantMutateError
-      error_key(:cloud_not_supported)
-    end
-
     class ProvidersMatch < VagrantMutateError
       error_key(:providers_match)
     end
@@ -46,6 +42,10 @@ module VagrantMutate
       error_key(:determine_provider_failed)
     end
 
+    class LoadMetadataFailed < VagrantMutateError
+      error_key(:load_metadata_failed)
+    end
+
     class CreateBoxDirFailed < VagrantMutateError
       error_key(:create_box_dir_failed)
     end
@@ -78,5 +78,8 @@ module VagrantMutate
       error_key(:url_error)
     end
 
+    class MetadataNotFound < VagrantMutateError
+      error_key(:metadata_not_found)
+    end
   end
 end

data/lib/vagrant-mutate/mutate.rb

@@ -3,23 +3,26 @@ require 'vagrant-mutate/qemu'
 require 'vagrant-mutate/converter/converter'
 
 module VagrantMutate
-
   class Mutate < Vagrant.plugin(2, :command)
-
     def execute
       options = {}
       options[:input_provider] = nil
+      options[:version] = nil
 
       opts = OptionParser.new do |o|
         o.banner = 'Usage: vagrant mutate <box-name-or-file-or-url> <provider>'
-        o.on("--input_provider PROVIDER",
-          "Specify provider for input box") do |p|
+        o.on('--input-provider PROVIDER',
+             'Specify provider for input box') do |p|
           options[:input_provider] = p
         end
+        o.on('--version VERSION',
+             'Specify version for input box') do |p|
+          options[:version] = p
+        end
       end
 
       argv = parse_options(opts)
-      return if !argv
+      return unless argv
 
       unless argv.length == 2
         @env.ui.info(opts.help)
@@ -33,10 +36,10 @@ module VagrantMutate
       Qemu.verify_qemu_version(@env)
 
       input_loader  = BoxLoader.new(@env)
-      input_box = input_loader.load( options[:box_arg], options[:input_provider] )
+      input_box = input_loader.load(options[:box_arg], options[:input_provider], options[:version])
 
       output_loader = BoxLoader.new(@env)
-      output_box = output_loader.prepare_for_output( input_box.name, options[:output_provider])
+      output_box = output_loader.prepare_for_output(input_box.name, options[:output_provider], input_box.version)
 
       converter  = Converter::Converter.create(@env, input_box, output_box)
       converter.convert
@@ -44,9 +47,6 @@ module VagrantMutate
       input_loader.cleanup
 
       @env.ui.info "The box #{output_box.name} (#{output_box.provider_name}) is now ready to use."
-
     end
-
   end
-
 end

data/lib/vagrant-mutate/qemu.rb

@@ -1,40 +1,38 @@
 module VagrantMutate
   class Qemu
-
       # http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
-      def self.verify_qemu_installed
-        logger = Log4r::Logger.new('vagrant::mutate')
-        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-          exts.each do |ext|
-            exe = File.join(path, "qemu-img#{ext}")
-            if File.executable? exe
-              logger.info "Found qemu"
-              return
-            end
+    def self.verify_qemu_installed
+      logger = Log4r::Logger.new('vagrant::mutate')
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "qemu-img#{ext}")
+          if File.executable? exe
+            logger.info 'Found qemu'
+            return
           end
         end
-        # if we make it here qemu-img command was not found
-        raise Errors::QemuImgNotFound
       end
+      # if we make it here qemu-img command was not found
+      fail Errors::QemuImgNotFound
+    end
 
-      def self.verify_qemu_version(env)
-        usage = `qemu-img --version`
-        if usage =~ /(\d+\.\d+\.\d+)/
-          installed_version = Gem::Version.new($1)
-          # less than 1.2 or equal to 1.6.x
-          if (installed_version < Gem::Version.new('1.2.0') or (installed_version >= Gem::Version.new('1.6.0') and installed_version < Gem::Version.new('1.7.0')))
+    def self.verify_qemu_version(env)
+      usage = `qemu-img --version`
+      if usage =~ /(\d+\.\d+\.\d+)/
+        installed_version = Gem::Version.new(Regexp.last_match[1])
+        # less than 1.2 or equal to 1.6.x
+        if installed_version < Gem::Version.new('1.2.0') or (installed_version >= Gem::Version.new('1.6.0') and installed_version < Gem::Version.new('1.7.0'))
 
-            env.ui.warn "You have qemu #{installed_version} installed. "\
-              "This version cannot read some virtualbox boxes. "\
-              "If conversion fails, see below for recommendations. "\
-              "https://github.com/sciurus/vagrant-mutate/wiki/QEMU-Version-Compatibility"
+          env.ui.warn "You have qemu #{installed_version} installed. "\
+            'This version cannot read some virtualbox boxes. '\
+            'If conversion fails, see below for recommendations. '\
+            'https://github.com/sciurus/vagrant-mutate/wiki/QEMU-Version-Compatibility'
 
-          end
-        else
-          raise Errors::ParseQemuVersionFailed
         end
+      else
+        fail Errors::ParseQemuVersionFailed
       end
-
+    end
   end
 end

data/lib/vagrant-mutate/version.rb

@@ -1,3 +1,3 @@
 module VagrantMutate
-  VERSION = '0.3.2'
+  VERSION = '1.0.0'
 end

data/lib/vagrant-mutate.rb

@@ -2,7 +2,6 @@ require 'vagrant-mutate/version'
 require 'vagrant-mutate/errors'
 
 module VagrantMutate
-
   def self.source_root
     @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
   end
@@ -21,5 +20,4 @@ module VagrantMutate
       I18n.reload!
     end
   end
-
 end

data/locales/en.yml

@@ -1,8 +1,6 @@
 en:
   vagrant_mutate:
     errors:
-      cloud_not_supported: |-
-          Vagrant-mutate can not download from Vagrant Cloud for you.
       providers_match: |-
         Input and output provider are the same. Aborting.
       provider_not_supported: |-
@@ -24,6 +22,9 @@ en:
       determine_provider_failed: |-
         Determining provider for box failed with error:
         %{error_message}
+      load_metadata_failed: |-
+        Loading metadata for box failed with error:
+        %{error_message}
       create_box_dir_failed: |-
         Creating directory for box failed with error:
         %{error_message}
@@ -45,3 +46,5 @@ en:
         %{error_message}
       url_error: |-
           The url %{url} is not valid
+      metadata_not_found: |-
+        Unable to find metadata file for %{box}

data/test/test.rb

@@ -12,7 +12,7 @@ end
 
 def ensure_pkg_dir
   pkg_dir = File.expand_path('../../pkg', __FILE__)
-  if not Dir.exists? pkg_dir
+  unless Dir.exist? pkg_dir
     Dir.mkdir pkg_dir
   end
 end
@@ -22,7 +22,7 @@ def build_plugin
   pkg_dir = File.expand_path('../../pkg', __FILE__)
   working_dir = Dir.pwd
   Dir.chdir pkg_dir
-  FileUtils.rm( Dir.glob('*.gem') )
+  FileUtils.rm(Dir.glob('*.gem'))
   system('rake build')
   Dir.chdir working_dir
 end
@@ -56,7 +56,7 @@ end
 
 def test(input, outputs)
   failures = []
-  test_dir = File.expand_path( File.dirname(__FILE__) )
+  test_dir = File.expand_path(File.dirname(__FILE__))
 
   input_box = File.join(test_dir, 'input', input, 'mutate-test.box')
 
@@ -83,19 +83,19 @@ def test(input, outputs)
     end
   end
 
-  return failures
+  failures
 end
 
 cleanup
 ensure_pkg_dir
 build_plugin
-failures = test( 'virtualbox', ['kvm', 'libvirt'] )
-failures += test( 'libvirt', ['kvm'] )
-failures += test( 'kvm', ['libvirt'] )
+failures = test('virtualbox', %w(kvm libvirt))
+failures += test('libvirt', ['kvm'])
+failures += test('kvm', ['libvirt'])
 
 if failures.empty?
   puts "\nALL TESTS PASSED"
 else
   puts "\nTESTS FAILED"
-  failures.each {|f| puts f}
+  failures.each { |f| puts f }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-mutate
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Brian Pitts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-04 00:00:00.000000000 Z
+date: 2015-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -48,7 +48,7 @@ files:
 - ".gitignore"
 - CHANGELOG.md
 - Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
 - Rakefile
 - lib/vagrant-mutate.rb