vagrant-xenserver-jc 0.0.13

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

@@ -0,0 +1,31 @@
+require "log4r"
+require "xmlrpc/client"
+require "vagrant-xenserver/util/uploader"
+require "rexml/document"
+require "json"
+require "xenapi"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class StartVM
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::start_vm")
+        end
+        
+        def call(env)
+          myvm = env[:machine].id
+
+          begin
+            env[:xc].VM.start(myvm,false,false)
+          rescue XenApi::Errors::NoHostsAvailable
+            raise Errors::NoHostsAvailable
+          end
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "log4r"
+require "xmlrpc/client"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class SuspendVM
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::suspend_vm")
+        end
+        
+        def call(env)
+          myvm = env[:machine].id
+          
+          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].task.get_status(suspend_task)
+          if suspend_result != "success"
+            raise Errors::APIError
+          end
+          
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+require "log4r"
+require "xenapi"
+require "vagrant-xenserver/util/uploader"
+require "vagrant-xenserver/util/exnhandler"
+require "rexml/document"
+require "json"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class UploadVHD
+
+        @@lock = Mutex.new
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::upload_vhd")
+        end
+
+        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
+          rescue
+            @logger.error("Error getting virtual size of VHD: #{box_vhd_file}")
+            raise Errors::QemuImgError
+          end
+          return disk_info['virtual-size']
+        end
+
+        def call(env)
+          if env[:machine].provider_config.xva_url.nil?
+            box_vhd_file = env[:machine].box.directory.join('box.vhd').to_s
+
+            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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require "log4r"
+require "xmlrpc/client"
+require "vagrant-xenserver/util/uploader"
+require "rexml/document"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class UploadXVA
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::upload_xva")
+        end
+
+        def call(env)
+          box_name = env[:machine].box.name.to_s
+          box_version = env[:machine].box.version.to_s
+
+          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
+
+            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)
+
+              # 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}"
+
+              uploader_options = {}
+              uploader_options[:ui] = env[:ui]
+              uploader_options[:insecure] = true
+
+              uploader = MyUtil::Uploader.new(box_xva_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"
+
+              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)
+
+              doc = REXML::Document.new(task_result)
+
+              @logger.debug("task_result=\"#{task_result}\"")
+              template_ref = doc.elements['value/array/data/value'].text
+
+              @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)   
+
+              # 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
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+require "log4r"
+require "xmlrpc/client"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class ValidateNetwork
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::validate_network")
+        end
+
+        def call(env)
+          myvm = env[:machine].id
+
+          # only find network without :fowarded port, then sort by name label
+          vifs = env[:machine].config.vm.networks.reject {
+            |k,v| k == :forwarded_port}.sort_by {
+              |k,v| v[:network] || ""}
+
+          # this will hold any vifs with no device (ethX)
+          vifs_unknown = []
+
+          # create a placeholder hash for all vifs
+          # note that eth0 is already used by HIMN, so start with 1
+          eth = Hash.new
+          vifs.count.times do |x|
+            x += 1
+            eth["eth#{x}".to_sym] = {}
+          end
+
+          # Get All networks without HIMN
+          allnetworks = env[:xc].network.get_all_records.reject {
+            |ref,net| net['other_config']['is_host_internal_management_network'] }
+
+          # find the network type (public/external or private/single-server)
+          allnets = {}
+          allnetworks.each do |ref, params|
+            allnets[ref] = params
+            allnets[ref]["network_type"] = params["PIFs"].empty? ? "private_network" : "external_network"
+          end
+          # convert allnets to string for error message
+          allnets_str = allnets.map { |k,v| "#{v['name_label']} (#{v['network_type']})"}.join(", ")
+
+          # foreach vifs which has device defined, assign it to `eth` Hash
+          vifs.each do |k,v|
+            # Check if network name label in configuration matches
+            # the network on Xenserver Host
+            netrefrec = allnets.find { |ref,net| net['name_label'].upcase == v[:network].upcase }
+            (net_ref, net_rec) = netrefrec
+            if net_ref.nil?
+              raise Errors::InvalidNetwork, network: v[:network], allnetwork: allnets_str, vm: env[:machine].name
+            end
+
+            # Assign network UUID/ref
+            v[:net_ref] = net_ref
+
+            # Assign network type
+            v[:network_type] = net_rec["network_type"]
+
+            # no match, assign a device number (ethX) later
+            if v[:device].nil?
+              # vifs_unknown will contains vifs without :device defined
+              # SORTED BY NETWORK NAME LABEL
+              vifs_unknown.push(v)
+            else
+              if v[:device].start_with?("eth") and eth.include?(v[:device].to_sym)
+                eth[v[:device].to_sym] = v
+              else
+                raise "Configration Error in netowrk `#{v[:network]}' for device name `#{v[:device]}'"
+              end
+            end
+          end
+
+          # Populate `eth' hash from the rest of unconfigured vifs
+          vifs_unknown.each do |vif|
+            unconfigured_eth = eth.find {|k,v| v.empty?}[0]
+            vif[:device] = unconfigured_eth.to_s
+            eth[unconfigured_eth.to_sym] = vif
+          end
+
+          # Validate network settings:
+          #   - if `ip' and dhcp is set, raise error
+          #   - ip and netmask must be defined it dhcp is not set
+          #   - external_network
+          #     - can have gateway
+          #   - private_network (internal xenserver host-only network)
+          #     - CANNOT have gateway
+          #     - if `ip' defined, raise error if dhcp is set
+          eth.each do |e, opt|
+            raise Errors::InvalidInterface, eth: e, opt: opt[:proto], net: opt[:network],
+              message: "No IP address is defined" if opt[:proto] == 'static' and opt[:ip].nil?
+
+            raise Errors::InvalidInterface, eth: e, opt: opt[:proto], net: opt[:network],
+              message: "No IP netmask is defined" if opt[:proto] == 'static' and opt[:netmask].nil?
+
+            raise Errors::InvalidInterface, eth: e, opt: opt[:proto], net: opt[:network],
+              message: "Cannot assign IP #{opt[:ip]} here" if opt[:proto] == 'dhcp' and !opt[:ip].nil?
+
+            raise Errors::InvalidInterface, eth: e, opt: opt[:network_type], net: opt[:network],
+              message: "Cannot assign gateway #{opt[:gateway]} here" if opt[:network_type] == "private_network" and !opt[:gateway].nil?
+          end
+
+          # Put eth on global env
+          env[:vifs] = eth
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require "log4r"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      # This action wait for SSH Communicator via HIMN interface is ready
+      class WaitForHIMNCommunicator
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_xenserver::action::wait_himn")
+        end
+
+        def call(env)
+          if env[:machine].provider_config.use_himn
+            env[:machine_ssh_info] = wait_ssh_via_himn(env)
+          end
+
+          @app.call(env)
+        end
+
+        def wait_ssh_via_himn(env)
+          machine = env[:machine]
+          return nil if machine.id.nil?
+
+          # Find the machine
+          networks = env[:xc].network.get_all_records
+
+          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
+
+          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 }
+          command = "ssh '#{machine.provider_config.xs_host}' -l '#{machine.provider_config.xs_username}' \"true &>/dev/null </dev/tcp/#{ip.to_s}/22 && echo open || echo closed\""
+          max_retry = 20
+          begin
+            retries ||= 0
+            ssh_ready = `#{command}`.strip
+            sleep 1
+            raise if ssh_ready == "closed"
+          rescue
+            if retries == max_retry
+              raise Errors::HIMNCommunicatorError
+            end
+            retry if (retries += 1) <= max_retry
+          end
+        end
+      end
+    end
+  end
+end