vagrant-xenserver 0.0.0

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

@@ -0,0 +1,30 @@
+require "log4r"
+require "xmlrpc/client"
+require "vagrant-xenserver/util/uploader"
+require "rexml/document"
+require "json"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class CloneDisk
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::upload_xva")
+        end
+        
+        def call(env)
+          vdi_ref = env[:box_vdi]
+
+          clone = env[:xc].call("VDI.clone", env[:session], vdi_ref, {})['Value']
+
+          env[:my_vdi] = clone
+
+          @logger.info("clone VDI="+clone)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "log4r"
+require "xmlrpc/client"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class ConnectXS
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_xenserver::actions::connect_xs")
+        end
+
+        def call(env)
+          if not env[:session]
+            env[:xc] = XMLRPC::Client.new(env[:machine].provider_config.xs_host, "/", "80")
+            
+            @logger.info("Connecting to XenServer")
+            
+            sess_result = env[:xc].call("session.login_with_password", env[:machine].provider_config.xs_username, env[:machine].provider_config.xs_password,"1.0")
+            
+            if sess_result["Status"] != "Success"
+              raise Errors::LoginError
+            end
+            
+            env[:session] = sess_result["Value"]
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,83 @@
+require "log4r"
+require "xmlrpc/client"
+require "vagrant-xenserver/util/uploader"
+require "rexml/document"
+require "json"
+
+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].call("network.get_all_records",env[:session])['Value']
+
+          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'])
+
+          oim = env[:xc].call("VM.get_by_name_label",env[:session],"Other install media")['Value'][0]
+
+          vm_ref = env[:xc].call("VM.clone",env[:session],oim,env[:machine].box.name.to_s)['Value']
+
+          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].call("VBD.create",env[:session],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].call("VIF.create",env[:session],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")
+          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[:machine].id = vm_ref
+
+          @app.call env
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+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)
+          env[:xc].call("VM.hard_shutdown",env[:session],env[:machine].id)
+          
+          vbds = env[:xc].call("VM.get_VBDs",env[:session],env[:machine].id)['Value']
+          
+          vbds.each { |vbd| 
+            vbd_rec = env[:xc].call("VBD.get_record",env[:session],vbd)['Value']
+            if vbd_rec['type'] == "Disk"
+              env[:xc].call("VDI.destroy",env[:session],vbd_rec['VDI'])
+            end
+          }
+
+          env[:xc].call("VM.destroy",env[:session],env[:machine].id)
+
+          env[:machine].id = nil
+
+          @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/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/maybe_upload_disk.rb

@@ -0,0 +1,84 @@
+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_image_file = env[:machine].box.directory.join('export.xva').to_s
+          box_image_file = "/home/jludlam/devel/vagrant-xenserver/centos-6.5.vhd"
+          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
+
+          task = task_result["Value"]
+
+          url = "http://#{hostname}/import?session_id=#{session}&task_id=#{task}"
+
+          uploader_options = {}
+          uploader_options[:ui] = env[:ui]
+
+          uploader = MyUtil::Uploader.new(box_image_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|
+            @logger.info("ele=" + ele.text)
+          end
+
+          @logger.info("task_result=" + task_result)
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+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)
+          env[:machine_ssh_info] = read_ssh_info(env)
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(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)
+
+          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
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          vifs = vif_result['Value']
+          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}' nc %h %p"
+
+          if not ssh_info[:username]
+            ssh_info[:username] = machine.config.ssh.default.username
+          end
+
+          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::readstate")
+        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?
+
+          result = xc.call("VM.get_record",session,machine.id)
+
+          if result["Status"] != "Success"
+            @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
+  end
+end

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

@@ -0,0 +1,26 @@
+require "log4r"
+require "xmlrpc/client"
+require "vagrant-xenserver/util/uploader"
+require "rexml/document"
+require "json"
+
+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
+          
+          env[:xc].call("VM.start",env[:session],myvm,false,false)
+
+          @app.call env
+        end
+      end
+    end
+  end
+end