vagrant-xenserver 0.0.11 → 0.0.12

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

@@ -0,0 +1,86 @@
+require "log4r"
+require "xmlrpc/client"
+require "vagrant-xenserver/util/uploader"
+require "rexml/document"
+require "json"
+require "etc"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class CreateTemplate
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::create_template")
+        end
+        
+        def call(env)
+          if env[:template].nil?
+
+            box_name = env[:machine].box.name.to_s
+            box_version = env[:machine].box.version.to_s
+
+            # No template - that means it wasn't a downloaded XVA.
+            # Let's create a VM and attach the uploaded VDI to it.
+            # First see if we've done that already:
+            
+            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
+            }
+
+            if template.nil?
+              vdi_ref = env[:box_vdi]
+
+              oim = env[:xc].VM.get_by_name_label("Other install media")[0]
+              
+              template_name = "#{box_name}.#{box_version}"
+              
+              template_ref = env[:xc].VM.clone(oim,template_name)
+              
+              vbd_record = {
+                'VM' => template_ref,
+                'VDI' => env[:box_vdi],
+                'userdevice' => '0',
+                'bootable' => true,
+                'mode' => 'RW',
+                'type' => 'Disk',
+                'unpluggable' => false,
+                'empty' => false,
+                'other_config' => {},
+                'qos_algorithm_type' => '',
+                'qos_algorithm_params' => {}
+              }
+              
+              vbd_res = env[:xc].VBD.create(vbd_record)
+              
+              @logger.info("vbd_res=" + vbd_res.to_s)
+
+              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)
+              
+              if env[:machine].provider_config.pv
+                env[:xc].VM.set_HVM_boot_policy(template_ref,"")
+                env[:xc].VM.set_PV_bootloader(template_ref,"pygrub")
+              end
+
+              mem = ((env[:machine].provider_config.memory) * (1024*1024)).to_s
+              env[:xc].VM.set_memory_limits(template_ref,mem,mem,mem,mem)
+
+              env[:template] = template_ref
+              
+            else
+              @logger.info("Found pre-existing template for this box")
+              (template_ref, template_rec) = template
+              env[:template] = template_ref
+            end
+            
+          end
+            
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -9,40 +9,61 @@ module VagrantPlugins
           @app = app
           @logger = Log4r::Logger.new("vagrant::xenserver::actions::create_vifs")
         end
-        
+
+        def create_vif(env, vm, network, mac)
+          vif_devices = env[:xc].VM.get_allowed_VIF_devices(vm)
+
+          vif_record = {
+            'VM' => vm,
+            'network' => network,
+            'device' => vif_devices[0],
+            'MAC' => mac,
+            'MTU' => '1500',
+            'other_config' => {},
+            'qos_algorithm_type' => '',
+            'qos_algorithm_params' => {},
+            'locking_mode' => 'network_default',
+            'ipv4_allowed' => [],
+            'ipv6_allowed' => []
+          }
+
+          vif_res = env[:xc].VIF.create(vif_record)
+
+          return vif_res
+        end
+
         def call(env)
-          myvm = env[:machine].id
+          vm_ref = env[:machine].id
+
+          networks = env[:xc].network.get_all_records
+
+          # Remove all current VIFs
+          current_vifs = env[:xc].VM.get_VIFs(vm_ref)
+          current_vifs.each { |vif| env[:xc].VIF.destroy(vif) }
+
+          # If a HIMN VIF has been asked for, create one
+          if env[:machine].provider_config.use_himn
+            himn = networks.find { |ref,net| net['other_config']['is_host_internal_management_network'] }
+            (himn_ref,himn_rec) = himn
+
+            @logger.debug("himn="+himn.to_s)
+
+            create_vif(env, vm_ref, himn_ref, '')
+          end
+
 
           env[:machine].config.vm.networks.each do |type, options|
-            next if type == :forwarded_port
             @logger.info "got an interface: #{type} #{options}"
 
             if type == :public_network then
               bridge = options[:bridge]
-
-              networks = env[:xc].call("network.get_all_records",env[:session])['Value']
+              mac = options[:mac] || ''
 
               netrefrec = networks.find { |ref,net| net['bridge']==bridge }
               (net_ref,net_rec) = netrefrec
 
-              vif_devices = env[:xc].call("VM.get_allowed_VIF_devices",env[:session],myvm)['Value']
-              
-              vif_record = {
-                'VM' => myvm,
-                'network' => net_ref,
-                'device' => vif_devices[0],
-                'MAC' => '',
-                'MTU' => '1500',
-                'other_config' => {},
-                'qos_algorithm_type' => '',
-                'qos_algorithm_params' => {},
-                'locking_mode' => 'network_default',
-                'ipv4_allowed' => [],
-                'ipv6_allowed' => []
-              }
-              
-              vif_res = env[:xc].call("VIF.create",env[:session],vif_record)
-          
+              vif_res = create_vif(env, vm_ref, net_ref, mac)
+
               @logger.info("vif_res=" + vif_res.to_s)
             end
           end

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

@@ -17,7 +17,7 @@ module VagrantPlugins
         def call(env)
           vdi_ref = env[:my_vdi]
           
-          networks = env[:xc].call("network.get_all_records",env[:session])['Value']
+          networks = env[:xc].network.get_all_records
 
           himn = networks.find { |ref,net| net['other_config']['is_host_internal_management_network'] }
           (himn_ref,himn_rec) = himn
@@ -26,14 +26,18 @@ module VagrantPlugins
           
           username = Etc.getlogin
           
-          oim = env[:xc].call("VM.get_by_name_label",env[:session],"Other install media")['Value'][0]
+          oim = env[:xc].VM.get_by_name_label("Other install media")[0]
 
           box_name = env[:machine].box.name.to_s
           box_version = env[:machine].box.version.to_s
 
-          vm_name = "#{username}/#{box_name}/#{box_version}"
+          if env[:machine].provider_config.name.nil?
+            vm_name = "#{username}/#{box_name}/#{box_version}"
+          else
+            vm_name = env[:machine].provider_config.name
+          end
 
-          vm_ref = env[:xc].call("VM.clone",env[:session],oim,vm_name)['Value']
+          vm_ref = env[:xc].VM.clone(oim,vm_name)
 
           vbd_record = {
             'VM' => vm_ref,
@@ -49,7 +53,7 @@ module VagrantPlugins
             'qos_algorithm_params' => {}
           }
 
-          vbd_res = env[:xc].call("VBD.create",env[:session],vbd_record)
+          vbd_res = env[:xc].VBD.create(vbd_record)
           
           @logger.info("vbd_res=" + vbd_res.to_s)
 
@@ -67,19 +71,19 @@ module VagrantPlugins
             'ipv6_allowed' => []
           }
 
-          vif_res = env[:xc].call("VIF.create",env[:session],vif_record)
+          vif_res = env[:xc].VIF.create(vif_record)
           
           @logger.info("vif_res=" + vif_res.to_s)
 
           if env[:machine].provider_config.pv
-            env[:xc].call("VM.set_HVM_boot_policy",env[:session],vm_ref,"")
-            env[:xc].call("VM.set_PV_bootloader",env[:session],vm_ref,"pygrub")
+            env[:xc].VM.set_HVM_boot_policy(vm_ref,"")
+            env[:xc].VM.set_PV_bootloader(vm_ref,"pygrub")
           end
 
           mem = ((env[:machine].provider_config.memory) * (1024*1024)).to_s
 
-          env[:xc].call("VM.set_memory_limits",env[:session],vm_ref,mem,mem,mem,mem)
-          env[:xc].call("VM.provision",env[:session],vm_ref)
+          env[:xc].VM.set_memory_limits(vm_ref,mem,mem,mem,mem)
+          env[:xc].VM.provision(vm_ref)
 
           env[:machine].id = vm_ref
 

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

@@ -11,18 +11,21 @@ module VagrantPlugins
         end
         
         def call(env)
-          env[:xc].call("VM.hard_shutdown",env[:session],env[:machine].id)
-          
-          vbds = env[:xc].call("VM.get_VBDs",env[:session],env[:machine].id)['Value']
+          begin
+            env[:xc].VM.hard_shutdown(env[:machine].id)
+          rescue
+          end
+
+          vbds = env[:xc].VM.get_VBDs(env[:machine].id)
           
           vbds.each { |vbd| 
-            vbd_rec = env[:xc].call("VBD.get_record",env[:session],vbd)['Value']
+            vbd_rec = env[:xc].VBD.get_record(vbd)
             if vbd_rec['type'] == "Disk"
-              env[:xc].call("VDI.destroy",env[:session],vbd_rec['VDI'])
+              env[:xc].VDI.destroy(vbd_rec['VDI'])
             end
           }
 
-          env[:xc].call("VM.destroy",env[:session],env[:machine].id)
+          env[:xc].VM.destroy(env[:machine].id)
 
           env[:machine].id = nil
 

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

@@ -0,0 +1,96 @@
+require "log4r"
+require "xmlrpc/client"
+require "vagrant-xenserver/util/uploader"
+require "vagrant-xenserver/util/exnhandler"
+require "rexml/document"
+require "vagrant/util/busy"
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class DownloadXVA
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::download_xva")
+        end
+        
+        def call(env)
+          xva_url = env[:machine].provider_config.xva_url
+
+          box_name = env[:machine].box.name.to_s
+          box_version = env[:machine].box.version.to_s
+
+          @logger.info("xva_url="+xva_url.to_s)
+          # Check whether we've already downloaded a VM from this URL
+          # When we do, we set an other_config key 'xva_url', so we
+          # can just scan through the VMs looking for it.
+          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
+          }
+
+          @logger.info("template="+template.to_s)
+
+          if template.nil? && (not xva_url.nil?)
+            # No template, let's download it.
+            pool=env[:xc].pool.get_all
+            default_sr=env[:xc].pool.get_default_SR(pool[0])
+
+            env[:ui].output("Downloading XVA. This may take some time. Source URL: "+xva_url)
+            task = env[:xc].Async.VM.import(xva_url, default_sr, false, false)
+
+            begin
+              sleep(2.0)
+              task_status = env[:xc].task.get_status(task)
+              task_progress = env[:xc].task.get_progress(task) * 100.0
+              output = "Progress: #{task_progress.round(0)}%"
+              env[:ui].clear_line
+              env[:ui].detail(output, new_line: false)
+            end while task_status == "pending"
+
+            env[:ui].clear_line
+
+            if task_status != "success"
+	    # Task failed - let's find out why:
+	      error_list = env[:xc].task.get_error_info(task)
+              MyUtil::Exnhandler.handle("Async.VM.import", error_list)
+            end
+
+            task_result = env[:xc].task.get_result(task)
+
+            doc = REXML::Document.new(task_result)
+
+            @logger.debug("task_result=\"#{task_result}\"")
+            template_ref = doc.elements['value/array/data/value'].text
+
+            # 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,"xva_url",xva_url)
+            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
+          else
+            (template_ref, template_rec) = template
+            env[:template] = template_ref
+          end
+          
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -13,12 +13,8 @@ module VagrantPlugins
         def call(env)
           myvm = env[:machine].id
           
-          shutdown_result = env[:xc].call("VM.clean_shutdown",env[:session],myvm)
+          shutdown_result = env[:xc].VM.clean_shutdown(myvm)
 
-          if shutdown_result["Status"] != "Success"
-            raise Errors::APIError
-          end
-          
           @app.call env
         end
       end

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

@@ -8,7 +8,7 @@ module VagrantPlugins
         end
 
         def call(env)
-          env[:nfs_valid_ids] = env[:xc].call("VM.get_all",env[:session])['Value']
+          env[:nfs_valid_ids] = env[:xc].VM.get_all
           @app.call(env)
         end
       end

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

@@ -12,30 +12,33 @@ module VagrantPlugins
         end
 
         def call(env)
-          env[:machine_ssh_info] = read_ssh_info(env)
+          if env[:machine].provider_config.use_himn
+            env[:machine_ssh_info] = read_ssh_info_himn(env)
+          else
+            env[:machine_ssh_info] = read_ssh_info(env)
+          end
 
           @app.call(env)
         end
 
-        def read_ssh_info(env)
+        def read_ssh_info_himn(env)
           machine = env[:machine]
           return nil if machine.id.nil?
 
           # Find the machine
-          networks = env[:xc].call("network.get_all_records",env[:session])['Value']
-          vif_result = env[:xc].call("VM.get_VIFs",env[:session],machine.id)
+          networks = env[:xc].network.get_all_records
 
-          himn = networks.find { |ref,net| net['other_config']['is_host_internal_management_network'] }
-          (himn_ref,himn_rec) = himn
-          
-          if vif_result['Status']=='Failure'
-            # The machine can't be found
+          begin
+            vifs = env[:xc].VM.get_VIFs(machine.id)
+          rescue
             @logger.info("Machine couldn't be found, assuming it got destroyed.")
             machine.id = nil
             return nil
           end
 
-          vifs = vif_result['Value']
+          himn = networks.find { |ref,net| net['other_config']['is_host_internal_management_network'] }
+          (himn_ref,himn_rec) = himn
+
           assigned_ips = himn_rec['assigned_ips']
           (vif,ip) = assigned_ips.find { |vif,ip| vifs.include? vif }
 
@@ -46,15 +49,48 @@ module VagrantPlugins
             :forward_agent => machine.config.ssh.forward_agent,
             :forward_x11   => machine.config.ssh.forward_x11,
           }
-          
+
           ssh_info[:proxy_command] = "ssh '#{machine.provider_config.xs_host}' -l '#{machine.provider_config.xs_username}' nc %h %p"
 
           if not ssh_info[:username]
             ssh_info[:username] = machine.config.ssh.default.username
           end
 
-          ssh_info
+          return ssh_info
+        end
+
+        def read_ssh_info(env)
+          machine = env[:machine]
+          return nil if machine.id.nil?
+
+          gm = env[:xc].VM.get_guest_metrics(machine.id)
+
+          begin
+            networks = env[:xc].VM_guest_metrics.get_networks(gm)
+          rescue
+            return nil
+          end
+
+          ip = networks["0/ip"]
+          if ip.nil?
+            return nil
+          end
+
+          ssh_info = {
+            :host          => ip,
+            :port          => machine.config.ssh.guest_port,
+            :username      => machine.config.ssh.username,
+            :forward_agent => machine.config.ssh.forward_agent,
+            :forward_x11   => machine.config.ssh.forward_x11,
+          }
+
+          if not ssh_info[:username]
+            ssh_info[:username] = machine.config.ssh.default.username
+          end
+
+          return ssh_info
         end
+
       end
     end
   end