vagrant-mutate 0.1.3 → 0.1.4

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.1.4 (2013-12-08)
+* Rework box and converter implementation (#7)
+* Write disk images as sparse files (#13)
+* Switch vagrant-kvm disk format from raw to qcow2 (#16)
+* Prefer the binary named qemu-system-* over qemu-kvm or kvm (#20)
+
 # 0.1.3 (2013-12-03)
 
 * Add support for vagrant-kvm (#12)

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

@@ -0,0 +1,27 @@
+module VagrantMutate
+  module Box
+    class Box
+
+      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')
+      end
+
+      def virtual_size
+        input_file = File.join( @dir, @image_name )
+        info = `qemu-img info #{input_file}`
+        @logger.debug "qemu-img info output\n#{info}"
+        if info =~ /(\d+) bytes/
+          return $1
+        else
+          raise Errors::DetermineImageSizeFailed
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require_relative 'box'
+
+module VagrantMutate
+  module Box
+    class Kvm < Box
+
+      def initialize(env, name, dir)
+        super
+        @provider_name    = 'kvm'
+        @supported_input  = false,
+        @supported_output = true,
+        @image_format     = 'qcow2',
+        @image_name       = 'box-disk1.img'
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require_relative 'box'
+
+module VagrantMutate
+  module Box
+    class Libvirt < Box
+
+      def initialize(env, name, dir)
+        super
+        @provider_name    = 'libvirt'
+        @supported_input  = false,
+        @supported_output = true,
+        @image_format     = 'qcow2',
+        @image_name       = 'box.img'
+      end
+
+    end
+  end
+end

data/lib/vagrant-mutate/{provider → box}/virtualbox.rb

@@ -1,19 +1,17 @@
 require "rexml/document"
+require_relative 'box'
 
 module VagrantMutate
-  module Provider
+  module Box
+    class Virtualbox < Box
 
-    class Virtualbox < Provider
-      def initialize(box)
-          @box              = box
-          @name             = 'virtualbox'
-          @supported_input  = true,
-          @supported_output = false,
-          @image_format     = 'vmdk',
-          @image_name       = 'box-disk1.vmdk'
-
-          definition = File.read( File.join( box.dir, 'box.ovf') )
-          @ovf = REXML::Document.new(definition)
+      def initialize(env, name, dir)
+        super
+        @provider_name     = 'virtualbox'
+        @supported_input  = true,
+        @supported_output = false,
+        @image_format     = 'vmdk',
+        @image_name       = 'box-disk1.vmdk'
       end
 
       # the architecture is not defined in the ovf file,
@@ -28,7 +26,7 @@ module VagrantMutate
 
       # use mac from the first enabled nic
       def mac_address
-        @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']
             # convert to more standarad format with colons
@@ -40,7 +38,7 @@ module VagrantMutate
       end
 
       def cpus
-        @ovf.elements.each("//VirtualHardwareSection/Item") do |device|
+        ovf.elements.each("//VirtualHardwareSection/Item") do |device|
           if device.elements["rasd:ResourceType"].text == '3'
             return device.elements["rasd:VirtualQuantity"].text
           end
@@ -48,7 +46,7 @@ module VagrantMutate
       end
 
       def memory
-        @ovf.elements.each("//VirtualHardwareSection/Item") do |device|
+        ovf.elements.each("//VirtualHardwareSection/Item") do |device|
           if device.elements["rasd:ResourceType"].text == '4'
             return size_in_bytes(device.elements["rasd:VirtualQuantity"].text,
               device.elements["rasd:AllocationUnits"].text)
@@ -58,6 +56,10 @@ module VagrantMutate
 
       private
 
+      def ovf
+        @ovf ||= REXML::Document.new( File.read( File.join( @dir, 'box.ovf') ) )
+      end
+
       # Takes a quantity and a unit
       # returns quantity in bytes
       # mib = true to use mebibytes, etc
@@ -99,4 +101,3 @@ module VagrantMutate
 
   end
 end
-

data/lib/vagrant-mutate/{box.rb → box_loader.rb}

@@ -4,73 +4,80 @@ require 'json'
 require 'zlib'
 
 module VagrantMutate
-  class Box
+  class BoxLoader
 
     include Archive::Tar
 
-    attr_reader :dir, :name, :provider
-
     def initialize( env )
       @env = env
       @logger = Log4r::Logger.new('vagrant::mutate')
+      @tmp_dir = nil
+    end
+
+    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
     end
 
-    def prepare_for_output( box_name, provider_name )
-      @logger.info "Preparing #{box_name} for output as #{provider_name}"
-      @name = box_name
-      @provider = Provider::Provider.create( provider_name, self )
-      @dir = create_output_dir()
-      @dir_is_tmp = false
+    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)
 
-      unless @provider.supported_output
+      unless box.supported_output
         raise Errors::ProviderNotSupported, :provider => provider_name, :direction => 'output'
       end
+
+      return box
     end
 
     def load_from_file(file)
       @logger.info "Loading box from file #{file}"
-      @name = File.basename( file, File.extname(file) )
-      @dir = unpack(file)
-      @dir_is_tmp = true
-      @provider = determine_provider()
+      name = File.basename( file, File.extname(file) )
+      dir = unpack(file)
+      @tmp_dir = dir
+      provider_name = determine_provider(dir)
+      box = create_box(provider_name, name, dir)
 
-      unless @provider.supported_input
+      unless box.supported_input
         raise Errors::ProviderNotSupported, :provider => provider_name, :direction => 'input'
       end
+
+      return box
     end
 
     def load_by_name(name)
       @logger.info "Loading box from name #{name}"
-      @name = name
+      dir = find_input_dir(name)
       # cheat for now since only supported input is virtualbox
-      @provider = Provider::Provider.create('virtualbox', self)
-      @dir = find_input_dir()
-      @dir_is_tmp = false
+      box = create_box('virtualbox', name, dir)
+      return box
     end
 
     def cleanup
-      if @dir_is_tmp
+      if @tmp_dir
         @env.ui.info "Cleaning up temporary files."
-        @logger.info "Deleting #{dir}"
-        FileUtils.remove_entry_secure(@dir)
-      end
-    end
-
-    def virtual_size
-      input_file = File.join( @dir, @provider.image_name )
-      info = `qemu-img info #{input_file}`
-      @logger.debug "qemu-img info output\n#{info}"
-      if info =~ /(\d+) bytes/
-        return $1
-      else
-        raise Errors::DetermineImageSizeFailed
+        @logger.info "Deleting #{@tmp_dir}"
+        FileUtils.remove_entry_secure(@tmp_dir)
       end
     end
 
     private
 
-    def determine_provider
-      metadata_file = File.join(@dir, 'metadata.json')
+    def determine_provider(dir)
+      metadata_file = File.join(dir, 'metadata.json')
       if File.exists? metadata_file
         begin
           metadata = JSON.load( File.new( metadata_file, 'r') )
@@ -78,15 +85,16 @@ module VagrantMutate
           raise Errors::DetermineProviderFailed, :error_message => e.message
         end
         @logger.info "Determined input provider is #{metadata['provider']}"
-        return Provider::Provider.create( metadata['provider'], self )
+        return metadata['provider']
       else
         @logger.info "No metadata found, so assuming input provider is virtualbox"
-        return Provider::Provider.create('virtualbox', self)
+        return 'virtualbox'
       end
     end
 
-    def find_input_dir
-      in_dir = File.join( @env.boxes_path, @name, 'virtualbox' )
+    def find_input_dir(name)
+      # cheat for now since only supported input is virtualbox
+      in_dir = File.join( @env.boxes_path, name, 'virtualbox' )
       if File.directory?(in_dir)
         @logger.info "Found input directory #{in_dir}"
         return in_dir
@@ -95,9 +103,9 @@ module VagrantMutate
       end
     end
 
-    def create_output_dir
+    def create_output_dir(name, provider_name)
       # e.g. $HOME/.vagrant.d/boxes/fedora-19/libvirt
-      out_dir = File.join( @env.boxes_path, @name, @provider.name )
+      out_dir = File.join( @env.boxes_path, name, provider_name )
       begin
         FileUtils.mkdir_p(out_dir)
       rescue => e

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

@@ -0,0 +1,136 @@
+require 'fileutils'
+
+module VagrantMutate
+  module Converter
+    class Converter
+
+      def self.create(env, input_box, output_box)
+        case output_box.provider_name
+        when 'kvm'
+          require_relative 'kvm'
+          Kvm.new(env, input_box, output_box)
+        when 'libvirt'
+          require_relative 'libvirt'
+          Libvirt.new(env, input_box, output_box)
+        else
+          raise Errors::ProviderNotSupported, :provider => output_box.provider_name, :direction => 'output'
+        end
+      end
+
+      def initialize(env, input_box, output_box)
+        @env = env
+        @input_box  = input_box
+        @output_box = output_box
+        @logger = Log4r::Logger.new('vagrant::mutate')
+        verify_qemu_installed
+        verify_qemu_version
+      end
+
+      def convert()
+        @env.ui.info "Converting #{@input_box.name} from #{@input_box.provider_name} "\
+          "to #{@output_box.provider_name}."
+
+        write_metadata
+        copy_vagrantfile
+        write_specific_files
+        write_disk
+      end
+
+      private
+
+      # http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
+      def verify_qemu_installed
+        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
+        end
+        # if we make it here qemu-img command was not found
+        raise Errors::QemuNotFound
+      end
+
+      def verify_qemu_version
+        usage = `qemu-img`
+        if usage =~ /(\d+\.\d+\.\d+)/
+          recommended_version = Gem::Version.new('1.2.0')
+          installed_version = Gem::Version.new($1)
+          if installed_version < recommended_version
+            @env.ui.warn "You have qemu #{installed_version} installed. "\
+              "This version is too old to read some virtualbox boxes. "\
+              "If conversion fails, try upgrading to qemu 1.2.0 or newer."
+          end
+        else
+          raise Errors::ParseQemuVersionFailed
+        end
+      end
+
+
+      def write_metadata
+        metadata = generate_metadata
+        begin
+          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
+        end
+        @logger.info "Wrote metadata"
+      end
+
+      def copy_vagrantfile
+        input = File.join( @input_box.dir, 'Vagrantfile' )
+        if File.exists? input
+          output = File.join( @output_box.dir, 'Vagrantfile' )
+          @logger.info "Copying #{input} to #{output}"
+          begin
+            FileUtils.copy_file(input, output)
+          rescue => e
+            raise Errors::WriteVagrantfileFailed, :error_message => e.message
+          end
+        end
+      end
+
+      def write_disk
+        if @input_box.image_format == @output_box.image_format
+          copy_disk
+        else
+          convert_disk
+        end
+      end
+
+      def copy_disk
+        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
+        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
+        output_format = @output_box.image_format
+
+        # p for progress bar
+        # S for sparse file
+        qemu_options = '-p -S 16k'
+
+        command = "qemu-img convert #{qemu_options} -f #{input_format} -O #{output_format} #{input_file} #{output_file}"
+        @logger.info "Running #{command}"
+        unless system(command)
+          raise Errors::WriteDiskFailed, :error_message => "qemu-img exited with status #{$?.exitstatus}"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'erb'
+
+module VagrantMutate
+  module Converter
+    class Kvm < Converter
+
+      def generate_metadata
+        metadata = {
+          'provider' => @output_box.provider_name,
+        }
+      end
+
+      def write_specific_files
+        template_path = VagrantMutate.source_root.join('templates', 'kvm', 'box.xml.erb')
+        template = File.read(template_path)
+
+        uuid = nil
+        gui = true
+        disk_bus = 'virtio'
+
+        image_type = @output_box.image_format
+        disk = @output_box.image_name
+
+        name = @input_box.name
+        memory = @input_box.memory / 1024 # convert bytes to kib
+        cpus = @input_box.cpus
+        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) )
+        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/bin/kvm' ]
+        qemu_bin = qemu_bin_list.detect { |binary| File.exists? binary }
+        unless qemu_bin
+          raise Errors::QemuNotFound
+        end
+        return qemu_bin
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+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
+        }
+      end
+
+      def write_specific_files
+        # nothing to do here
+      end
+
+    end
+  end
+end

data/lib/vagrant-mutate/mutate.rb

@@ -1,6 +1,5 @@
-require 'vagrant-mutate/box'
-require 'vagrant-mutate/converter'
-require 'vagrant-mutate/provider/provider'
+require 'vagrant-mutate/box_loader'
+require 'vagrant-mutate/converter/converter'
 
 module VagrantMutate
 
@@ -21,23 +20,23 @@ module VagrantMutate
       box_arg = argv[0]
       output_provider_arg = argv[1]
 
-      converter  = Converter.new(@env)
-      input_box  = Box.new(@env)
-      output_box = Box.new(@env)
+      input_loader  = BoxLoader.new(@env)
+      output_loader = BoxLoader.new(@env)
 
       if box_arg =~ /\.box$/
-        input_box.load_from_file(box_arg)
+        input_box = input_loader.load_from_file(box_arg)
       else
-        input_box.load_by_name(box_arg)
+        input_box = input_loader.load_by_name(box_arg)
       end
 
-      output_box.prepare_for_output( input_box.name, output_provider_arg)
+      output_box = output_loader.prepare_for_output( input_box.name, output_provider_arg)
 
-      converter.convert(input_box, output_box)
+      converter  = Converter::Converter.create(@env, input_box, output_box)
+      converter.convert
 
-      input_box.cleanup
+      input_loader.cleanup
 
-      @env.ui.info "The box #{output_box.name} (#{output_box.provider.name}) is now ready to use."
+      @env.ui.info "The box #{output_box.name} (#{output_box.provider_name}) is now ready to use."
 
     end
 

data/lib/vagrant-mutate/version.rb

@@ -1,3 +1,3 @@
 module VagrantMutate
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/test/expected_output/virtualbox/kvm/box.xml

@@ -18,9 +18,9 @@
   <on_reboot>restart</on_reboot>
   <on_crash>restart</on_crash>
   <devices>
-    <emulator>/usr/bin/kvm</emulator>
+    <emulator>/usr/bin/qemu-system-x86_64</emulator>
     <disk type='file' device='disk'>
-      <driver name='qemu' type='raw'/>
+      <driver name='qemu' type='qcow2'/>
       <source file='box-disk1.img'/>
       <target dev='vda' bus='virtio'/>
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-mutate
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-03 00:00:00.000000000 Z
+date: 2013-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: archive-tar-minitar
@@ -73,14 +73,16 @@ files:
 - README.md
 - Rakefile
 - lib/vagrant-mutate.rb
-- lib/vagrant-mutate/box.rb
-- lib/vagrant-mutate/converter.rb
+- lib/vagrant-mutate/box/box.rb
+- lib/vagrant-mutate/box/kvm.rb
+- lib/vagrant-mutate/box/libvirt.rb
+- lib/vagrant-mutate/box/virtualbox.rb
+- lib/vagrant-mutate/box_loader.rb
+- lib/vagrant-mutate/converter/converter.rb
+- lib/vagrant-mutate/converter/kvm.rb
+- lib/vagrant-mutate/converter/libvirt.rb
 - lib/vagrant-mutate/errors.rb
 - lib/vagrant-mutate/mutate.rb
-- lib/vagrant-mutate/provider/kvm.rb
-- lib/vagrant-mutate/provider/libvirt.rb
-- lib/vagrant-mutate/provider/provider.rb
-- lib/vagrant-mutate/provider/virtualbox.rb
 - lib/vagrant-mutate/version.rb
 - locales/en.yml
 - templates/kvm/box.xml.erb

data/lib/vagrant-mutate/converter.rb

@@ -1,119 +0,0 @@
-require 'fileutils'
-
-module VagrantMutate
-  class Converter
-
-    def initialize(env)
-      @env = env
-      @logger = Log4r::Logger.new('vagrant::mutate')
-      verify_qemu_installed
-      verify_qemu_version
-    end
-
-    def convert(input_box, output_box)
-      @input_box  = input_box
-      @output_box = output_box
-
-      @env.ui.info "Converting #{input_box.name} from #{input_box.provider.name} "\
-        "to #{output_box.provider.name}."
-
-      write_metadata
-      # will have to rethink this if any providers need to alter the vagrantfile
-      copy_vagrantfile
-      output_box.provider.write_specific_files(input_box)
-      write_disk
-    end
-
-    private
-
-    # http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
-    def verify_qemu_installed
-      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
-      end
-      # if we make it here qemu-img command was not found
-      raise Errors::QemuNotFound
-    end
-
-    def verify_qemu_version
-      usage = `qemu-img`
-      if usage =~ /(\d+\.\d+\.\d+)/
-        recommended_version = Gem::Version.new('1.2.0')
-        installed_version = Gem::Version.new($1)
-        if installed_version < recommended_version
-          @env.ui.warn "You have qemu #{installed_version} installed. "\
-            "This version is too old to read some virtualbox boxes. "\
-            "If conversion fails, try upgrading to qemu 1.2.0 or newer."
-        end
-      else
-        raise Errors::ParseQemuVersionFailed
-      end
-    end
-
-
-    def write_metadata
-      metadata = @output_box.provider.generate_metadata(@input_box)
-      begin
-        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
-      end
-      @logger.info "Wrote metadata"
-    end
-
-    def copy_vagrantfile
-      input = File.join( @input_box.dir, 'Vagrantfile' )
-      if File.exists? input
-        output = File.join( @output_box.dir, 'Vagrantfile' )
-        @logger.info "Copying #{input} to #{output}"
-        begin
-          FileUtils.copy_file(input, output)
-        rescue => e
-          raise Errors::WriteVagrantfileFailed, :error_message => e.message
-        end
-      end
-    end
-
-    def write_disk
-      if @input_box.provider.image_format == @output_box.provider.image_format
-        copy_disk
-      else
-        convert_disk
-      end
-    end
-
-    def copy_disk
-      input = File.join( @input_box.dir, @input_box.provider.image_name )
-      output = File.join( @output_box.dir, @output_box.provider.image_name )
-      @logger.info "Copying #{input} to #{output}"
-      begin
-        FileUtils.copy_file(input, output)
-      rescue => e
-        raise Errors::WriteDiskFailed, :error_message => e.message
-      end
-    end
-
-    def convert_disk
-      input_file    = File.join( @input_box.dir, @input_box.provider.image_name )
-      output_file   = File.join( @output_box.dir, @output_box.provider.image_name )
-      input_format  = @input_box.provider.image_format
-      output_format = @output_box.provider.image_format
-
-      command = "qemu-img convert -p -f #{input_format} -O #{output_format} #{input_file} #{output_file}"
-      @logger.info "Running #{command}"
-      unless system(command)
-        raise Errors::WriteDiskFailed, :error_message => "qemu-img exited with status #{$?.exitstatus}"
-      end
-    end
-
-  end
-end

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

@@ -1,57 +0,0 @@
-require 'erb'
-
-module VagrantMutate
-  module Provider
-    class Kvm < Provider
-      def initialize(box)
-          @box              = box
-          @name             = 'kvm'
-          @supported_input  = false,
-          @supported_output = true,
-          @image_format     = 'raw',
-          @image_name       = 'box-disk1.img'
-      end
-
-      def generate_metadata(input_box)
-        metadata = {
-          'provider' => @box.provider.name,
-        }
-      end
-
-      def write_specific_files(input_box)
-        template_path = VagrantMutate.source_root.join('templates', 'kvm', 'box.xml.erb')
-        template = File.read(template_path)
-
-        uuid = nil
-        gui = true
-        disk_bus = 'virtio'
-        name = input_box.name
-        image_type = @image_format
-        disk = @image_name
-        qemu_bin = find_kvm
-        memory = input_box.provider.memory / 1024 # convert bytes to kib
-        cpus = input_box.provider.cpus
-        mac = input_box.provider.mac_address
-        arch = input_box.provider.architecture
-
-        File.open( File.join( @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-kvm', '/usr/bin/kvm',
-                          '/usr/bin/qemu-system-x86_64',
-                          '/usr/bin/qemu-system-i386' ]
-        qemu_bin = qemu_bin_list.detect { |binary| File.exists? binary }
-        unless qemu_bin
-          raise Errors::QemuNotFound
-        end
-        return qemu_bin
-      end
-
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module VagrantMutate
-  module Provider
-    class Libvirt < Provider
-      def initialize(box)
-          @box              = box
-          @name             = 'libvirt'
-          @supported_input  = false,
-          @supported_output = true,
-          @image_format     = 'qcow2',
-          @image_name       = 'box.img'
-      end
-
-      def generate_metadata(input_box)
-        metadata = {
-          'provider' => @box.provider.name,
-          'format'   => 'qcow2',
-          'virtual_size' => ( input_box.virtual_size.to_f / (1024 * 1024 * 1024) ).ceil
-        }
-      end
-
-      def write_specific_files(input_box)
-        # nothing to do here
-      end
-
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module VagrantMutate
-  module Provider
-    class Provider
-      attr_reader :name, :supported_input, :supported_output, :image_format, :image_name
-
-      def self.create(name, box)
-        case name
-        when 'kvm'
-          require_relative 'kvm'
-          Kvm.new(box)
-        when 'libvirt'
-          require_relative 'libvirt'
-          Libvirt.new(box)
-        when 'virtualbox'
-          require_relative 'virtualbox'
-          Virtualbox.new(box)
-        else
-          raise Errors::ProviderNotSupported, :provider => name, :direction => 'input or output'
-        end
-      end
-
-    end
-  end
-end