fog-vsphere 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad810bd0bdd64f88734bbd79e55ec34499638de434018789fee29d7b0e80e18b
-  data.tar.gz: 12ee08e303541b65f02314ab02187a04952dd487198bc33e2c84d87591bf8245
+  metadata.gz: 73be829a1d5ffd1d11f38e91c589dc06d13053df3265907615b8ab025d577dc0
+  data.tar.gz: fbcffa36f4ea94ae6a3f56a958143593a5a27b84041bc70fb5842830063d288d
 SHA512:
-  metadata.gz: 5635212e1c8379224a31165790df4d2c34c09760e3c6b52e6d2a432500d1ec115f174ab09d264690cbd8d544eaeb9d64a946b96fe195d7531ac124aaec43fe2c
-  data.tar.gz: c078f8486725f2749a6c6729952154baf64864e6ce422190680c5b4125f584de5e9739b264f9fea667b49a294fe39ce3d5c1e0e5450522f3172fde86177f00c9
+  metadata.gz: f74b04e50ffc07f9523df9b27e954b4709fb65f347f7c1c1bfadda3c1b0a19953f1e38cf46695041242276a363f8a6feecda18385d00e42230551a5b502868fb
+  data.tar.gz: 5a0a583a956180e5bb8bbb2758472c5e510b7f9814af7ecac32cf82f3a736cd348e0c0243f73de5cf94f432dcaa55e40f316ee278b1e5ba97967490dd2b23160

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## v3.2.0
+
+* Annotation Notes are not set in Image based builds (#218)
+
+* Cloning disks thin relocation and storagePod location (#216)
+
+* Grab DC if within a folder (#214)
+
 ## v3.1.1
 
 * Fixes multiple storagePods deployment (#213)

data/CONTRIBUTORS.md

@@ -56,6 +56,7 @@
 * Paul Thornthwaite <paul@brightbox.co.uk>
 * Paul Thornthwaite <tokengeek@gmail.com>
 * Paulo Henrique Lopes Ribeiro <plribeiro3000@gmail.com>
+* Rohan Arora <roarora@redhat.com>
 * Rich Daley <rdaley@williamhill.co.uk>
 * Rich Lane <rlane@club.cc.cmu.edu>
 * Samuel Keeley <samuel@dropbox.com>

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

@@ -24,7 +24,7 @@ module Fog
         end
 
         def vm_folders(filters = {})
-          service.folders({ datacenter: path.join('/'), type: :vm }.merge(filters))
+          service.folders({ datacenter: name, type: :vm }.merge(filters))
         end
 
         def virtual_machines(filters = {})

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

@@ -48,15 +48,11 @@ module Fog
 
         # rubocop:disable Metrics/ParameterLists
         def create_vm_on_storage_pod(vm_pod_name, volumes, vm_cfg, vmFolder, resource_pool, datacenter, host = nil)
-          disks_per_pod = volumes.group_by(&:storage_pod)
-          disks_per_pod[vm_pod_name] ||= []
-          disks_per_pod[vm_pod_name].concat(disks_per_pod.delete(nil)) if disks_per_pod.key?(nil)
-
           storage_spec = RbVmomi::VIM::StoragePlacementSpec.new(
             type: 'create',
             folder: vmFolder,
             resourcePool: resource_pool,
-            podSelectionSpec: pod_selection_spec(vm_pod_name, disks_per_pod, datacenter),
+            podSelectionSpec: pod_selection_spec(vm_pod_name, group_disks_by_storage_pod(volumes, vm_pod_name), datacenter),
             configSpec: vm_cfg,
             host: host
           )
@@ -76,19 +72,40 @@ module Fog
           vm
         end
 
-        def pod_selection_spec(vm_pod_name, disks_per_pod, datacenter)
+        def group_disks_by_storage_pod(volumes, vm_pod_name: nil)
+          vm_pod_name ||= volumes.detect { |v| !v.storage_pod.empty? }.storage_pod
+          disks_per_pod = volumes.group_by(&:storage_pod)
+          if disks_per_pod.key?(nil)
+            disks_per_pod[vm_pod_name] ||= []
+            disks_per_pod[vm_pod_name].concat(disks_per_pod.delete(nil))
+          end
+          disks_per_pod
+        end
+
+        def pod_selection_spec(vm_pod_name, disks_per_pod, datacenter, with_relocation: false, only_volumes: false)
           raw_pods = {}
-          disks_per_pod.each_key { |pod_name| raw_pods[pod_name] = get_raw_storage_pod(pod_name, datacenter) }
-
-          RbVmomi::VIM::StorageDrsPodSelectionSpec.new(
-            storagePod: raw_pods[vm_pod_name],
-            initialVmConfig: disks_per_pod.map do |name, vols|
-              RbVmomi::VIM::VmPodConfigForPlacement.new(
-                disk: vols.collect { |vol| RbVmomi::VIM::PodDiskLocator.new(diskId: vol.key) },
-                storagePod: raw_pods[name]
-              )
-            end
+          raw_pods[vm_pod_name] = get_raw_storage_pod(vm_pod_name, datacenter)
+          disks_per_pod.each_key { |pod_name| raw_pods[pod_name] ||= get_raw_storage_pod(pod_name, datacenter) }
+
+          disk_placements = disks_per_pod.map do |name, vols|
+            RbVmomi::VIM::VmPodConfigForPlacement.new(
+              disk: vols.collect do |vol|
+                locator = RbVmomi::VIM::PodDiskLocator.new(diskId: vol.key)
+                locator[:diskBackingInfo] = relocation_volume_backing(vol) if with_relocation
+                locator
+              end,
+              storagePod: raw_pods[name]
+            )
+          end
+          vm_config_placements = []
+          vm_config_placements << RbVmomi::VIM::VmPodConfigForPlacement.new(storagePod: raw_pods[vm_pod_name], disk: []) unless only_volumes
+          vm_config_placements.concat(disk_placements)
+
+          spec = RbVmomi::VIM::StorageDrsPodSelectionSpec.new(
+            initialVmConfig: vm_config_placements
           )
+          spec[:storagePod] = raw_pods[vm_pod_name] unless only_volumes
+          spec
         end
 
         # check if a storage pool is set on any of the volumes and return the first result found or nil

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

@@ -164,7 +164,8 @@ module Fog
             device_change << modify_template_nics_simple_spec(options['network_label'], options['nic_type'], options['network_adapter_device_key'], options['datacenter'])
           end
           if disks = options['volumes']
-            device_change.concat(modify_template_volumes_specs(vm_mob_ref, options['volumes'], default_storage_pod: options['storage_pod']))
+            device_change.concat(modify_template_volumes_specs(vm_mob_ref, options['volumes']))
+            device_change.concat(add_new_volumes_specs(vm_mob_ref, options['volumes'])) unless options['storage_pod']
           end
           virtual_machine_config_spec.deviceChange = device_change if device_change.any?
           # Options['numCPUs'] or Options['memoryMB']
@@ -178,6 +179,7 @@ module Fog
           virtual_machine_config_spec.cpuHotAddEnabled = options['cpuHotAddEnabled'] if options.key?('cpuHotAddEnabled')
           virtual_machine_config_spec.memoryHotAddEnabled = options['memoryHotAddEnabled'] if options.key?('memoryHotAddEnabled')
           virtual_machine_config_spec.firmware = options['firmware'] if options.key?('firmware')
+          virtual_machine_config_spec.annotation = options['annotation'] if options.key?('annotation')
           virtual_machine_config_spec.extraConfig = extra_config(extra_config: options['extraConfig']) if options.key?('extraConfig')
           if @vsphere_rev.to_f >= 5 && options.key?('boot_order')
             boot_order = options['boot_order'].flat_map do |boot_device|
@@ -627,18 +629,16 @@ module Fog
                                                                       diskMoveType: :moveChildMostDiskBacking)
           else
             relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(pool: resource_pool,
-                                                                      host: host,
-                                                                      transform: options['transform'] || 'sparse')
-            unless options.key?('storage_pod') && datastore_obj.nil?
+                                                                      host: host)
+            unless options['storage_pod'] && datastore_obj.nil?
               relocation_spec[:datastore] = datastore_obj
             end
           end
           # relocate templates is not supported by fog-vsphere when vm is cloned on a storage pod
-          unless options.key?('storage_pod') || !options['volumes']
-            unless options['volumes'].empty?
-              relocation_spec[:disk] = relocate_template_volumes_specs(vm_mob_ref, options['volumes'], options['datacenter'])
-            end
+          if !options['storage_pod'] && options['volumes'] && !options['volumes'].empty?
+            relocation_spec[:disk] = relocate_template_volumes_specs(vm_mob_ref, options['volumes'], options['datacenter'])
           end
+
           # And the clone specification
           clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(location: relocation_spec,
                                                             config: virtual_machine_config_spec,
@@ -648,18 +648,16 @@ module Fog
 
           # Perform the actual Clone Task
           # Clone VM on a storage pod
-          if options.key?('storage_pod') && !options['storage_pod'].nil?
+          if options['storage_pod']
             raise ArgumentError, 'need to use at least vsphere revision 5.0 or greater to use storage pods' unless @vsphere_rev.to_f >= 5
             vm_pod_name = options['storage_pod']
-            disks_per_pod = options['volumes'].group_by(&:storage_pod)
-            disks_per_pod[vm_pod_name] ||= []
-            disks_per_pod[vm_pod_name].concat(disks_per_pod.delete(nil)) if disks_per_pod.key?(nil)
+            disks_per_pod = group_disks_by_storage_pod(modified_volumes(vm_mob_ref, options['volumes']), vm_pod_name: options['storage_pod'])
 
             storage_spec = RbVmomi::VIM::StoragePlacementSpec.new(
               type: 'clone',
               folder: dest_folder,
               resourcePool: resource_pool,
-              podSelectionSpec: pod_selection_spec(vm_pod_name, disks_per_pod, options['datacenter']),
+              podSelectionSpec: pod_selection_spec(vm_pod_name, disks_per_pod, options['datacenter'], with_relocation: true),
               cloneSpec: clone_spec,
               cloneName: options['name'],
               vm: vm_mob_ref
@@ -688,6 +686,26 @@ module Fog
                 raise Fog::Vsphere::Errors::NotFound unless new_vm
               end
             end
+
+            new_volumes = new_volumes(vm_mob_ref, options['volumes'])
+            if new_vm && !new_volumes.empty?
+              new_disks_per_pod = group_disks_by_storage_pod(new_volumes, vm_pod_name: options['storage_pod'])
+              add_vols_config_spec = {
+                deviceChange: add_new_volumes_specs(vm_mob_ref, options['volumes'], default_storage_pod: options['storage_pod'])
+              }
+              placement_spec = RbVmomi::VIM::StoragePlacementSpec.new(
+                type: 'reconfigure',
+                vm: new_vm,
+                configSpec: add_vols_config_spec,
+                podSelectionSpec: pod_selection_spec(vm_pod_name, new_disks_per_pod, options['datacenter'], only_volumes: true)
+              )
+              result = srm.RecommendDatastores(storageSpec: placement_spec)
+              grouped_recoms = result.recommendations.group_by { |rec| rec.target._ref }
+              if grouped_recoms.keys.size == new_disks_per_pod.size
+                keys = grouped_recoms.map { |_ref, recoms| recoms.first.key }
+                srm.ApplyStorageDrsRecommendation_Task(key: keys).wait_for_completion
+              end
+            end
           else
             task = vm_mob_ref.CloneVM_Task(folder: dest_folder,
                                            name: options['name'],
@@ -794,13 +812,21 @@ module Fog
           specs
         end
 
-        def modify_template_volumes_specs(vm_mob_ref, volumes, default_storage_pod: nil)
+        def modified_volumes(vm_mob_ref, volumes)
+          template_volumes = vm_mob_ref.config.hardware.device.grep(RbVmomi::VIM::VirtualDisk)
+          volumes.take(template_volumes.size)
+        end
+
+        def new_volumes(vm_mob_ref, volumes)
+          template_volumes = vm_mob_ref.config.hardware.device.grep(RbVmomi::VIM::VirtualDisk)
+          volumes.drop(template_volumes.size)
+        end
+
+        def modify_template_volumes_specs(vm_mob_ref, volumes)
           template_volumes = vm_mob_ref.config.hardware.device.grep(RbVmomi::VIM::VirtualDisk)
-          modified_volumes = volumes.take(template_volumes.size)
-          new_volumes      = volumes.drop(template_volumes.size)
 
           specs = []
-          template_volumes.zip(modified_volumes).each do |template_volume, new_volume|
+          template_volumes.zip(modified_volumes(vm_mob_ref, volumes)).each do |template_volume, new_volume|
             if new_volume
               # copy identifiers to fog device to mark them as used
               new_volume.unit_number = template_volume.unitNumber
@@ -819,22 +845,36 @@ module Fog
                          device: template_volume }
             end
           end
-          specs.concat(new_volumes.map { |volume| create_disk(volume, :add, storage_pod: default_storage_pod) })
           specs
         end
 
+        def add_new_volumes_specs(vm_mob_ref, volumes, default_storage_pod: nil)
+          new_volumes(vm_mob_ref, volumes).map { |volume| create_disk(volume, :add, storage_pod: default_storage_pod) }
+        end
+
         def relocate_template_volumes_specs(vm_mob_ref, volumes, datacenter)
           template_volumes = vm_mob_ref.config.hardware.device.grep(RbVmomi::VIM::VirtualDisk)
           modified_volumes = volumes.take(template_volumes.size)
 
           specs = []
           template_volumes.zip(modified_volumes).each do |template_volume, new_volume|
-            if new_volume && new_volume.datastore && new_volume.datastore != template_volume.backing.datastore.name
-              specs << { diskId: template_volume.key, datastore: get_raw_datastore(new_volume.datastore, datacenter) }
-            end
+            next unless new_volume
+            specs << RbVmomi::VIM.VirtualMachineRelocateSpecDiskLocator(
+              diskId: template_volume.key,
+              datastore: get_raw_datastore(new_volume.datastore, datacenter),
+              diskBackingInfo: relocation_volume_backing(new_volume)
+            )
           end
           specs
         end
+
+        def relocation_volume_backing(volume)
+          RbVmomi::VIM.VirtualDiskFlatVer2BackingInfo(
+            diskMode: volume.mode.to_sym,
+            fileName: '',
+            thinProvisioned: volume.thin
+          )
+        end
       end
 
       # rubocop:enable ClassLength

data/lib/fog/vsphere/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Vsphere
-    VERSION = '3.1.1'.freeze
+    VERSION = '3.2.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fog-vsphere
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - J.R. Garcia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-10 00:00:00.000000000 Z
+date: 2019-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog-core
@@ -334,8 +334,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Module for the 'fog' gem to support VMware vSphere.