veewee 0.3.7 → 0.3.9

data/lib/veewee/provider/core/helper/web.rb

@@ -47,7 +47,7 @@ module Veewee
           end
 
           def allow_for_http_request(filename,options) # start in new thread
-            s = server_for_http_request(filename,options.merge({:threaded => true}))
+            s = server_for_http_request(filename,options.merge({:threaded => false}))
             Thread.new { s.start }
           end
 

data/lib/veewee/provider/core/helper/winrm.rb

@@ -34,6 +34,7 @@ module Veewee
             rescue HTTPClient::ReceiveTimeoutError,HTTPClient::ConnectTimeoutError
               @winrm_up = false
             end
+            @winrm_up
           end
 
 
@@ -62,6 +63,8 @@ module Veewee
                       @connected = true
                       return true
                     rescue Exception => e
+                      @winrm_up = false
+                      next if e.message =~ /401/ # 2012 gives 401 errors
                       puts e.inspect
                       puts e.message
                       puts e.backtrace.inspect

data/lib/veewee/provider/core/provider.rb

@@ -41,7 +41,7 @@ module Veewee
 
             return box
           rescue Error => ex
-            ui.error "Could not instante the box #{name} with provider #{type} ,#{ex}"
+            ui.error "Could not instantiate the box #{name} with provider #{type} ,#{ex}"
             raise
           end
         end

data/lib/veewee/provider/kvm/box.rb

@@ -8,6 +8,7 @@ require 'veewee/provider/kvm/box/up'
 require 'veewee/provider/kvm/box/halt'
 require 'veewee/provider/kvm/box/poweroff'
 require 'veewee/provider/kvm/box/destroy'
+require 'veewee/provider/kvm/box/export_vagrant'
 
 require 'veewee/provider/kvm/box/helper/ip'
 require 'veewee/provider/kvm/box/helper/ssh_options'
@@ -33,6 +34,12 @@ module Veewee
 
           @connection=::Fog::Compute[:libvirt]
 
+          # Many of the existing templates have disk_format set to "VDI"
+          # Use "qcow2" instead as a vagrant-libvirt-compatible default
+          definition.disk_format.downcase!
+          definition.disk_format = "qcow2" if definition.disk_format == "vdi"
+          @volume_name = "#{name}.#{definition.disk_format}"
+
         end
 
       end # End Class

data/lib/veewee/provider/kvm/box/create.rb

@@ -1,4 +1,5 @@
 require 'nokogiri'
+require 'fileutils'
 
 module Veewee
   module Provider
@@ -7,82 +8,49 @@ module Veewee
         # Create a new vm
         def create(options={})
           # Assemble the Virtualmachine and set all the memory and other stuff"
-
-
           create_server(options)
           create_volume(options)
+          add_virtio_drivers if File.exists?(File.join(definition.path, 'Autounattend.xml'))
           self.create_floppy("virtualfloppy.img")
+          FileUtils.move(File.join(definition.path, 'Autounattend.xml.virtio'), File.join(definition.path, 'Autounattend.xml')) if File.exists?(File.join(definition.path, 'Autounattend.xml.virtio'))
+          add_floppy unless definition.floppy_files.nil?
         end
 
         def create_server(options)
-          #memory_size,cpu_count, volume_size
-          # verify some stuff before trying to create the server
-          kvm_options = definition.kvm[:vm_options][0]
-          # Create the "server"
-          attributes = {
-            :name => name,
-            :memory_size => definition.memory_size.to_i*1024,
-            :cpus => definition.cpu_count.to_i,
-            :volume_capacity => "#{definition.disk_size}M",
-            :domain_type => options['use_emulation'] ? 'qemu': 'kvm',
-            :iso_file => definition.iso_file,
-            :arch => definition.os_type_id.end_with?("_64") ? "x86_64" : "i686",
-            :iso_dir => env.config.veewee.iso_dir
-          }
-          # Check for network stuff (default, bridge)
-          check_network(kvm_options, attributes)
-          # Check for pool (storage)
-          check_pool(kvm_options, attributes)
-          s=@connection.servers.create(attributes)
-        end
 
-        # Check the network availability of the defined network for kvm
-        def check_network(options, attributes)
-          env.logger.info "Checking network"
-          if options.nil? or options.empty? or options["network_type"].nil? or options["network_type"] == "network"
-            check_default_network
-            attributes[:network_interface_type] = "network"
-          elsif options["network_type"] == "bridge"
-            options["network_bridge_name"].nil?
-            if options["network_bridge_name"].nil?
-              raise Veewee::Error, "You need to specify a 'network_bridge_name' if you plan to use 'bridge' as network type"
-            else
-              attributes[:network_interface_type] = "bridge"
-              attributes[:network_bridge_name] = "#{options["network_bridge_name"]}"
-            end
-          else
-            raise Veewee::Error, "You specified a 'network_type' that isn't known (#{options["network_type"]})"
+          # set volume pool name to user specified volume pool and fall back to first available volume pool
+          if options["pool_name"]
+            raise Veewee::Error, "Specified storage pool #{options["pool_name"]} does not exist" if @connection.pools.select { |pool| pool.name == options["pool_name"] }.empty?
+            volume_pool_name = options["pool_name"]
           end
-        end
+          volume_pool_name ||= @connection.pools.first.name
+          env.logger.info "Using storage pool #{volume_pool_name}"
 
-        def check_default_network
-          # Nothing specified, we check for default network
-          conn = ::Libvirt::open("qemu:///system")
-          networks=conn.list_networks
-          if networks.count < 1
-            raise Veewee::Error, "You need at least one (active) network defined or customize your definition. This needs to be available if you connect to qemu:///system."
+          # set network name to user specified network and fall back to default network or first available network
+          if options["network_name"]
+            raise Veewee::Error, "Specified network #{options["network_name"]} does not exist" if @connection.networks.select { |net| net.name == options["network_name"] }.empty?
+            network_name = options["network_name"]
           end
-        end
+          network_name ||= "default" unless @connection.networks.select { |net| net.name == 'default' }.empty?
+          network_name ||= @connection.networks.first.name
+          env.logger.info "Using network #{network_name}"
 
-        # Check the given pool and append to attributes
-        # Note: volume_pool_name is not working in fog library version 1.7.0.
-        #       This should be fixed in the next release.
-        def check_pool(options, attributes)
-          env.logger.info "Checking pool storage"
-          if not options.nil? and not options.empty? and not options["pool_name"].nil?
-            conn = ::Libvirt::open("qemu:///system")
-            # Checking if the pool exists and if it is active
-            begin
-              storage = conn.lookup_storage_pool_by_name(options["pool_name"])
-            rescue Libvirt::RetrieveError
-              raise Veewee::Error, "You've specified an non-existent storage pool (#{options["pool_name"]})"
-            end
-            if storage.active?
-              attributes[:volume_pool_name] = options["pool_name"]
-            else
-              raise Veewee::Error, "The storage pool '#{options["pool_name"]}' is not started. Start it and restart the creation process"
-            end
-          end
+          # Create the "server"
+          attributes = {
+              :name => name,
+              :memory_size => definition.memory_size.to_i*1024,
+              :cpus => definition.cpu_count.to_i,
+              :volume_capacity => "#{definition.disk_size}M",
+              :domain_type => options['use_emulation'] ? 'qemu' : 'kvm',
+              :iso_file => definition.iso_file,
+              :arch => definition.os_type_id.end_with?("_64") ? "x86_64" : "i686",
+              :iso_dir => env.config.veewee.iso_dir,
+              :volume_pool_name => volume_pool_name,
+              :volume_format_type => definition.disk_format,
+              :network_nat_network => network_name
+          }
+
+          @connection.servers.create(attributes)
         end
 
         # Create the volume of a new vm
@@ -91,11 +59,12 @@ module Veewee
         end
 
         def add_floppy
+          env.logger.info 'Adding floppy disk'
           # Get a raw libvirt connection
-          c=@connection.raw
+          conn = @connection.client
 
           # Retrieve the domain
-          domain=c.lookup_domain_by_name(name)
+          domain=conn.lookup_domain_by_name(name)
 
           # Retrieve the existing XML from the domain
           domain_xml=domain.xml_desc
@@ -107,8 +76,8 @@ module Veewee
           devices=domain_doc.xpath('/domain/devices').first
           # The floppy xml representation
           floppy_xml="<disk type='file' device='floppy'><driver name='qemu' type='raw'/><source file='"+
-          File.join(definitition.path,"virtualfloppy.img") +
-          "'/><target dev='fda' bus='fdc'/><address type='drive' controller='0' bus='0' unit='0'/></disk>
+              File.join(definition.path, "virtualfloppy.img") +
+              "'/><target dev='fda' bus='fdc'/><address type='drive' controller='0' bus='0' unit='0'/></disk>
           <controller type='fdc' index='0'>"
 
           # Convert the floppy xml to nokogiri
@@ -121,10 +90,92 @@ module Veewee
           new_xml=domain_doc.to_xml
 
           # Undefine the existing domain
-          s.undefine
+          domain.undefine
+
+          # Re-define the domain
+          conn.define_domain_xml(new_xml)
+        end
+
+        def add_virtio_drivers
+          env.logger.info 'Adding virtio drivers for windows system to the virtual machine'
+          # Get a raw libvirt connection
+          conn = @connection.client
+
+          # Retrieve the domain
+          domain=conn.lookup_domain_by_name(name)
+
+          # Retrieve the existing XML from the domain
+          domain_xml=domain.xml_desc
+
+          # Convert the xml nokogiri doc
+          domain_doc=Nokogiri::XML(domain_xml)
+
+          # Find the device section
+          devices=domain_doc.xpath('/domain/devices').first
+
+          # get latest version of virtio drivers
+          url ='http://alt.fedoraproject.org/pub/alt/virtio-win/latest/images/bin/'
+          filename = open(url).read.scan(/\"(virtio-win-.*.iso)\"/).first.first
+          download_iso(url + filename, filename)
+          path = File.join(env.config.veewee.iso_dir, filename)
+
+          # The disk xml representation
+          disk_xml="<disk type='file' device='cdrom'><driver name='qemu' type='raw'/><source file='" +
+              path + "'/><target dev='hdd' bus='ide'/></disk>"
+
+          # Convert the disk xml to nokogiri
+          disk_doc=Nokogiri::XML(disk_xml)
+
+          # Add the floppy to the devices section
+          devices.add_child(disk_doc.root)
+
+          # Get the raw xml of the changed document
+          new_xml=domain_doc.to_xml
+
+          # Undefine the existing domain
+          domain.undefine
 
           # Re-define the domain
-          c.define_domain_xml(new_xml)
+          conn.define_domain_xml(new_xml)
+
+          env.logger.info 'Add search path for virtio drivers to Autounattend.xml'
+          # parse Autoattend.xml to document
+          FileUtils.copy(File.join(definition.path, 'Autounattend.xml'), File.join(definition.path, 'Autounattend.xml.virtio'))
+          doc = Nokogiri::XML.parse(File.read(File.join(definition.path, 'Autounattend.xml')))
+          # determine platform and windows version
+          platform = definition.os_type_id.end_with?("_64") ? "amd64" : "x86"
+          version = case definition.os_type_id.downcase
+                      when /windows-?7/
+                        'win7'
+                      when /windows-?2008/
+                        'win7'
+                      when /windows-?8/
+                        'win8'
+                      when /xp/
+                        'xp'
+                      when /vista/
+                        'vista'
+                      else
+                        raise 'could not determine windows version'
+                    end
+          # create new element
+          component=Nokogiri::XML(%Q|<component name="Microsoft-Windows-PnpCustomizationsWinPE"
+processorArchitecture="#{platform}" publicKeyToken="31bf3856ad364e35"
+language="neutral" versionScope="nonSxS"
+xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+<DriverPaths>
+<PathAndCredentials wcm:keyValue="1" wcm:action="add">
+<Path>e:\\#{version}\\#{platform}</Path>
+</PathAndCredentials>
+</DriverPaths>
+</component>|)
+          doc.xpath('//unattend:settings[@pass="windowsPE"]', 'unattend' => 'urn:schemas-microsoft-com:unattend').first.add_child component.root
+
+          file = File.open(File.join(definition.path, 'Autounattend.xml'), 'w')
+          file.write(doc)
+          file.close
+
         end
 
       end #End Module

data/lib/veewee/provider/kvm/box/destroy.rb

@@ -4,7 +4,7 @@ module Veewee
       module BoxCommand
         # Destroy a vm
         def destroy(options={})
-          if @connection.servers.all(:name => name).nil?
+          unless exists_vm? or exists_volume?
             env.ui.error "Error:: You tried to destroy a non-existing box '#{name}'"
             raise Veewee::Error,"Error:: You tried to destroy a non-existing box '#{name}'"
           end
@@ -12,9 +12,9 @@ module Veewee
           self.poweroff if running?
           destroy_vm if exists_vm?
 
-          vol_exists=!@connection.volumes.all(:name => "#{name}.img").nil?
-          env.logger.info "Volume exists? : #{vol_exists}"
-          destroy_volume if exists_volume?
+          vol_exists = exists_volume?
+          env.logger.info "Volume exists?: #{vol_exists}"
+          destroy_volume if vol_exists
         end
 
         def destroy_vm
@@ -23,8 +23,7 @@ module Veewee
         end
 
         def destroy_volume
-          vol=@connection.volumes.all(:name => "#{name}.img").first
-          vol.destroy
+          @connection.volumes.all(:name => @volume_name).first.destroy
         end
       end # End Module
 

data/lib/veewee/provider/kvm/box/export_vagrant.rb

@@ -0,0 +1,143 @@
+require 'pathname'
+require 'erb'
+module Veewee
+  module Provider
+    module Kvm
+      module BoxCommand
+        def export_vagrant(options)
+
+          # Check if box already exists
+          unless self.exists?
+            ui.info "#{name} is not found, maybe you need to build it first?"
+            exit
+          end
+
+          if File.exists?("#{name}.box")
+            if options["force"]
+              env.logger.debug("#{name}.box exists, but --force was provided")
+              env.logger.debug("removing #{name}.box first")
+              FileUtils.rm("#{name}.box")
+              env.logger.debug("#{name}.box removed")
+            else
+              raise Veewee::Error, "export file #{name}.box already exists. Use --force option to overwrite."
+            end
+          end
+
+          # We need to shutdown first
+          if self.running?
+            ui.info "Vagrant requires the box to be shutdown, before it can export"
+            ui.info "Sudo also needs to work for user #{definition.ssh_user}"
+            ui.info "Performing a clean shutdown now."
+
+            self.halt
+
+            #Wait for state poweroff
+            while (self.running?) do
+              ui.info ".",{:new_line => false}
+              sleep 1
+            end
+            ui.info ""
+            ui.info "Machine #{name} is powered off cleanly"
+          end
+
+          # Vagrant requires a relative path for output of boxes
+          boxdir=Pathname.new(Dir.pwd)
+          full_path=File.join(boxdir,name+".box")
+          path1=Pathname.new(full_path)
+          path2=Pathname.new(Dir.pwd)
+          box_path=File.expand_path(path1.relative_path_from(path2).to_s)
+
+          if File.exists?("#{box_path}")
+            raise Veewee::Error, "box #{name}.box already exists"
+          end
+
+          # Create temp directory
+          current_dir = FileUtils.pwd
+          ui.info "Creating a temporary directory for export"
+          tmp_dir = Dir.mktmpdir
+          env.logger.debug("Create temporary directory for export #{tmp_dir}")
+
+          server = @connection.servers.all(:name => name).first
+          volume = server.volumes.find(&:path)
+
+          begin
+            ui.info "Adding additional files"
+
+            # Handling the Vagrantfile
+            if options["vagrantfile"].to_s == ""
+              # Prepare the vagrant erb
+              template_path = File.join(File.dirname(__FILE__),'..','templates',"Vagrantfile")
+              ui.info("Creating Vagrantfile")
+              FileUtils.cp(template_path, File.join(tmp_dir,'Vagrantfile'))
+            else
+              f = options["vagrantfile"]
+              env.logger.debug("Including vagrantfile: #{f}")
+              FileUtils.cp(f,File.join(tmp_dir,"Vagrantfile"))
+            end
+
+            # Inject a metadata.json file
+            File.open(File.join(tmp_dir, 'metadata.json'), 'w') {|f| f.write(template_metadatafile(volume.capacity)) }
+
+            # Handling other includes
+            unless options["include"].nil?
+              options["include"].each do |f|
+                env.logger.debug("Including file: #{f}")
+                FileUtils.cp(f,File.join(tmp_dir,f))
+              end
+            end
+
+            # Final image must be qcow2 for vagrant-libvirt
+            # This also allows us to make the image sparse again after zerodisk.sh has run
+            # both qemu-img and virt-sparsify can do this, but the latter is better
+            volume_out = File.join(tmp_dir, 'box.img')
+            if options['sparsify']
+              ui.info "Sparsifying and copying the box volume"
+              command = "virt-sparsify --machine-readable #{volume.path} --convert qcow2 #{volume_out}"
+            else
+              ui.info "Copying the box volume"
+              command = "qemu-img convert -O qcow2 #{volume.path} #{volume_out}"
+            end
+            env.logger.debug("Source volume: #{volume.path}")
+            env.logger.debug(command)
+            shell_exec command
+
+            ui.info "Packaging the box"
+            FileUtils.cd(tmp_dir)
+            command = "tar -cvf '#{box_path}' ."
+            env.logger.debug(command)
+            shell_exec (command)
+
+          rescue Errno::ENOENT => ex
+            raise Veewee::Error, "#{ex}"
+          rescue Error => ex
+            raise Veewee::Error, "Packaging of the box failed:\n+#{ex}"
+          ensure
+            # Remove temporary directory
+            ui.info "Cleaning up temporary directory"
+            env.logger.debug("Removing temporary dir #{tmp_dir}")
+            FileUtils.rm_rf(tmp_dir)
+
+            FileUtils.cd(current_dir)
+          end
+          ui.info ""
+          ui.info "To import it into vagrant type:"
+          ui.info "vagrant box add '#{name}' '#{box_path}'"
+          ui.info ""
+          ui.info "To use it:"
+          ui.info "vagrant init '#{name}'"
+          ui.info "vagrant up --provider=libvirt"
+          ui.info "vagrant ssh"
+        end
+
+        def template_metadatafile size
+          {
+            "provider"     => "libvirt",
+            "format"       => "qcow2",
+            "virtual_size" => size+1  # fog rounds down
+          }.to_json
+        end
+
+      end #Module
+    end #Module
+  end #Module
+end #Module