vagrant-xenserver-jc 0.0.13

data/lib/vagrant-xenserver/action.rb

@@ -0,0 +1,272 @@
+require 'vagrant/action/builder'
+require 'log4r'
+
+module VagrantPlugins
+  module XenServer
+    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| 
+          b.use Provision
+          b.use PrepareNFSValidIds
+          b.use SyncedFolderCleanup
+          b.use SyncedFolders
+          b.use Call, IsRunning do |env, b2|
+            if !env[:result]
+              b2.use StartVM
+            end
+          end
+          b.use WaitForHIMNCommunicator
+          b.use WaitForCommunicator, ["Running"]
+          b.use Call, IsCreated do |env,b2|
+            if env[:machine].provider_config.use_himn
+              b2.use ConfigureNetwork
+            end
+          end
+          b.use SetHostname
+          b.use PrepareNFSSettings         
+        end
+      end
+      
+      def self.action_up
+	Vagrant::Action::Builder.new.tap do |b|
+          b.use HandleBox
+          b.use ConfigValidate
+          b.use ConnectXS
+          b.use ValidateNetwork
+          b.use Call, IsCreated do |env,b2|
+            # Create the VM
+            if !env[:result]
+              b2.use UploadVHD
+              b2.use UploadXVA
+              b2.use DownloadXVA
+              b2.use CreateTemplate
+              b2.use CloneVM
+              b2.use SetVMParams
+              b2.use CreateVIFs
+            end
+            b2.use action_boot
+          end
+        end
+      end
+      
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              @logger.info "MessageNotCreated"
+              next
+            end
+            b2.use ConnectXS
+            b2.use Call, IsRunning do |env, b3|
+              if !env[:result]
+                @logger.info "Not running"
+                next
+              end
+              b3.use HaltVM            
+            end
+          end
+        end
+      end
+
+      def self.action_suspend
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              @logger.info "MessageNotCreated"
+              next
+            end
+            b2.use ConnectXS
+            b2.use Call, IsRunning do |env, b3|
+              if !env[:result]
+                @logger.info "Not running"
+                next
+              end
+              b3.use SuspendVM
+            end
+          end
+        end
+      end
+
+      def self.action_resume
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              @logger.info "MessageNotCreated"
+              next
+            end
+            b2.use ConnectXS
+            b2.use Call, IsSuspended do |env, b3|
+              if !env[:result]
+                @logger.info "Not suspended"
+                next
+              end
+              b3.use ResumeVM
+            end
+          end
+        end
+      end
+
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              @logger.info "MessageNotCreated"
+              next
+            end
+            b2.use ConnectXS
+            b2.use DestroyVM
+            b2.use ProvisionerCleanup
+            b2.use PrepareNFSValidIds
+            b2.use SyncedFolderCleanup
+          end
+        end
+      end
+
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectXS
+          b.use ReadState
+        end
+      end
+
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectXS
+          b.use ReadSSHInfo
+        end
+      end
+
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          @logger.info("XXXXX SSH")
+          b.use ConfigValidate
+          b.use Call, IsCreated do | env, b2|
+            if !env[:result]
+#              b2.use MessageNotCreated
+              @logger.info("MessageNotCreate")
+              next
+            end
+
+            b2.use ConnectXS
+            b2.use Call, IsRunning do |env2, b3|
+              if !env2[:result]
+                #b3.use MessageNotRunning
+                @logger.info("MessageNotCreate")
+                next
+              end
+
+              b3.use SSHExec
+              @logger.info("ssh run")
+            end
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          @logger.info("XXXXX SSH")
+          b.use ConfigValidate
+          b.use Call, IsCreated do | env, b2|
+            if !env[:result]
+#              b2.use MessageNotCreated
+              @logger.info("MessageNotCreate")
+              next
+            end
+
+            b2.use ConnectXS
+            b2.use Call, IsRunning do |env2, b3|
+              if !env2[:result]
+                #b3.use MessageNotRunning
+                @logger.info("MessageNotCreate")
+                next
+              end
+
+              b3.use SSHRun
+              @logger.info("ssh run")
+            end
+          end
+        end
+      end
+
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          @logger.info("XXXXX provision")
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              @logger.info("MessageNotCreated")
+              next
+            end
+
+            b2.use ConnectXS
+            b2.use Call, IsRunning do |env2, b3|
+              if !env2[:result]
+                @logger.info("MessageNotRunning")
+                next
+              end
+
+              b3.use Provision
+            end
+          end
+        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")
+      autoload :DummyMessage, action_root.join('dummy')
+      autoload :ReadState, action_root.join('read_state')
+      autoload :IsCreated, action_root.join('is_created')
+      autoload :IsRunning, action_root.join('is_running')
+      autoload :IsSuspended, action_root.join('is_suspended')
+      autoload :UploadXVA, action_root.join('upload_xva')
+      autoload :UploadVHD, action_root.join('upload_vhd')
+      autoload :CloneDisk, action_root.join('clone_disk')
+      autoload :SetVMParams, action_root.join('set_vm_params')
+      autoload :CloneVM, action_root.join('clone_vm')
+      autoload :CreateTemplate, action_root.join('create_template')
+      autoload :DestroyVM, action_root.join('destroy_vm')
+      autoload :StartVM, action_root.join('start_vm')
+      autoload :HaltVM, action_root.join('halt_vm')
+      autoload :SuspendVM, action_root.join('suspend_vm')
+      autoload :ResumeVM, action_root.join('resume_vm')
+      autoload :ReadSSHInfo, action_root.join('read_ssh_info')
+      autoload :PrepareNFSSettings, action_root.join('prepare_nfs_settings')
+      autoload :PrepareNFSValidIds, action_root.join('prepare_nfs_valid_ids')
+      autoload :DownloadXVA, action_root.join('download_xva')
+      autoload :WaitForHIMNCommunicator, action_root.join('wait_himn')
+      autoload :ValidateNetwork, action_root.join('validate_network')
+      autoload :ConfigureNetwork, action_root.join('configure_network')
+    end
+  end
+end
+

data/lib/vagrant-xenserver/config.rb

@@ -0,0 +1,102 @@
+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 port to communicate with the API on XenServer
+      #
+      # @return [Int]
+      attr_accessor :xs_port
+
+      # True if the API should be accessed over SSL/TLS
+      #
+      # @return [Bool]
+      attr_accessor :xs_use_ssl
+
+      # The XenServer username
+      #
+      # @return [String]
+      attr_accessor :xs_username
+
+      # The XenServer password
+      #
+      # @return [String]
+      attr_accessor :xs_password
+
+      # Name of the VM
+      #
+      # @return [String]
+      attr_accessor :name
+
+      # True if the VM should be PV
+      #
+      # @return [Bool]
+      attr_accessor :pv
+
+      # Timeout for commands sent to XenServer
+      #
+      # @return [Int]
+      attr_accessor :api_timeout
+
+      # Memory settings
+      #
+      # @return [Int]
+      attr_accessor :memory
+
+      # XVA URL: If this is set, we'll assume that the XenServer should directly download an XVA from the specified URL
+      #
+      # @return [String]
+      attr_accessor :xva_url
+
+      # Use HIMN: If this is set, we'll use the host-internal-management-network to connect to the VM (proxying via dom0)
+      # Useful if the guest does not have tools installed
+      attr_accessor :use_himn
+
+      def initialize
+        @xs_host = UNSET_VALUE
+        @xs_port = UNSET_VALUE
+        @xs_use_ssl = UNSET_VALUE
+        @xs_username = UNSET_VALUE
+        @xs_password = UNSET_VALUE
+        @name = UNSET_VALUE
+        @pv = UNSET_VALUE
+        @api_timeout = UNSET_VALUE
+        @memory = UNSET_VALUE
+        @xva_url = UNSET_VALUE
+        @use_himn = UNSET_VALUE
+      end
+
+      def finalize!
+        @xs_host = nil if @xs_host == UNSET_VALUE
+        @xs_port = 80 if @xs_port == UNSET_VALUE
+        @xs_use_ssl = false if @xs_use_ssl == UNSET_VALUE
+        @xs_username = nil if @xs_username == UNSET_VALUE
+        @xs_password = nil if @xs_password == UNSET_VALUE
+        @name = nil if @name == UNSET_VALUE
+        @pv = nil if @pv == UNSET_VALUE
+        @api_timeout = 60 if @api_timeout == UNSET_VALUE
+        @memory = 1024 if @memory == UNSET_VALUE
+        @xva_url = nil if @xva_url == UNSET_VALUE
+        @use_himn = false if @use_himn == 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?
+
+        if not (machine.config.vm.networks.any? { |type,options| type == :public_network })
+          errors << I18n.t("vagrant_xenserver.config.himn_required") if not @use_himn
+        end
+        { "XenServer Provider" => errors }
+      end
+    end
+  end
+end
+

data/lib/vagrant-xenserver/errors.rb

@@ -0,0 +1,68 @@
+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
+
+      class UnknownOS < VagrantXenServerError
+        error_key(:unknown_os)
+      end
+
+      class QemuImgError < VagrantXenServerError
+        error_key(:qemuimg_error)
+      end
+
+      class NoDefaultSR < VagrantXenServerError
+        error_key(:nodefaultsr_error)
+      end
+
+      class NoHostsAvailable < VagrantXenServerError
+        error_key(:nohostsavailable_error)
+      end
+
+      class Import404 < VagrantXenServerError
+        error_key(:import404)
+      end
+
+      class InvalidNetwork < VagrantXenServerError
+        error_key(:invalid_network)
+      end
+
+      class InvalidInterface < VagrantXenServerError
+        error_key(:invalid_interface)
+      end
+
+      class InsufficientSpace < VagrantXenServerError
+        error_key(:insufficientspace)
+      end
+
+      class ConnectionError < VagrantXenServerError
+        error_key(:connection_error)
+      end
+
+      class HIMNCommunicatorError < VagrantXenServerError
+        error_key(:himn_communicator_error)
+      end
+      
+    end
+  end
+end

data/lib/vagrant-xenserver/plugin.rb

@@ -0,0 +1,70 @@
+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', parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # 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
+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/exnhandler.rb

@@ -0,0 +1,49 @@
+# Handle the errors thrown by XenServer
+require "json"
+
+module VagrantPlugins
+  module XenServer
+    module MyUtil
+      class Exnhandler
+
+        def self.def(api,error)
+          # Default case: raise generic API error
+          raise Errors::APIError,
+                api: api,
+                error: String(error)
+        end
+
+        def self.handle(api,error)
+          case error[0]
+          when "IMPORT_ERROR"
+            case error[1]
+            when "404 Not Found"
+              raise Errors::Import404
+            else
+              Exnhandler.def(api,error)
+            end
+          when "SR_BACKEND_FAILURE_44"
+            raise Errors::InsufficientSpace
+          else
+            raise Errors::APIError,
+                  api: api,
+                  error: String(error)
+          end
+        end
+
+        def self.handle_xenapiexn(api,e,logger)
+          case e
+          when XenApi::Errors::SRFull
+            raise Errors::InsufficientSpace
+          when XenApi::Errors::GenericError
+            # Grotesque hack - get the error array back by parsing the string
+            # representation as JSON. Bleurgh!
+            self.handle(api,JSON.parse(e.message))
+          else
+            self.handle(api,e)
+          end
+        end
+      end
+    end
+  end
+end