vagrant-kvm 0.1.4 → 0.1.5

data/Rakefile

@@ -1,6 +1,5 @@
 require 'rubygems'
 require 'bundler/setup'
-require 'rspec/core/rake_task'
 
 # Immediately sync all stdout so that tools like buildbot can
 # immediately load in the output.
@@ -13,3 +12,27 @@ Dir.chdir(File.expand_path("../", __FILE__))
 # This installs the tasks that help with gem creation and
 # publishing.
 Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+namespace :box do
+  desc 'Downloads and adds vagrant box for testing.'
+  task :add do
+    system 'bundle exec vagrant box add vagrant-kvm-specs http://cloud-images.ubuntu.com/vagrant/precise/current/precise-server-cloudimg-amd64-vagrant-disk1.box'
+  end
+
+  desc 'Prepares VirtualBox box for usage with KVM.'
+  task :prepare do
+    system 'bundle exec vagrant plugin install vagrant-mutate'
+    system 'bundle exec vagrant mutate vagrant-kvm-specs kvm'
+    system 'bundle exec vagrant box remove vagrant-kvm-specs virtualbox'
+  end
+
+  desc 'Removes testing vagrant box.'
+  task :remove do
+    system 'bundle exec vagrant box remove vagrant-kvm-specs kvm'
+  end
+end
+
+task :default => :spec

data/example_box/README.md

@@ -3,16 +3,16 @@
 Vagrant providers each require a custom provider-specific box format.
 This folder shows the example contents of a box for the `kvm` provider.
 
-There are two box formats for the `kvm` provider:
-1. VirtualBox box - you need to change the provider to `kvm` in the
-   `metadata.json` file, the box will be converted on the fly.
-2. "Native" box - you need a box.xml file (libvirt domain format) and a raw
-   image file (you can convert a .vmdk with qemu-img)
+You need a box.xml file (libvirt domain format), you can use the example
+supplied as a base or use one from a VM you created with other tools. Don't
+forget to change the volume path to just the name of the volume. You should
+use a qcow2 volume in most cases, raw is also supported if you have a good
+reason to use this format.
 
-To turn this into a native box, you need to create a vagrant image and do:
+To turn this into a native box, you need to create an tar archive:
 
-```
+```bash
 $ tar cvzf kvm.box ./metadata.json ./Vagrantfile ./box.xml ./box-disk1.img
 ```
 
-You need a base MAC address and a private network like in the example.
+You need a base MAC address like in the example.

data/lib/vagrant-kvm/action.rb

@@ -15,12 +15,25 @@ module VagrantPlugins
         Vagrant::Action::Builder.new.tap do |b|
           b.use Network
           b.use Provision
-          b.use PruneNFSExports
-          b.use NFS
-          b.use PrepareNFSSettings
+          b.use Vagrant::Action::Builtin::HandleForwardedPortCollisions
+          if Vagrant::VERSION < "1.4.0"
+            b.use PruneNFSExports
+            b.use NFS
+            b.use PrepareNFSSettings
+          else
+            #FIXME
+            b.use PrepareNFSValidIds
+            b.use SyncedFolderCleanup
+            b.use SyncedFolders
+            b.use PrepareNFSSettings
+          end
           b.use SetHostname
           #b.use Customize
+          b.use ForwardPorts
           b.use Boot
+          if Vagrant::VERSION >= "1.3.0"
+            b.use WaitForCommunicator, [:running]
+          end
           b.use ShareFolders
         end
       end
@@ -41,7 +54,13 @@ module VagrantPlugins
                 b3.use ConfigValidate
                 b3.use EnvSet, :force_halt => true
                 b3.use action_halt
-                b3.use PruneNFSExports
+                if Vagrant::VERSION < "1.4.0"
+                  b3.use PruneNFSExports
+                else
+                  b3.use PrepareNFSSettings
+                  b3.use PrepareNFSValidIds
+                  b3.use SyncedFolderCleanup
+                end
                 b3.use Destroy
               else
                 b3.use MessageWillNotDestroy
@@ -63,10 +82,12 @@ module VagrantPlugins
                 b3.use Resume
               end
 
+              b2.use ClearForwardedPorts
               b2.use Call, GracefulHalt, :shutoff, :running do |env2, b3|
                 if !env2[:result]
                   b3.use ForcedHalt
                 end
+                b3.use ResetImagePermission
               end
             else
               b2.use MessageNotCreated
@@ -87,7 +108,14 @@ module VagrantPlugins
 
             b2.use SetupPackageFiles
             b2.use action_halt
-            #b2.use Export
+            if Vagrant::VERSION < "1.4.0"
+              b2.use PruneNFSExports
+            else
+              b2.use PrepareNFSSettings
+              b2.use PrepareNFSValidIds
+              b2.use SyncedFolderCleanup
+            end
+            b2.use Export
             b2.use PackageVagrantfile
             b2.use Package
           end
@@ -143,6 +171,7 @@ module VagrantPlugins
           b.use CheckKvm
           b.use Call, Created do |env, b2|
             if env[:result]
+              b2.use ResumeNetwork
               b2.use Resume
             else
               b2.use MessageNotCreated
@@ -190,12 +219,14 @@ module VagrantPlugins
 
               b3.use Call, IsPaused do |env3, b4|
                 if env3[:result]
+                  b4.use ResumeNetwork
                   b4.use Resume
                   next
                 end
 
                 # The VM is not saved, so we must have to boot it up
                 # like normal. Boot!
+                b4.use PrepareGui
                 b4.use action_boot
               end
             end
@@ -230,6 +261,7 @@ module VagrantPlugins
             # If the VM is NOT created yet, then do the setup steps
             if !env[:result]
               b2.use CheckBox
+              b2.use SetName
               b2.use Import
               b2.use MatchMACAddress
             end
@@ -245,10 +277,13 @@ module VagrantPlugins
       autoload :CheckCreated, action_root.join("check_created")
       autoload :CheckKvm, action_root.join("check_kvm")
       autoload :CheckRunning, action_root.join("check_running")
+      autoload :ClearForwardedPorts, action_root.join("clear_forwarded_ports")
       autoload :Created, action_root.join("created")
       autoload :Destroy, action_root.join("destroy")
       autoload :DestroyConfirm, action_root.join("destroy_confirm")
+      autoload :Export, action_root.join("export")
       autoload :ForcedHalt, action_root.join("forced_halt")
+      autoload :ForwardPorts, action_root.join("forward_ports")
       autoload :Import, action_root.join("import")
       autoload :InitStoragePool, action_root.join("init_storage_pool")
       autoload :IsPaused, action_root.join("is_paused")
@@ -256,11 +291,18 @@ module VagrantPlugins
       autoload :IsSaved, action_root.join("is_saved")
       autoload :MatchMACAddress, action_root.join("match_mac_address")
       autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :MessageNotRunning, action_root.join("message_not_running")
       autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
       autoload :Network, action_root.join("network")
+      autoload :PackageVagrantfile, action_root.join("package_vagrantfile")
+      autoload :Package, action_root.join("package")
+      autoload :PrepareGui, action_root.join("prepare_gui")
       autoload :PrepareNFSSettings, action_root.join("prepare_nfs_settings")
+      autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")
       autoload :PruneNFSExports, action_root.join("prune_nfs_exports")
+      autoload :ResetImagePermission, action_root.join("reset_image_permission")
       autoload :Resume, action_root.join("resume")
+      autoload :ResumeNetwork, action_root.join("resume_network")
       autoload :SetName, action_root.join("set_name")
       autoload :SetupPackageFiles, action_root.join("setup_package_files")
       autoload :ShareFolders, action_root.join("share_folders")

data/lib/vagrant-kvm/action/boot.rb

@@ -9,10 +9,6 @@ module VagrantPlugins
         def call(env)
           @env = env
 
-          if @env[:machine].provider_config.gui
-            env[:machine].provider.driver.set_gui
-          end
-
           # Start up the VM
           env[:ui].info I18n.t("vagrant.actions.vm.boot.booting")
           env[:machine].provider.driver.start

data/lib/vagrant-kvm/action/clear_forwarded_ports.rb

@@ -0,0 +1,53 @@
+#
+#  borrowed from vagrant-lxc
+
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class ClearForwardedPorts
+        include Util::Commands
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::kvm::action::clear_forwarded_ports")
+        end
+
+        def call(env)
+          @env = env
+
+          if redir_pids.any?
+            env[:ui].info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
+            redir_pids.each do |pid|
+              next unless is_redir_pid?(pid)
+              @logger.debug "Killing pid #{pid}"
+              run_command "pkill -TERM -P #{pid}"
+            end
+
+            remove_redir_pids
+          end
+
+          @app.call env
+        end
+
+        protected
+
+        def redir_pids
+          @redir_pids = Dir[@env[:machine].data_dir.join('pids').to_s + "/redir_*.pid"].map do |file|
+            File.read(file).strip.chomp
+          end
+        end
+
+        def is_redir_pid?(pid)
+          `ps -o cmd= #{pid}`.strip.chomp =~ /redir/
+        end
+
+        def remove_redir_pids
+          Dir[@env[:machine].data_dir.join('pids').to_s + "/redir_*.pid"].each do |file|
+            File.delete file
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-kvm/action/forward_ports.rb

@@ -0,0 +1,104 @@
+#
+#  borrowed from vagrant-lxc
+
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class ForwardPorts
+        include Util::Commands
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::kvm::action::forward_ports")
+        end
+
+        def call(env)
+          @env = env
+
+          # Get the ports we're forwarding
+          env[:forwarded_ports] = compile_forwarded_ports(env[:machine].config)
+
+          if @env[:forwarded_ports].any? and not redir_installed?
+            raise Errors::RedirNotInstalled
+          end
+
+          # Warn if we're port forwarding to any privileged ports
+          env[:forwarded_ports].each do |fp|
+            if fp[:host] <= 1024
+              env[:ui].warn I18n.t("vagrant.actions.vm.forward_ports.privileged_ports")
+              break
+            end
+          end
+
+          # Continue, we need the VM to be booted in order to grab its IP
+          @app.call env
+
+          if @env[:forwarded_ports].any?
+            env[:ui].info I18n.t("vagrant.actions.vm.forward_ports.forwarding")
+            forward_ports
+          end
+        end
+
+        def forward_ports
+          @env[:forwarded_ports].each do |fp|
+            message_attributes = {
+              # TODO: Add support for multiple adapters
+              :adapter    => 'eth0',
+              :guest_port => fp[:guest],
+              :host_port  => fp[:host]
+            }
+
+            # TODO: Remove adapter from logging
+            @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.forwarding_entry",
+                                  message_attributes))
+
+            redir_pid = redirect_port(
+              fp[:host_ip],
+              fp[:host],
+              fp[:guest_ip] || @env[:machine].provider.ssh_info[:host],
+              fp[:guest]
+            )
+            store_redir_pid(fp[:host], redir_pid)
+          end
+        end
+
+        private
+
+        def compile_forwarded_ports(config)
+          mappings = {}
+
+          config.vm.networks.each do |type, options|
+            if type == :forwarded_port && options[:id] != 'ssh'
+              mappings[options[:host]] = options
+            end
+          end
+
+          mappings.values
+        end
+
+        def redirect_port(host_ip, host_port, guest_ip, guest_port)
+          params = %W( --lport=#{host_port} --caddr=#{guest_ip} --cport=#{guest_port} )
+          params.unshift "--laddr=#{host_ip}" if host_ip
+          params << '--syslog' if ENV['REDIR_LOG']
+          redir_cmd = "redir #{params.join(' ')} 2>/dev/null"
+
+          @logger.debug "Forwarding port with `#{redir_cmd}`"
+          spawn redir_cmd
+        end
+
+        def store_redir_pid(host_port, redir_pid)
+          data_dir = @env[:machine].data_dir.join('pids')
+          data_dir.mkdir unless data_dir.directory?
+
+          data_dir.join("redir_#{host_port}.pid").open('w') do |pid_file|
+            pid_file.write(redir_pid)
+          end
+        end
+
+        def redir_installed?
+          run_command "which redir > /dev/null"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kvm/action/import.rb

@@ -1,44 +1,123 @@
+require 'etc'
+
 module VagrantPlugins
   module ProviderKvm
     module Action
       class Import
+        include Util
+        include Util::Commands
+
         def initialize(app, env)
           @app = app
+          @logger = Log4r::Logger.new("vagrant::kvm::action::import")
         end
 
         def call(env)
-          env[:ui].info I18n.t("vagrant.actions.vm.import.importing",
+          @env = env
+          @env[:ui].info I18n.t("vagrant.actions.vm.import.importing",
                                :name => env[:machine].box.name)
 
+          provider_config = @env[:machine].provider_config
+
           # Ignore unsupported image types
-          image_type = env[:machine].provider_config.image_type
-          image_type = 'raw' unless image_type == 'qcow2'
-
-          # Import the virtual machine (ovf or libvirt)
-          # if a libvirt XML definition is present we use it
-          # otherwise we convert the OVF
-          storage_path = File.join(env[:tmp_path],"/storage-pool")
-          box_file = env[:machine].box.directory.join("box.xml").to_s
-          if File.file?(box_file)
-            env[:machine].id = env[:machine].provider.driver.import(
-                        box_file, storage_path, image_type)
-          else
-            box_file = env[:machine].box.directory.join("box.ovf").to_s
-            env[:machine].id = env[:machine].provider.driver.import_ovf(
-                        box_file, storage_path, image_type)
+          args={:image_type => provider_config.image_type}
+          args[:image_type] = 'qcow2' unless args[:image_type] == 'raw'
+          # Add memory attribute when specified
+          if provider_config.memory_size
+            args[:memory] = provider_config.memory_size
           end
 
+          # import arguments
+          args = {
+            :image_backing => provider_config.image_backing,
+            :qemu_bin      => provider_config.qemu_bin,
+            :cpus          => provider_config.core_number,
+            :cpu_model     => provider_config.cpu_model,
+            :machine_type  => provider_config.machine_type,
+            :network_model => provider_config.network_model,
+            :video_model   => provider_config.video_model
+          }.merge(args)
+
+          # Import the virtual machine
+          storage_path = File.join(@env[:tmp_path],"/storage-pool")
+          box_file = @env[:machine].box.directory.join("box.xml").to_s
+          raise Errors::KvmBadBoxFormat unless File.file?(box_file)
+
+          # import box volume
+          volume_name = import_volume(storage_path, box_file, args)
+
+          # import the box to a new vm
+          env[:machine].id = @env[:machine].provider.driver.import(box_file, volume_name, args)
+
           # If we got interrupted, then the import could have been
           # interrupted and its not a big deal. Just return out.
-          return if env[:interrupted]
+          return if @env[:interrupted]
 
           # Flag as erroneous and return if import failed
-          raise Vagrant::Errors::VMImportFailure if !env[:machine].id
+          raise Vagrant::Errors::VMImportFailure if !@env[:machine].id
 
           # Import completed successfully. Continue the chain
           @app.call(env)
         end
 
+        def import_volume(storage_path, box_file, args)
+          @logger.debug "Importing volume. Storage path: #{storage_path} " + 
+            "Image Type: #{args[:image_type]}"
+
+          box_disk = @env[:machine].provider.driver.find_box_disk(box_file)
+          new_disk = File.basename(box_disk, File.extname(box_disk)) + "-" +
+            Time.now.to_i.to_s + ".img"
+          old_path = File.join(File.dirname(box_file), box_disk)
+          new_path = File.join(storage_path, new_disk)
+
+          # for backward compatibility, we handle both raw and qcow2 box format
+          box = Util::DiskInfo.new(old_path)
+          if box.type == 'raw' || args[:image_type] == 'raw'
+            args[:image_baking] = false
+            @logger.info "Disable disk image with box image as backing file"
+          end
+
+          if args[:image_type] == 'qcow2' || args[:image_type] == 'raw'
+            # create volume
+            box_name = @env[:machine].config.vm.box
+            driver = @env[:machine].provider.driver
+            userid = Process.uid.to_s
+            groupid = Process.gid.to_s
+            modes = {:dir => '0775', :file => '0664'}
+            label = 'virt_image_t'
+            if driver.host_redhat?
+              # on Redhat/Fedora, permission is controlled
+              # with only SELinux
+              modes = {:dir => '0777',:file => '0666'}
+            elsif driver.host_debian?
+              groupid = Etc.getgrnam('kvm').gid.to_s
+            else
+              # XXX: default
+            end
+            pool_name = 'vagrant_' + userid + '_' + box_name
+            driver.init_storage_directory(
+                :pool_path => File.dirname(old_path), :pool_name => pool_name,
+                :owner => userid, :group => groupid, :mode => modes[:dir])
+            driver.create_volume(
+                :disk_name => new_disk,
+                :capacity => box.capacity,
+                :path => new_path,
+                :image_type => args[:image_type],
+                :box_pool => pool_name,
+                :box_path => old_path,
+                :backing => args[:image_backing],
+                :owner => userid,
+                :group => groupid,
+                :mode => modes[:file],
+                :label => label)
+            driver.free_storage_pool(pool_name)
+          else
+            @logger.info "Image type #{args[:image_type]} is not supported"
+          end
+          # TODO cleanup if interrupted
+          new_disk
+        end
+
         def recover(env)
           if env[:machine].provider.state.id != :not_created
             return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)