vagrant-xenserver 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0cec68cbb7af733bd030330a8220b43d73c06b4
-  data.tar.gz: 6d87fb9aa7926950fbaa93df55d395bcfd190032
+  metadata.gz: 863a12a0d4f0def43d9e81dc02d35aa71d2c2992
+  data.tar.gz: 72bb9e377c24be9a249c3d23cbe827d9be1c47a4
 SHA512:
-  metadata.gz: f993a2dd8ff4737cf27bc81f3e255af09e3f7f4723c2640ff741a254dc2df846c730e69a65a159b1705bbd1d0fdb9fb818e401f63c3da6e2a23751411258d7ae
-  data.tar.gz: 2ec61fc6f4638f0a77e9051d7744c95e3e43147f5ee7db75c2b90dbda821dfcf0c32e9a1fea6f0749e4ace92f85747e4e185a3295aaeaa44699e15b06849b44d
+  metadata.gz: 24a88789435fd29b0f6a9c43bc31275bb4a260a444ccc1c9fd4e6f54c8d4f60d7ef99864aab262feebd229ca77dbf1b631875354c34cd7977869b74ebfe8eaf1
+  data.tar.gz: aa8d34e7b64708274df83a175c396fc49f44ac2e3e57daabb59e5b839225284362454e62b96074577bc4c92fc48d0408a6f218bbcb6cbde85209a14bc681919c

data/lib/vagrant-xenserver/action.rb

@@ -6,6 +6,11 @@ module VagrantPlugins
     module Action
       include Vagrant::Action::Builtin
       @logger = Log4r::Logger.new('vagrant::xenserver::action')
+      @xvalock = Mutex.new
+
+      def self.getlock
+        @xvalock
+      end
 
       def self.action_boot
 	Vagrant::Action::Builder.new.tap do |b| 
@@ -212,6 +217,21 @@ module VagrantPlugins
         end
       end
 
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |env1, b2|
+            if !env1[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConfigValidate
+            b2.use action_halt
+            b2.use action_boot
+          end
+        end
+      end
+
       action_root = Pathname.new(File.expand_path('../action', __FILE__))
       autoload :CreateVIFs, action_root.join("create_vifs")
       autoload :ConnectXS, action_root.join("connect_xs")

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

@@ -21,9 +21,12 @@ module VagrantPlugins
           else
             vm_name = env[:machine].provider_config.name
           end
-          
-          vm = env[:xc].VM.clone(template_ref, vm_name)
-          env[:xc].VM.provision(vm)
+
+          vm = nil
+          Action.getlock.synchronize do
+            vm = env[:xc].VM.clone(template_ref, vm_name)
+            env[:xc].VM.provision(vm)
+          end
 
           env[:machine].id = vm
 

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

@@ -12,22 +12,28 @@ module VagrantPlugins
         end
 
         def call(env)
-          if not env[:xc]
-            config = env[:machine].provider_config
+          config = env[:machine].provider_config
+
+          # Only even try to connect if we've got a hostname
+          if (not env[:xc]) && (not config.xs_host.nil?)
             uri = URI::Generic.new(config.xs_use_ssl ? 'https' : 'http',
-                                nil,
-                                config.xs_host,
-                                config.xs_port,
-                                nil,
-                                "/",
-                                nil,
-                                nil, nil)
+                              nil,
+                              config.xs_host,
+                              config.xs_port,
+                              nil,
+                              "/",
+                              nil,
+                              nil, nil)
             env[:xc] = XenApi::Client.new(uri.to_s, timeout = config.api_timeout)
 
             @logger.info("Connecting to XenServer")
 
-            if not env[:xc].login_with_password(config.xs_username, config.xs_password)
+            begin
+              result = env[:xc].login_with_password(config.xs_username, config.xs_password)
+            rescue XenApi::Errors::SessionAuthenticationFailed
               raise Errors::LoginError
+            rescue
+              raise Errors::ConnectionError
             end
 
             @logger.info("Connected to XenServer")
@@ -39,4 +45,3 @@ module VagrantPlugins
     end
   end
 end
-

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

@@ -24,58 +24,59 @@ module VagrantPlugins
             # 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
-            }
+            Action.getlock.synchronize do
+              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]
+              if template.nil?
+                vdi_ref = env[:box_vdi]
 
-              oim = env[:xc].VM.get_by_name_label("Other install media")[0]
+                oim = env[:xc].VM.get_by_name_label("Other install media")[0]
               
-              template_name = "#{box_name}.#{box_version}"
+                template_name = "#{box_name}.#{box_version}"
               
-              template_ref = env[:xc].VM.clone(oim,template_name)
+                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_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)
+                vbd_res = env[:xc].VBD.create(vbd_record)
               
-              @logger.info("vbd_res=" + vbd_res.to_s)
+                @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)
+                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
+                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)
+                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
+                env[:template] = template_ref
               
-            else
-              @logger.info("Found pre-existing template for this box")
-              (template_ref, template_rec) = template
-              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
-            
           end
             
           @app.call env

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

@@ -26,68 +26,73 @@ module VagrantPlugins
           # 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
+          template = nil
 
-            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
+          Action.getlock.synchronize do
+            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)
 
-            task_result = env[:xc].task.get_result(task)
+            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])
 
-            doc = REXML::Document.new(task_result)
+              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)
 
-            @logger.debug("task_result=\"#{task_result}\"")
-            template_ref = doc.elements['value/array/data/value'].text
+              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
 
-            # 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)   
+              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
+              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
           end
-          
+
           @app.call(env)
         end
       end

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

@@ -18,6 +18,7 @@ module VagrantPlugins
 
         def read_state(xc, session, machine)
           return :not_created if machine.id.nil?
+          return :not_created if not machine.id.start_with?("OpaqueRef")
 
           begin
             result = xc.VM.get_record(machine.id)

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

@@ -16,78 +16,80 @@ module VagrantPlugins
           box_name = env[:machine].box.name.to_s
           box_version = env[:machine].box.version.to_s
 
-          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
-          }
+          Action.getlock.synchronize do
+            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
+            }
 
-          box_xva_file = env[:machine].box.directory.join('box.xva').to_s
+            box_xva_file = env[:machine].box.directory.join('box.xva').to_s
 
-          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]
+            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]
 
-            @logger.info("box name=" + env[:machine].box.name.to_s)
-            @logger.info("box version=" + env[:machine].box.version.to_s)
+              @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 = env[:xc].task.create("vagrant-xva-upload",
-                                        "Task to track progress of the XVA upload from vagrant")
+              # 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}"
+              url = "https://#{hostname}/import?session_id=#{env[:xc].xenapi_session}&task_id=#{task}"
 
-            uploader_options = {}
-            uploader_options[:ui] = env[:ui]
-            uploader_options[:insecure] = true
+              uploader_options = {}
+              uploader_options[:ui] = env[:ui]
+              uploader_options[:insecure] = true
 
-            uploader = MyUtil::Uploader.new(box_xva_file, url, uploader_options)
+              uploader = MyUtil::Uploader.new(box_xva_file, url, uploader_options)
 
-            begin
-              uploader.upload!
-            rescue
-              env[:xc].task.cancel(task)
-            end
+              begin
+                uploader.upload!
+              rescue
+                env[:xc].task.cancel(task)
+              end
 
-            task_status = ""
+              task_status = ""
 
-            begin
-              sleep(0.2)
-              task_status = env[:xc].task.get_status(task)
-            end while task_status == "pending"
+              begin
+                sleep(0.2)
+                task_status = env[:xc].task.get_status(task)
+              end while task_status == "pending"
 
-            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
+              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 = env[:xc].task.get_result(task)
+              task_result = env[:xc].task.get_result(task)
 
-            doc = REXML::Document.new(task_result)
+              doc = REXML::Document.new(task_result)
 
-            @logger.debug("task_result=\"#{task_result}\"")
-            template_ref = doc.elements['value/array/data/value'].text
+              @logger.debug("task_result=\"#{task_result}\"")
+              template_ref = doc.elements['value/array/data/value'].text
 
-            @logger.info("template_ref=" + template_ref)
+              @logger.info("template_ref=" + template_ref)
 
-            # 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)   
+              # 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.
+              # 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
+              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
           end
 
           @app.call(env)

data/lib/vagrant-xenserver/errors.rb

@@ -46,7 +46,11 @@ module VagrantPlugins
       class InsufficientSpace < VagrantXenServerError
         error_key(:insufficientspace)
       end
+
+      class ConnectionError < VagrantXenServerError
+        error_key(:connection_error)
+      end
+      
     end
   end
 end
-

data/lib/vagrant-xenserver/plugin.rb

@@ -20,16 +20,49 @@ module VagrantPlugins
       end
 
       provider('xenserver', parallel: true) do
+        # Setup logging and i18n
+        setup_logging
         setup_i18n
 
-	require_relative "provider"
+        # Return the provider
+        require_relative "provider"
         Provider
       end
 
+      # This initializes the internationalization strings.
       def self.setup_i18n
         I18n.load_path << File.expand_path('locales/en.yml',
                                            XenServer.source_root)
         I18n.reload!
+       end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_xenserver")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
       end
     end
   end

data/lib/vagrant-xenserver/version.rb

@@ -1,6 +1,6 @@
 module VagrantPlugins
   module XenServer
-    VERSION = "0.0.12"
+    VERSION = "0.0.13"
   end
 end
 

data/locales/en.yml

@@ -27,3 +27,6 @@ en:
         There is insufficient space available on the SR.
       api_error: |-
         The API call '%{api}' failed with error '%{error}'.
+      connection_error: |-
+        Failed to connect to the XenServer. Please verify "xs_host" setting is correct.
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-xenserver
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - Jon Ludlam
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-24 00:00:00.000000000 Z
+date: 2017-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -134,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Enables Vagrant to manage XenServers.