vagrant-xenserver-jc 0.0.13

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

@@ -0,0 +1,86 @@
+require "log4r"
+require "xmlrpc/client"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class CreateVIFs
+        def initialize(app, env)
+          @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)
+          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|
+            @logger.info "got an interface: #{type} #{options}"
+
+            if type == :public_network then
+              bridge = options[:bridge]
+              mac = options[:mac] || ''
+              name_label = options[:network] || ''
+
+              if name_label then
+                netrefrec = networks.find { |ref,net| net['name_label']==name_label }
+              else
+                netrefrec = networks.find { |ref,net| net['bridge']==bridge }
+              end
+
+              (net_ref,net_rec) = netrefrec
+              if net_ref.nil? then
+                  @logger.error("Error finding bridge #{bridge} on host")
+                  raise Errors::NoHostsAvailable
+              end
+
+              vif_res = create_vif(env, vm_ref, net_ref, mac)
+
+              @logger.info("vif_res=" + vif_res.to_s)
+            end
+          end
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require "log4r"
+require "xmlrpc/client"
+require "vagrant-xenserver/util/uploader"
+require "rexml/document"
+require "json"
+require "etc"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class CreateVM
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::create_vm")
+        end
+        
+        def call(env)
+          vdi_ref = env[:my_vdi]
+          
+          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
+
+          @logger.info("himn_uuid="+himn_rec['uuid'])
+          
+          username = Etc.getlogin
+          
+          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
+
+          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].VM.clone(oim,vm_name)
+
+          vbd_record = {
+            'VM' => vm_ref,
+            'VDI' => env[:my_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)
+
+          vif_record = {
+            'VM' => vm_ref,
+            'network' => himn_ref,
+            'device' => '0',
+            '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)
+          
+          @logger.info("vif_res=" + vif_res.to_s)
+
+          if env[:machine].provider_config.pv
+            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].VM.set_memory_limits(vm_ref,mem,mem,mem,mem)
+          env[:xc].VM.provision(vm_ref)
+
+          env[:machine].id = vm_ref
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "log4r"
+require "xmlrpc/client"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class DestroyVM
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::destroy_vm")
+        end
+        
+        def call(env)
+          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].VBD.get_record(vbd)
+            if vbd_rec['type'] == "Disk"
+              env[:xc].VDI.destroy(vbd_rec['VDI'])
+            end
+          }
+
+          env[:xc].VM.destroy(env[:machine].id)
+
+          env[:machine].id = nil
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+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.
+
+          template = nil
+
+          Action.getlock.synchronize do
+            templates = env[:xc].VM.get_all_records_where("field \"is_a_template\"=\"true\" and field \"is_a_snapshot\"=\"false\"")
+            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
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module XenServer
+    module Action
+      class DummyMessage
+	def initialize(app, env)
+	  @app = app
+	end
+
+	def call(env)
+	  env[:ui].info(env[:session])
+	end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,23 @@
+require "log4r"
+require "xmlrpc/client"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class HaltVM
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::halt_vm")
+        end
+        
+        def call(env)
+          myvm = env[:machine].id
+          
+          shutdown_result = env[:xc].VM.clean_shutdown(myvm)
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'log4r'
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_xenserver::action::is_created')
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @logger.info("env[:machine].state.id="+env[:machine].state.id.to_s)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'log4r'
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class IsRunning
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_xenserver::action::is_running')
+        end
+
+        def call(env)
+          @logger.info("env[:machine].state.id="+env[:machine].state.id.to_s)
+          env[:result] = env[:machine].state.id == 'Running'
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'log4r'
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class IsSuspended
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_xenserver::action::is_suspended')
+        end
+
+        def call(env)
+          @logger.info("env[:machine].state.id="+env[:machine].state.id.to_s)
+          env[:result] = env[:machine].state.id == 'Suspended'
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require 'nokogiri'
+require 'socket'
+require 'rbconfig'
+
+def os
+    @os ||= (
+      host_os = RbConfig::CONFIG['host_os']
+      case host_os
+      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+        :windows
+      when /darwin|mac os/
+        :macosx
+      when /linux/
+        :linux
+      when /solaris|bsd/
+        :unix
+      else
+        raise Vagrant::Errors::UnknownOS # "unknown os: #{host_os.inspect}"
+      end
+    )
+  end
+
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class PrepareNFSSettings
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+        
+        def initialize(app,env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          @machine = env[:machine]
+          @app.call(env)          
+
+          if using_nfs?
+            @logger.info("Using NFS, preparing NFS settings by reading host IP and machine IP")
+            env[:nfs_host_ip]    = read_host_ip(env[:machine],env)
+            env[:nfs_machine_ip] = env[:xs_host_ip]
+
+            @logger.info("host IP: #{env[:nfs_host_ip]} machine IP: #{env[:nfs_machine_ip]}")
+
+            raise Vagrant::Errors::NFSNoHostonlyNetwork if !env[:nfs_machine_ip] || !env[:nfs_host_ip]
+          end
+        end
+
+        # We're using NFS if we have any synced folder with NFS configured. If
+        # we are not using NFS we don't need to do the extra work to
+        # populate these fields in the environment.
+        def using_nfs?
+          !!synced_folders(@machine)[:nfs]
+        end
+
+        # Returns the IP address of the interface that will route to the xs_host
+        #
+        # @param [Machine] machine
+        # @return [String]
+        def read_host_ip(machine,env)
+          ip = Socket.getaddrinfo(env[:machine].provider_config.xs_host,nil)[0][2]
+          env[:xs_host_ip] = ip
+          def get_local_ip_linux(ip)
+            re = /src ([0-9\.]+)/
+            match = `ip route get to #{ip} | head -n 1`.match re
+            match[1]
+          end
+          def get_local_ip_mac(ip)
+            re = /interface: ([a-z0-9]+)/
+            match = `route get #{ip} | grep interface | head -n 1`.match re
+            interface = match[1]
+            re = /inet ([0-9\.]+)/
+            match = `ifconfig #{interface} inet | tail -1`.match re
+            match[1]
+          end
+          if os == :linux then get_local_ip_linux(ip)
+          elsif os == :macosx then get_local_ip_mac(ip)
+          else raise Vagrant::Errors::UnknownOS # "unknown os: #{host_os.inspect}"
+          end 
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module XenServer
+    module Action
+      class PrepareNFSValidIds
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::action::vm::nfs")
+        end
+
+        def call(env)
+          env[:nfs_valid_ids] = env[:xc].VM.get_all
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require "log4r"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_xenserver::action::read_ssh_info")
+        end
+
+        def call(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_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 }
+
+          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,
+          }
+
+          ssh_info[:proxy_command] = "ssh '#{machine.provider_config.xs_host}' -l '#{machine.provider_config.xs_username}' -W %h:%p"
+
+          if not ssh_info[:username]
+            ssh_info[:username] = machine.config.ssh.default.username
+          end
+
+          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
+end

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

@@ -0,0 +1,35 @@
+require "log4r"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class ReadState
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::read_state")
+        end
+
+        def call(env)
+          @logger.debug("XXXXX In ReadState")
+          env[:machine_state_id] = read_state(env[:xc], env[:session], env[:machine])
+          @logger.debug("state="+env[:machine_state_id].to_s)
+          @app.call(env)
+        end
+
+        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)
+            return result['power_state']
+          rescue
+            @logger.info("Machine not found. Assuming it has been destroyed.")
+            machine.id = nil
+            return :not_created
+          end
+        end
+      end
+    end
+  end
+end

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

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