vagrant-xenserver 0.0.0

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

@@ -0,0 +1,135 @@
+require "log4r"
+require "xmlrpc/client"
+require "vagrant-xenserver/util/uploader"
+require "rexml/document"
+require "json"
+
+module VagrantPlugins
+  module XenServer
+    module Action
+      class UploadVHD
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::xenserver::actions::upload_xva")
+        end
+        
+        def call(env)
+          box_vhd_file = env[:machine].box.directory.join('box.vhd').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)
+
+          # Find out if it has already been uploaded
+          vdis = env[:xc].call("VDI.get_all_records", env[:session])['Value']
+          
+          vdi_tag = "vagrant:" + env[:machine].box.name.to_s + "/" + env[:machine].box.version.to_s
+
+          vdi_ref_rec = vdis.find { |reference,record|
+                @logger.info(record['tags'].to_s)
+                record['tags'].include?(vdi_tag) 
+            }
+          
+          if not vdi_ref_rec
+
+            # Find out virtual size of the VHD
+            disk_info=JSON.parse(IO.popen(["qemu-img", "info",box_vhd_file,"--output=json"]).read)
+            virtual_size = disk_info['virtual-size']
+            
+            pool=env[:xc].call("pool.get_all",env[:session])['Value'][0]
+            default_sr=env[:xc].call("pool.get_default_SR",env[:session],pool)['Value']
+          @logger.info("default_SR="+default_sr)
+            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' => [] }                                                                                      
+ 
+            vdi_result=env[:xc].call("VDI.create",env[:session],vdi_record)['Value']
+
+            @logger.info("created VDI: " + vdi_result.to_s)
+            vdi_uuid = env[:xc].call("VDI.get_uuid",env[:session],vdi_result)['Value']
+            @logger.info("uuid: "+vdi_uuid)
+
+            # Create a task to so we can get the result of the upload
+            task_result = env[:xc].call("task.create", env[:session], "vagrant-vhd-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_raw_vdi?session_id=#{session}&task_id=#{task}&vdi=#{vdi_result}&format=vhd"
+            
+            uploader_options = {}
+            uploader_options[:ui] = env[:ui]
+            
+            uploader = MyUtil::Uploader.new(box_vhd_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|
+              vdi = ele.text
+            end
+            
+            @logger.info("task_result=" + task_result)
+
+            tag_result=env[:xc].call("VDI.add_tags",env[:session],vdi_result,vdi_tag)
+            @logger.info("task_result=" + tag_result.to_s)
+
+            env[:box_vdi] = vdi_result
+          else
+            (reference,record) = vdi_ref_rec
+            env[:box_vdi] = reference
+            @logger.info("box_vdi="+reference)
+
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-xenserver/action/upload_xva.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/test.xva"
+          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/config.rb

@@ -0,0 +1,57 @@
+require "vagrant"
+
+module VagrantPlugins
+  module XenServer
+    class Config < Vagrant.plugin("2", :config)
+      # The XenServer host name or IP
+      #
+      # @return [String]
+      attr_accessor :xs_host
+
+      # The XenServer username
+      #
+      # @return [String]
+      attr_accessor :xs_username
+
+      # The XenServer password
+      #
+      # @return [String]
+      attr_accessor :xs_password
+
+      # True if the VM should be PV
+      #
+      # @return [Bool]
+      attr_accessor :pv
+
+      # Memory settings
+      #
+      # @return [Int]
+      attr_accessor :memory
+
+      def initialize
+        @xs_host = UNSET_VALUE
+        @xs_username = UNSET_VALUE
+        @xs_password = UNSET_VALUE
+        @pv = UNSET_VALUE
+        @memory = UNSET_VALUE
+      end
+
+      def finalize!
+        @xs_host = nil if @xs_host == UNSET_VALUE
+        @xs_username = nil if @xs_username == UNSET_VALUE
+        @xs_password = nil if @xs_password == UNSET_VALUE
+        @pv = nil if @pv == UNSET_VALUE
+        @memory = 1024 if @memory == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+        errors << I18n.t("vagrant_xenserver.config.host_required") if @xs_host.nil?
+        errors << I18n.t("vagrant_xenserver.config.username_required") if @xs_username.nil?
+        errors << I18n.t("vagrant_xenserver.config.password_required") if @xs_password.nil?
+
+        { "XenServer Provider" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-xenserver/errors.rb

@@ -0,0 +1,29 @@
+require "vagrant"
+
+module VagrantPlugins
+  module XenServer
+    module Errors
+      class VagrantXenServerError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_xenserver.errors")
+      end
+
+      class LoginError < VagrantXenServerError
+        error_key(:login_error)
+      end
+
+      class UploaderInterrupted < VagrantXenServerError
+        error_key(:uploader_interrupted)
+      end
+
+      class UploaderError < VagrantXenServerError
+        error_key(:uploader_error)
+      end
+
+      class APIError < VagrantXenServerError
+        error_key(:api_error)
+      end
+
+    end
+  end
+end
+

data/lib/vagrant-xenserver/plugin.rb

@@ -0,0 +1,29 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant XenServer plugin must be run within Vagrant."
+end
+
+
+module VagrantPlugins
+  module XenServer
+    class Plugin < Vagrant.plugin("2")
+      name "XenServer provider"
+      description <<-DESC
+	This plugin installs a provider that allows Vagrant to manage
+	virtual machines hosted on a XenServer.
+      DESC
+
+      config('xenserver', :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider('xenserver') do
+	require_relative "provider"
+        Provider
+      end
+    end
+  end
+end
+

data/lib/vagrant-xenserver/provider.rb

@@ -0,0 +1,36 @@
+require "vagrant"
+
+module VagrantPlugins
+  module XenServer
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        env = @machine.action('read_ssh_info')
+        env[:machine_ssh_info]
+      end
+
+      def state
+        env = @machine.action("read_state")
+
+        state_id = env[:machine_state_id]
+        
+        Vagrant::MachineState.new(state_id, state_id, state_id)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "XenServer (#{id})"
+      end
+    end
+  end
+end
+

data/lib/vagrant-xenserver/util/uploader.rb

@@ -0,0 +1,215 @@
+require "uri"
+
+require "log4r"
+
+require "vagrant/util/busy"
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module XenServer
+    module MyUtil
+      # This class uploads files using various protocols by subprocessing
+      # to cURL. cURL is a much more capable and complete upload tool than
+      # a hand-rolled Ruby library, so we defer to its expertise.
+      class Uploader
+        # Custom user agent provided to cURL so that requests to URL shorteners
+        # are properly tracked.
+        USER_AGENT = "VagrantXenserver/1.0"
+        
+        attr_reader :source
+        attr_reader :destination
+        
+        def initialize(source, destination, options=nil)
+          options     ||= {}
+          
+          @logger      = Log4r::Logger.new("vagrant::xenserver::util::uploader")
+          @source      = source.to_s
+          @destination = destination.to_s
+          
+          begin
+            url = URI.parse(@destination)
+            if url.scheme && url.scheme.start_with?("http") && url.user
+              auth = "#{url.user}"
+              auth += ":#{url.password}" if url.password
+              url.user = nil
+              url.password = nil
+              options[:auth] ||= auth
+              @destination = url.to_s
+            end
+          rescue URI::InvalidURIError
+            # Ignore, since its clearly not HTTP
+          end
+
+          # Get the various optional values
+          @auth        = options[:auth]
+          @ca_cert     = options[:ca_cert]
+          @ca_path     = options[:ca_path]
+          @continue    = options[:continue]
+          @headers     = options[:headers]
+          @insecure    = options[:insecure]
+          @ui          = options[:ui]
+          @client_cert = options[:client_cert]
+        end
+
+        # This executes the actual upload, uploading the source file
+        # to the destination with the given options used to initialize this
+        # class.
+        #
+        # If this method returns without an exception, the upload
+        # succeeded. An exception will be raised if the upload failed.
+        def upload!
+          options, subprocess_options = self.options
+          options += ["--output", "dummy"]
+          options << @destination
+          options += ["-T", @source]
+
+          # This variable can contain the proc that'll be sent to
+          # the subprocess execute.
+          data_proc = nil
+
+          if @ui
+            # If we're outputting progress, then setup the subprocess to
+            # tell us output so we can parse it out.
+            subprocess_options[:notify] = :stderr
+
+            progress_data = ""
+            progress_regexp = /(\r(.+?))\r/
+
+            # Setup the proc that'll receive the real-time data from
+            # the uploader.
+            data_proc = Proc.new do |type, data|
+              # Type will always be "stderr" because that is the only
+              # type of data we're subscribed for notifications.
+
+              # Accumulate progress_data
+              progress_data << data
+
+              while true
+                # If we have a full amount of column data (two "\r") then
+                # we report new progress reports. Otherwise, just keep
+                # accumulating.
+                match = progress_regexp.match(progress_data)
+                break if !match
+                data = match[2]
+                progress_data.gsub!(match[1], "")
+
+                # Ignore the first \r and split by whitespace to grab the columns
+                columns = data.strip.split(/\s+/)
+
+                # COLUMN DATA:
+                #
+                # 0 - % total
+                # 1 - Total size
+                # 2 - % received
+                # 3 - Received size
+                # 4 - % transferred
+                # 5 - Transferred size
+                # 6 - Average download speed
+                # 7 - Average upload speed
+                # 9 - Total time
+                # 9 - Time spent
+                # 10 - Time left
+                # 11 - Current speed
+
+                output = "Progress: #{columns[0]}% (Rate: #{columns[11]}/s, Estimated time remaining: #{columns[10]})"
+                @ui.clear_line
+                @ui.detail(output, new_line: false)
+              end
+            end
+          end
+
+          @logger.info("Uploader starting upload: ")
+          @logger.info("  -- Source: #{@source}")
+          @logger.info("  -- Destination: #{@destination}")
+
+          begin
+            execute_curl(options, subprocess_options, &data_proc)
+          ensure
+            # If we're outputting to the UI, clear the output to
+            # avoid lingering progress meters.
+            if @ui
+              @ui.clear_line
+
+              # Windows doesn't clear properly for some reason, so we just
+              # output one more newline.
+#              @ui.detail("") if Platform.windows?
+            end
+          end
+
+          # Everything succeeded
+          true
+        end
+
+        def execute_curl(options, subprocess_options, &data_proc)
+          options = options.dup
+          options << subprocess_options
+
+          # Create the callback that is called if we are interrupted
+          interrupted  = false
+          int_callback = Proc.new do
+            @logger.info("Uploader interrupted!")
+            interrupted = true
+          end
+
+          # Execute!
+          result = Vagrant::Util::Busy.busy(int_callback) do
+            Vagrant::Util::Subprocess.execute("curl", *options, &data_proc)
+          end
+
+          # If the upload was interrupted, then raise a specific error
+          raise Errors::UploaderInterrupted if interrupted
+
+          # If it didn't exit successfully, we need to parse the data and
+          # show an error message.
+          if result.exit_code != 0
+            @logger.warn("Uploader exit code: #{result.exit_code}")
+            parts    = result.stderr.split(/\n*curl:\s+\(\d+\)\s*/, 2)
+            parts[1] ||= ""
+            raise Errors::UploaderError, message: parts[1].chomp
+          end
+
+          result
+        end
+
+        # Returns the varoius cURL and subprocess options.
+        #
+        # @return [Array<Array, Hash>]
+        def options
+          # Build the list of parameters to execute with cURL
+          options = [
+                     "--fail",
+                     "--location",
+                     "--max-redirs", "10",
+                     "--user-agent", USER_AGENT,
+                    ]
+
+          options += ["--cacert", @ca_cert] if @ca_cert
+          options += ["--capath", @ca_path] if @ca_path
+          options += ["--continue-at", "-"] if @continue
+          options << "--insecure" if @insecure
+          options << "--cert" << @client_cert if @client_cert
+          options << "-u" << @auth if @auth
+
+          if @headers
+            Array(@headers).each do |header|
+              options << "-H" << header
+            end
+          end
+
+          # Specify some options for the subprocess
+          subprocess_options = {}
+
+          # If we're in Vagrant, then we use the packaged CA bundle
+          if Vagrant.in_installer?
+            subprocess_options[:env] ||= {}
+            subprocess_options[:env]["CURL_CA_BUNDLE"] =
+              File.expand_path("cacert.pem", ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"])
+          end
+
+          return [options, subprocess_options]
+        end
+      end
+    end
+  end
+end