vagrant-xenserver 0.0.11 → 0.0.12

data/lib/vagrant-xenserver/action/read_state.rb

@@ -19,15 +19,14 @@ module VagrantPlugins
         def read_state(xc, session, machine)
           return :not_created if machine.id.nil?
 
-          result = xc.call("VM.get_record",session,machine.id)
-
-          if result["Status"] != "Success"
+          begin
+            result = xc.VM.get_record(machine.id)
+            return result['power_state']
+          rescue
             @logger.info("Machine not found. Assuming it has been destroyed.")
             machine.id = nil
             return :not_created
           end
-          
-          return result["Value"]['power_state']
         end
       end
     end

data/lib/vagrant-xenserver/action/resume_vm.rb

@@ -13,11 +13,11 @@ module VagrantPlugins
         def call(env)
           myvm = env[:machine].id
           
-          resume_task = env[:xc].call("Async.VM.resume",env[:session],myvm,false,false)['Value']
-          while env[:xc].call("task.get_status",env[:session],resume_task)['Value'] == 'pending' do
+          resume_task = env[:xc].Async.VM.resume(myvm,false,false)
+          while env[:xc].task.get_status(resume_task) == 'pending' do
               sleep 1
           end
-          resume_result = env[:xc].call("task.get_status",env[:session],resume_task)['Value']
+          resume_result = env[:xc].task.get_status(resume_task)
           if resume_result != "success"
             raise Errors::APIError
           end

data/lib/vagrant-xenserver/action/set_vm_params.rb

@@ -0,0 +1,28 @@
+require "log4r"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class SetVMParams
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::set_vm_params")
+        end
+        
+        def call(env)
+          myvm = env[:machine].id
+
+          if env[:machine].provider_config.pv
+            env[:xc].VM.set_HVM_boot_policy(myvm,"")
+            env[:xc].VM.set_PV_bootloader(myvm,"pygrub")
+          end
+
+          mem = ((env[:machine].provider_config.memory) * (1024*1024)).to_s
+          env[:xc].VM.set_memory_limits(myvm,mem,mem,mem,mem)
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xenserver/action/start_vm.rb

@@ -3,6 +3,7 @@ require "xmlrpc/client"
 require "vagrant-xenserver/util/uploader"
 require "rexml/document"
 require "json"
+require "xenapi"
 
 module VagrantPlugins
   module XenServer
@@ -15,8 +16,12 @@ module VagrantPlugins
         
         def call(env)
           myvm = env[:machine].id
-          
-          env[:xc].call("VM.start",env[:session],myvm,false,false)
+
+          begin
+            env[:xc].VM.start(myvm,false,false)
+          rescue XenApi::Errors::NoHostsAvailable
+            raise Errors::NoHostsAvailable
+          end
 
           @app.call env
         end

data/lib/vagrant-xenserver/action/suspend_vm.rb

@@ -13,11 +13,11 @@ module VagrantPlugins
         def call(env)
           myvm = env[:machine].id
           
-          suspend_task = env[:xc].call("Async.VM.suspend",env[:session],myvm)['Value']
-          while env[:xc].call("task.get_status",env[:session],suspend_task)['Value'] == 'pending' do
+          suspend_task = env[:xc].Async.VM.suspend(myvm)
+          while env[:xc].task.get_status(suspend_task) == 'pending' do
               sleep 1
           end
-          suspend_result = env[:xc].call("task.get_status",env[:session],suspend_task)['Value']
+          suspend_result = env[:xc].task.get_status(suspend_task)
           if suspend_result != "success"
             raise Errors::APIError
           end

data/lib/vagrant-xenserver/action/upload_vhd.rb

@@ -1,6 +1,7 @@
 require "log4r"
-require "xmlrpc/client"
+require "xenapi"
 require "vagrant-xenserver/util/uploader"
+require "vagrant-xenserver/util/exnhandler"
 require "rexml/document"
 require "json"
 
@@ -15,130 +16,144 @@ module VagrantPlugins
           @app = app
           @logger = Log4r::Logger.new("vagrant::xenserver::actions::upload_vhd")
         end
-        
-        def call(env)
-          box_vhd_file = env[:machine].box.directory.join('box.vhd').to_s
-
-          hostname = env[:machine].provider_config.xs_host
-          session = env[:session]
-
-          @logger.info("box name=" + env[:machine].box.name.to_s)
-          @logger.info("box version=" + env[:machine].box.version.to_s)
-
-          # Find out if it has already been uploaded
-          vdis = env[:xc].call("VDI.get_all_records", env[:session])['Value']
-          md5=`dd if=#{box_vhd_file} bs=1M count=1 | md5sum | cut '-d ' -f1`.strip
-
-          @logger.info("md5=#{md5}")
-
-          vdi_tag = "vagrant:" + env[:machine].box.name.to_s + "/" + md5
 
-          vdi_ref_rec = vdis.find { |reference,record|
-                @logger.info(record['tags'].to_s)
-                record['tags'].include?(vdi_tag) 
-            }
-          
-          if not vdi_ref_rec
-            @@lock.synchronize do
-            # Find out virtual size of the VHD
-            disk_info={}
+        def get_vhd_size(box_vhd_file)
+          # Find out virtual size of the VHD
+          disk_info={}
+          begin
             begin
               disk_info=JSON.parse(IO.popen(["qemu-img", "info",box_vhd_file,"--output=json"]).read) 
             rescue JSON::ParserError
               size=`qemu-img info #{box_vhd_file} | grep "virtual size" | cut "-d(" -f2 | cut "-d " -f1`
               disk_info['virtual-size']=size.strip
             end
-            virtual_size = disk_info['virtual-size']
-            @logger.info("virtual_size=#{virtual_size}")
-            pool=env[:xc].call("pool.get_all",env[:session])['Value'][0]
-            default_sr=env[:xc].call("pool.get_default_SR",env[:session],pool)['Value']
-            @logger.info("default_SR="+default_sr)
-            vdi_record = {
-              'name_label' => 'Vagrant disk',
-              'name_description' => 'Base disk uploaded for the vagrant box '+env[:machine].box.name.to_s+' v'+env[:machine].box.version.to_s,
-              'SR' => default_sr,
-              'virtual_size' => "#{virtual_size}",
-              'type' => 'user',
-              'sharable' => false,
-              'read_only' => false,
-              'other_config' => {},
-              'xenstore_data' => {},
-              'sm_config' => {},
-              'tags' => [] }                                                                                      
- 
-            vdi_result=env[:xc].call("VDI.create",env[:session],vdi_record)['Value']
-
-            @logger.info("created VDI: " + vdi_result.to_s)
-            vdi_uuid = env[:xc].call("VDI.get_uuid",env[:session],vdi_result)['Value']
-            @logger.info("uuid: "+vdi_uuid)
-
-            # Create a task to so we can get the result of the upload
-            task_result = env[:xc].call("task.create", env[:session], "vagrant-vhd-upload",
-                                        "Task to track progress of the XVA upload from vagrant")
-            
-            if task_result["Status"] != "Success"
-              raise Errors::APIError
-            end
-            
-            task = task_result["Value"]
-            
-            url = "https://#{hostname}/import_raw_vdi?session_id=#{session}&task_id=#{task}&vdi=#{vdi_result}&format=vhd"
-            
-            uploader_options = {}
-            uploader_options[:ui] = env[:ui]
-            uploader_options[:insecure] = true
-            
-            uploader = MyUtil::Uploader.new(box_vhd_file, url, uploader_options)
-            
-            begin
-              uploader.upload!
-            rescue Errors::UploaderInterrupted
-              env[:ui].info(I18n.t("vagrant.xenserver.action.upload_xva.interrupted"))
-              raise
-            end
-            
-            task_status = ""
-            
-            begin
-              sleep(0.2)
-              task_status_result = env[:xc].call("task.get_status",env[:session],task)
-              if task_status_result["Status"] != "Success"
-                raise Errors::APIError
-              end
-              task_status = task_status_result["Value"]
-            end while task_status == "pending"
-            
-            @logger.info("task_status="+task_status)
-            
-            if task_status != "success"
-              raise Errors::APIError
-            end
-            
-            task_result_result = env[:xc].call("task.get_result",env[:session],task)
-            if task_result_result["Status"] != "Success"
-              raise Errors::APIError
-            end
-            
-            task_result = task_result_result["Value"]
-            
-            doc = REXML::Document.new(task_result)
-            
-            doc.elements.each('value/array/data/value') do |ele|
-              vdi = ele.text
-            end
-            
-            @logger.info("task_result=" + task_result)
+          rescue
+            @logger.error("Error getting virtual size of VHD: #{box_vhd_file}")
+            raise Errors::QemuImgError
+          end
+          return disk_info['virtual-size']
+        end
 
-            tag_result=env[:xc].call("VDI.add_tags",env[:session],vdi_result,vdi_tag)
-            @logger.info("task_result=" + tag_result.to_s)
+        def call(env)
+          if env[:machine].provider_config.xva_url.nil?
+            box_vhd_file = env[:machine].box.directory.join('box.vhd').to_s
 
-            env[:box_vdi] = vdi_result
-            end
-          else
-            (reference,record) = vdi_ref_rec
-            env[:box_vdi] = reference
-            @logger.info("box_vdi="+reference)
+            if File.exist?(box_vhd_file)
+              hostname = env[:machine].provider_config.xs_host
+              session = env[:xc].xenapi_session
+
+              @logger.info("box name=" + env[:machine].box.name.to_s)
+              @logger.info("box version=" + env[:machine].box.version.to_s)
+
+              md5=`dd if=#{box_vhd_file} bs=1M count=1 | md5sum | cut '-d ' -f1`.strip
+
+              @logger.info("md5=#{md5}")
+
+              # Find out if it has already been uploaded
+              @@lock.synchronize do
+
+                vdis = env[:xc].VDI.get_all_records
+
+                vdi_tag = "vagrant:" + env[:machine].box.name.to_s + "/" + md5
 
+                vdi_ref_rec = vdis.find { |reference,record|
+                  @logger.info(record['tags'].to_s)
+                  record['tags'].include?(vdi_tag)
+                }
+
+                if not vdi_ref_rec
+                  virtual_size = get_vhd_size(box_vhd_file)
+                  @logger.info("virtual_size=#{virtual_size}")
+                  pool=env[:xc].pool.get_all
+                  default_sr=env[:xc].pool.get_default_SR(pool[0])
+                  @logger.info("default_SR="+default_sr)
+
+                  # Verify the default SR is valid:
+                  begin
+                    env[:xc].SR.get_uuid(default_sr)
+                  rescue
+                    raise Errors::NoDefaultSR
+                  end
+
+                  vdi_record = {
+                    'name_label' => 'Vagrant disk',
+                    'name_description' => 'Base disk uploaded for the vagrant box '+env[:machine].box.name.to_s+' v'+env[:machine].box.version.to_s,
+                    'SR' => default_sr,
+                    'virtual_size' => "#{virtual_size}",
+                    'type' => 'user',
+                    'sharable' => false,
+                    'read_only' => false,
+                    'other_config' => {},
+                    'xenstore_data' => {},
+                    'sm_config' => {},
+                    'tags' => [] }
+
+                  begin
+                    vdi_result=env[:xc].VDI.create(vdi_record)
+                  rescue XenApi::Errors::GenericError => e
+                    MyUtil::Exnhandler.handle_xenapiexn("VDI.create",e,@logger)
+                  end
+
+                  @logger.info("created VDI: " + vdi_result.to_s)
+                  vdi_uuid = env[:xc].VDI.get_uuid(vdi_result)
+                  @logger.info("uuid: "+vdi_uuid)
+
+                  # Create a task to so we can get the result of the upload
+                  task = env[:xc].task.create("vagrant-vhd-upload",
+                                              "Task to track progress of the XVA upload from vagrant")
+
+                  url = "https://#{hostname}/import_raw_vdi?session_id=#{session}&task_id=#{task}&vdi=#{vdi_result}&format=vhd"
+
+                  uploader_options = {}
+                  uploader_options[:ui] = env[:ui]
+                  uploader_options[:insecure] = true
+
+                  uploader = MyUtil::Uploader.new(box_vhd_file, url, uploader_options)
+
+                  begin
+                    uploader.upload!
+                  rescue
+                    env[:xc].task.cancel(task)
+                  end
+
+                  task_status = ""
+
+                  begin
+                    sleep(0.2)
+                    task_status = env[:xc].task.get_status(task)
+                  end while task_status == "pending"
+
+                  @logger.info("task_status="+task_status)
+
+                  if task_status != "success"
+	            # Task failed - let's find out why:
+	            error_list = env[:xc].task.get_error_info(task)
+                    MyUtil::Exnhandler.handle("import HTTP handler", error_list)
+                  end
+
+                  task_result = env[:xc].task.get_result(task)
+
+                  doc = REXML::Document.new(task_result)
+
+                  doc.elements.each('value/array/data/value') do |ele|
+                    vdi = ele.text
+                  end
+
+                  @logger.info("task_result=" + task_result)
+
+                  tag_result=env[:xc].VDI.add_tags(vdi_result,vdi_tag)
+
+                  @logger.info("Added tags")
+
+                  env[:box_vdi] = vdi_result
+                else
+                  (reference,record) = vdi_ref_rec
+                  env[:box_vdi] = reference
+                  @logger.info("box_vdi="+reference)
+
+                end
+              end
+            end
           end
 
           @app.call(env)

data/lib/vagrant-xenserver/action/upload_xva.rb

@@ -11,73 +11,86 @@ module VagrantPlugins
           @app = app
           @logger = Log4r::Logger.new("vagrant::xenserver::actions::upload_xva")
         end
-        
+
         def call(env)
-          #box_image_file = env[:machine].box.directory.join('export.xva').to_s
-          box_image_file = "/home/jludlam/devel/vagrant-xenserver/test.xva"
-          hostname = env[:machine].provider_config.xs_host
-          session = env[:session]
-
-          @logger.info("box name=" + env[:machine].box.name.to_s)
-          @logger.info("box version=" + env[:machine].box.version.to_s)
-
-          # Create a task to so we can get the result of the upload
-          task_result = env[:xc].call("task.create", env[:session], "vagrant-xva-upload",
-                        "Task to track progress of the XVA upload from vagrant")
-          
-          if task_result["Status"] != "Success"
-            raise Errors::APIError
-          end
+          box_name = env[:machine].box.name.to_s
+          box_version = env[:machine].box.version.to_s
 
-          task = task_result["Value"]
+          templates = env[:xc].VM.get_all_records_where("field \"is_a_template\"=\"true\"")
+          template = templates.detect { |vm,vmr|
+            vmr["other_config"]["box_name"] == box_name &&
+              vmr["other_config"]["box_version"] == box_version
+          }
 
-          url = "https://#{hostname}/import?session_id=#{session}&task_id=#{task}"
+          box_xva_file = env[:machine].box.directory.join('box.xva').to_s
 
-          uploader_options = {}
-          uploader_options[:ui] = env[:ui]
-          uploader_options[:insecure] = true
+          if File.exist?(box_xva_file) && template.nil?
+            #box_image_file = env[:machine].box.directory.join('export.xva').to_s
+            hostname = env[:machine].provider_config.xs_host
+            session = env[:session]
 
-          uploader = MyUtil::Uploader.new(box_image_file, url, uploader_options)
+            @logger.info("box name=" + env[:machine].box.name.to_s)
+            @logger.info("box version=" + env[:machine].box.version.to_s)
 
-          begin
-            uploader.upload!
-          rescue Errors::UploaderInterrupted
-            env[:ui].info(I18n.t("vagrant.xenserver.action.upload_xva.interrupted"))
-            raise
-          end
+            # Create a task to so we can get the result of the upload
+            task = env[:xc].task.create("vagrant-xva-upload",
+                                        "Task to track progress of the XVA upload from vagrant")
+
+            url = "https://#{hostname}/import?session_id=#{env[:xc].xenapi_session}&task_id=#{task}"
 
-          task_status = ""
+            uploader_options = {}
+            uploader_options[:ui] = env[:ui]
+            uploader_options[:insecure] = true
 
-          begin
-            sleep(0.2)
-            task_status_result = env[:xc].call("task.get_status",env[:session],task)
-            if task_status_result["Status"] != "Success"
-              raise Errors::APIError
+            uploader = MyUtil::Uploader.new(box_xva_file, url, uploader_options)
+
+            begin
+              uploader.upload!
+            rescue
+              env[:xc].task.cancel(task)
             end
-            task_status = task_status_result["Value"]
-          end while task_status == "pending"
 
-          @logger.info("task_status="+task_status)
+            task_status = ""
 
-          if task_status != "success"
-            raise Errors::APIError
-          end
+            begin
+              sleep(0.2)
+              task_status = env[:xc].task.get_status(task)
+            end while task_status == "pending"
 
-          task_result_result = env[:xc].call("task.get_result",env[:session],task)
-          if task_result_result["Status"] != "Success"
-            raise Errors::APIError
-          end
+            if task_status != "success"
+	      # Task failed - let's find out why:
+	      error_list = env[:xc].task.get_error_info(task)
+              MyUtil::Exnhandler.handle("VM.import", error_list)
+            end
 
-          task_result = task_result_result["Value"]
+            task_result = env[:xc].task.get_result(task)
 
-          doc = REXML::Document.new(task_result)
+            doc = REXML::Document.new(task_result)
 
-          doc.elements.each('value/array/data/value') do |ele|
-            @logger.info("ele=" + ele.text)
-          end
+            @logger.debug("task_result=\"#{task_result}\"")
+            template_ref = doc.elements['value/array/data/value'].text
+
+            @logger.info("template_ref=" + template_ref)
 
-          @logger.info("task_result=" + task_result)
+            # Make sure it's really a template, and add the xva_url to other_config:
+            env[:xc].VM.set_is_a_template(template_ref,true)
+            env[:xc].VM.add_to_other_config(template_ref,"box_name",box_name)
+            env[:xc].VM.add_to_other_config(template_ref,"box_version",box_version)   
+
+            # Hackity hack: HVM booting guests don't need to set the bootable flag
+            # on their VBDs, but PV do. Let's set bootable=true on VBD device=0
+            # just in case.
+
+            vbds = env[:xc].VM.get_VBDs(template_ref)
+            vbds.each { |vbd|
+              if env[:xc].VBD.get_userdevice(vbd) == "0"
+                env[:xc].VBD.set_bootable(vbd, true)
+              end
+            }
+            env[:template] = template_ref
+          end
 
+          @app.call(env)
         end
       end
     end