fog-vsphere 1.7.0 → 1.7.0.1

data/lib/fog/vsphere/models/compute/ticket.rb

@@ -0,0 +1,16 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class Vsphere
+      class Ticket < Fog::Model
+        attribute :server_id
+
+        attribute :ticket
+        attribute :host
+        attribute :port
+        attribute :ssl_thumbprint
+      end
+    end
+  end
+end

data/lib/fog/vsphere/models/compute/tickets.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Tickets < Fog::Collection
+        autoload :Ticket, File.expand_path('../ticket', __FILE__)
+
+        model Fog::Compute::Vsphere::Ticket
+
+        attr_accessor :server
+
+        def create(opts = {})
+          requires :server
+          raise 'server must be a Fog::Compute::Vsphere::Server' unless server.is_a?(Fog::Compute::Vsphere::Server)
+          new(
+            service.vm_acquire_ticket(
+              opts.merge(
+                'instance_uuid' => server.instance_uuid
+              )
+            )
+          )
+        end
+     end
+    end
+  end
+end

data/lib/fog/vsphere/models/compute/volume.rb

@@ -5,7 +5,6 @@ module Fog
         DISK_SIZE_TO_GB = 1048576
         identity :id
 
-        has_one :server, Server
         attribute :datastore
         attribute :storage_pod
         attribute :mode
@@ -17,9 +16,12 @@ module Fog
         attribute :size_gb
         attribute :key
         attribute :unit_number
-        attribute :controller_key, :type => :integer
+        attribute :server_id
+
+        def initialize(attributes={} )
+          # Assign server first to prevent race condition with persisted?
+          self.server_id = attributes.delete(:server_id)
 
-        def initialize(attributes={})
           super defaults.merge(attributes)
         end
 
@@ -29,7 +31,6 @@ module Fog
 
         def size_gb= s
           attributes[:size] = s.to_i * DISK_SIZE_TO_GB if s
-          attributes[:size_gb] = s.to_i if s
         end
 
         def to_s
@@ -47,7 +48,25 @@ module Fog
           raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
           requires :server_id, :size, :datastore
 
-          set_unit_number
+          # When adding volumes to vsphere, if our unit_number is 7 or higher, vsphere will increment the unit_number
+          # This is due to SCSI ID 7 being reserved for the pvscsi controller
+          # When referring to a volume that already added using a unit_id of 7 or higher, we must refer to the actual SCSI ID
+          if unit_number.nil?
+            # Vsphere maps unit_numbers 7 and greater to a higher SCSI ID since the pvscsi driver reserves SCSI ID 7
+            used_unit_numbers = server.volumes.map { |volume| volume.unit_number < 7 ? volume.unit_number : volume.unit_number - 1 }
+            max_unit_number = used_unit_numbers.max
+
+            if max_unit_number > server.volumes.size
+              # If the max ID exceeds the number of volumes, there must be a hole in the range. Find a hole and use it.
+              self.unit_number = max_unit_number.times.to_a.find { |i| used_unit_numbers.exclude?(i) }
+            else
+              self.unit_number = max_unit_number + 1
+            end
+          else
+            if server.volumes.any? { |volume| volume.unit_number == self.unit_number && volume.id != self.id }
+              raise "A volume already exists with that unit_number, so we can't save the new volume"
+            end
+          end
 
           data = service.add_vm_volume(self)
 
@@ -61,7 +80,6 @@ module Fog
 
             self.id = created.id
             self.key = created.key
-            self.controller_key = created.controllerKey
             self.filename = created.filename
 
             true
@@ -70,33 +88,9 @@ module Fog
           end
         end
 
-        def server_id
-          requires :server
-          server.id
-        end
-
-        def set_unit_number
-          # When adding volumes to vsphere, if our unit_number is 7 or higher, vsphere will increment the unit_number
-          # This is due to SCSI ID 7 being reserved for the pvscsi controller
-          # When referring to a volume that already added using a unit_id of 7 or higher, we must refer to the actual SCSI ID
-          if unit_number.nil?
-            self.unit_number = calculate_free_unit_number
-          else
-            if server.volumes.select { |vol| vol.controller_key == controller_key }.any? { |volume| volume.unit_number == self.unit_number && volume.id != self.id }
-              raise "A volume already exists with that unit_number, so we can't save the new volume"
-            end
-          end
-        end
-
-        def set_key
-          requires :controller_key, :unit_number
-
-          return unless key.nil?
-
-          # controller key is based on 1000 + controller bus
-          # disk key is based on 2000 + the SCSI ID + the controller bus * 16
-          controller_bus = controller_key - 1000
-          self.key = 2000 + (controller_bus * 16) + unit_number
+        def server
+          requires :server_id
+          service.servers.get(server_id)
         end
 
         private
@@ -105,21 +99,9 @@ module Fog
           {
             :thin => true,
             :name => "Hard disk",
-            :mode => "persistent",
-            :controller_key => 1000
+            :mode => "persistent"
           }
         end
-
-        def calculate_free_unit_number
-          requires :controller_key
-
-          # Vsphere maps unit_numbers 7 and greater to a higher SCSI ID since the pvscsi driver reserves SCSI ID 7
-          used_unit_numbers = server.volumes
-            .select { |vol| vol.unit_number && vol.controller_key == controller_key }.map(&:unit_number) + [7]
-          free_unit_numbers = (0..15).to_a - used_unit_numbers
-
-          free_unit_numbers.first
-        end
       end
     end
   end

data/lib/fog/vsphere/models/compute/volumes.rb

@@ -20,7 +20,7 @@ module Fog
               raise 'volumes should have vm or template'
             end
 
-          self.each { |volume| volume.server = server }
+          self.each { |volume| volume.server_id = server.id }
           self
         end
 

data/lib/fog/vsphere/requests/compute/create_vm.rb

@@ -20,7 +20,7 @@ module Fog
           vm_cfg[:cpuHotAddEnabled] = attributes[:cpuHotAddEnabled] if attributes.key?(:cpuHotAddEnabled)
           vm_cfg[:memoryHotAddEnabled] = attributes[:memoryHotAddEnabled] if attributes.key?(:memoryHotAddEnabled)
           vm_cfg[:firmware] = attributes[:firmware] if attributes.key?(:firmware)
-          vm_cfg[:bootOptions] = boot_options(attributes, vm_cfg) if attributes.key?(:boot_order) || attributes.key?(:boot_retry)
+          vm_cfg[:bootOptions] = boot_options(attributes) if attributes.key?(:boot_order) || attributes.key?(:boot_retry)
           resource_pool = if attributes[:resource_pool] && attributes[:resource_pool] != 'Resources'
                             get_raw_resource_pool(attributes[:resource_pool], attributes[:cluster], attributes[:datacenter])
                           else
@@ -97,12 +97,9 @@ module Fog
             devices << nics.map { |nic| create_interface(nic, nics.index(nic), :add, attributes) }
           end
 
-          if (scsi_controllers = (attributes[:scsi_controllers] || attributes["scsi_controller"]))
-            devices << scsi_controllers.each_with_index.map { |controller, index| create_controller(controller, index) }
-          end
-
           if (disks = attributes[:volumes])
-            devices << disks.map { |disk| create_disk(disk, :add, get_storage_pod(attributes)) }
+            devices << create_controller(attributes[:scsi_controller]||attributes["scsi_controller"]||{})
+            devices << disks.map { |disk| create_disk(disk, disks.index(disk), :add, 1000, get_storage_pod(attributes)) }
           end
 
           if (cdroms = attributes[:cdroms])
@@ -111,12 +108,12 @@ module Fog
           devices.flatten
         end
 
-        def boot_options(attributes, vm_cfg)
+        def boot_options attributes
           # NOTE: you must be using vsphere_rev 5.0 or greater to set boot_order
           # e.g. Fog::Compute.new(provider: "vsphere", vsphere_rev: "5.5", etc)
           options = {}
           if @vsphere_rev.to_f >= 5 and attributes[:boot_order]
-            options[:bootOrder] = boot_order(attributes, vm_cfg)
+            options[:bootOrder] = boot_order(attributes)
           end
 
           # Set attributes[:boot_retry] to a delay in miliseconds to enable boot retries
@@ -124,11 +121,11 @@ module Fog
             options[:bootRetryEnabled] = true
             options[:bootRetryDelay]   = attributes[:boot_retry]
           end
-
+                   
           options.empty? ? nil : RbVmomi::VIM::VirtualMachineBootOptions.new(options)
         end
 
-        def boot_order(attributes, vm_cfg)
+        def boot_order attributes
           # attributes[:boot_order] may be an array like this ['network', 'disk']
           # stating, that we want to prefer network boots over disk boots
           boot_order = []
@@ -145,17 +142,18 @@ module Fog
                 end
               end
             when 'disk'
-              disks = vm_cfg[:deviceChange].map {|dev| dev[:device]}.select { |dev| dev.is_a? RbVmomi::VIM::VirtualDisk }
-              disks.each do |disk|
-                # we allow booting from all harddisks, the first disk has the highest priority
-                boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableDiskDevice.new(
-                  :deviceKey => disk.key
-                )
+              if disks = attributes[:volumes]
+                disks.each do |disk|
+                  # we allow booting from all harddisks, the first disk has the highest priority
+                  boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableDiskDevice.new(
+                    :deviceKey => disk.key || get_disk_device_key(disks.index(disk)),
+                  )
+                end
               end
             when 'cdrom'
-              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableCdromDevice.new
+              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableCdromDevice.new()
             when 'floppy'
-              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableFloppyDevice.new
+              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableFloppyDevice.new()
             else
               raise "failed to create boot device because \"#{boot_device}\" is unknown"
             end
@@ -163,6 +161,19 @@ module Fog
           boot_order
         end
 
+        def get_disk_device_key(index)
+          # disk key is based on 2000 + the SCSI ID + the controller bus * 16
+          # the scsi host adapter appears as SCSI ID 7, so we have to skip that
+          # host adapter key is based on 1000 + bus id
+          # fog assumes that there is only a single scsi controller, see device_change()
+          if (index > 6) then
+            _index = index + 1
+          else
+            _index = index
+          end
+          2000 + _index
+        end
+
         def create_nic_backing nic, attributes
           raw_network = get_raw_network(nic.network, attributes[:datacenter], if nic.virtualswitch then nic.virtualswitch end)
 
@@ -193,9 +204,9 @@ module Fog
           }
         end
 
-        def create_controller(controller=nil, index = 0)
-          options=if controller
-                    controller_default_options.merge(controller.attributes)
+        def create_controller options=nil
+          options=if options
+                    controller_default_options.merge(Hash[options.map{|k,v| [k.to_sym,v] }])
                   else
                     controller_default_options
                   end
@@ -207,15 +218,15 @@ module Fog
           {
             :operation => options[:operation],
             :device    => controller_class.new({
-              :key       => options[:key] || (1000 + index),
-              :busNumber => options[:bus_id] || index,
+              :key       => options[:key],
+              :busNumber => options[:bus_id],
               :sharedBus => controller_get_shared_from_options(options),
             })
           }
         end
 
         def controller_default_options
-          {:operation => :add, :type => RbVmomi::VIM.VirtualLsiLogicController.class, :shared => false }
+          {:operation => "add", :type => RbVmomi::VIM.VirtualLsiLogicController.class, :key => 1000, :bus_id => 0, :shared => false }
         end
 
         def controller_get_shared_from_options options
@@ -230,29 +241,30 @@ module Fog
           end
         end
 
-        def create_disk(disk, operation = :add, storage_pod = nil)
+        def create_disk disk, index = 0, operation = :add, controller_key = 1000, storage_pod = nil
+          if (index > 6) then
+            _index = index + 1
+          else
+            _index = index
+          end
           # If we deploy the vm on a storage pod, datastore has to be an empty string
           if storage_pod
             datastore = ''
           else
             datastore = "[#{disk.datastore}]"
           end
-
-          disk.set_unit_number
-          disk.set_key
-
           payload = {
             :operation     => operation,
             :fileOperation => operation == :add ? :create : :destroy,
             :device        => RbVmomi::VIM.VirtualDisk(
-              :key           => disk.key,
+              :key           => disk.key || _index,
               :backing       => RbVmomi::VIM.VirtualDiskFlatVer2BackingInfo(
                 :fileName        => datastore,
                 :diskMode        => disk.mode.to_sym,
                 :thinProvisioned => disk.thin
               ),
-              :controllerKey => disk.controller_key,
-              :unitNumber    => disk.unit_number,
+              :controllerKey => controller_key,
+              :unitNumber    => _index,
               :capacityInKB  => disk.size
             )
           }

data/lib/fog/vsphere/requests/compute/host_finish_maintenance.rb

@@ -0,0 +1,14 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def host_finish_maintenance(name, cluster_name, datacenter_name, timeout = 0)
+          host_ref = get_host(name, cluster_name, datacenter_name)
+          task = host_ref.ExitMaintenanceMode_Task(timeout: timeout)
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/host_shutdown.rb

@@ -0,0 +1,14 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def host_shutdown(name, cluster_name, datacenter_name, force = false)
+          host_ref = get_host(name, cluster_name, datacenter_name)
+          task = host_ref.ShutdownHost_Task(force: force)
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/host_start_maintenance.rb

@@ -0,0 +1,14 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def host_start_maintenance(name, cluster_name, datacenter_name, timeout = 0, evacuate_powered_off_vms = false)
+          host_ref = get_host(name, cluster_name, datacenter_name)
+          task = host_ref.EnterMaintenanceMode_Task(timeout: timeout, evacuatePoweredOffVms: evacuate_powered_off_vms)
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+     end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_vm_scsi_controllers.rb

@@ -11,14 +11,21 @@ module Fog
         def list_vm_scsi_controllers_raw(vm_id)
           get_vm_ref(vm_id).config.hardware.device.grep(RbVmomi::VIM::VirtualSCSIController).map do |ctrl|
             {
-              :type    => ctrl.class.to_s,
-              :shared_bus  => ctrl.sharedBus.to_s,
-              :unit_number => ctrl.scsiCtlrUnitNumber,
-              :key => ctrl.key,
+              type: ctrl.class.to_s,
+              shared_bus: ctrl.sharedBus.to_s,
+              unit_number: ctrl.scsiCtlrUnitNumber,
+              key: ctrl.key
             }
           end
         end
       end
+      class Mock
+        def list_vm_scsi_controllers(vm_id)
+          raise Fog::Compute::Vsphere::NotFound, 'VM not Found' unless data[:servers].key?(vm_id)
+          return [] unless data[:servers][vm_id].key?('scsi_controllers')
+          data[:servers][vm_id]['scsi_controllers'].map { |h| h.merge(server_id: vm_id) }
+        end
+      end
     end
   end
 end

data/lib/fog/vsphere/requests/compute/list_vm_volumes.rb

@@ -38,8 +38,7 @@ module Fog
               :size => vol.capacityInKB,
               :name => vol.deviceInfo.label,
               :key => vol.key,
-              :unit_number => vol.unitNumber,
-              :controller_key => vol.controllerKey
+              :unit_number => vol.unitNumber
             }
           end
         end

data/lib/fog/vsphere/requests/compute/modify_vm_controller.rb

@@ -3,13 +3,25 @@ module Fog
     class Vsphere
       class Real
         def add_vm_controller(controller)
-          vm_reconfig_hardware('instance_uuid' => controller.server_id, 'hardware_spec' => {'deviceChange'=>[create_controller(controller)]})
+          options = {}
+          options[:operation] = 'add'
+          options[:type] = controller.type
+          options[:key] = controller.key
+          options[:shared] = controller.shared_bus
+
+          vm_reconfig_hardware('instance_uuid' => controller.server_id, 'hardware_spec' => {'deviceChange'=>[create_controller(options)]})
         end
       end
 
       class Mock
         def add_vm_controller(controller)
-          vm_reconfig_hardware('instance_uuid' => controller.server_id, 'hardware_spec' => {'deviceChange'=>[create_controller(controller)]})
+          options = {}
+          options[:operation] = 'add'
+          options[:type] = RbVmomi::VIM.VirtualLsiLogicController.class
+          options[:key] = 1000
+          options[:shared] = false
+
+          vm_reconfig_hardware('instance_uuid' => controller.server_id, 'hardware_spec' => {'deviceChange'=>[create_controller(options)]})
         end
       end
     end