knife-vsphere 0.6.0 → 0.7.0

data/lib/chef/knife/BaseVsphereCommand.rb

@@ -107,6 +107,35 @@ class Chef
 			  @password ||= ui.ask("Enter your password: ") { |q| q.echo = false }
 			end
 
+			def get_vm(vmname)
+		          vim = get_vim_connection
+		          baseFolder = find_folder(get_config(:folder));
+                          retval = traverse_folders_for_vm(baseFolder,vmname)
+                          return retval
+                        end 
+
+                        def traverse_folders_for_vm(folder,vmname)
+                           # not sure why @vm is necessary, but it returns class Array
+                           # instead of class VirtualMachine without it... ugh
+                           @vm = nil
+		           folders = find_all_in_folder(folder, RbVmomi::VIM::Folder)
+		           folders.each do |child|
+                             traverse_folders_for_vm(child,vmname)
+                             vms = find_all_in_folder(folder,RbVmomi::VIM::VirtualMachine)
+                             vms.each do |vm|
+                               if vm.name == vmname
+                                 @vm = vm
+                                 return @vm
+                               end
+                             end
+                           end
+                           return @vm
+	                end
+
+                        def get_datacenter
+                           dc = config[:vim].serviceInstance.find_datacenter(get_config(:vsphere_dc)) or abort "datacenter not found"
+                        end
+
 			def find_folder(folderName)
 				dcname = get_config(:vsphere_dc)
 				dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
@@ -154,6 +183,53 @@ class Chef
         baseEntity
 			end
 
+                        def choose_datastore(dstores,size)
+                          vmdk_size_kb = size.to_i * 1024 * 1024
+                          vmdk_size_B = size.to_i * 1024 * 1024 * 1024
+             
+                          candidates = []
+                          dstores.each  do |store|
+                            avail = number_to_human_size(store.summary[:freeSpace])
+                            cap = number_to_human_size(store.summary[:capacity])                     
+                            puts "#{ui.color("Datastore", :cyan)}: #{store.name} (#{avail}(#{store.summary[:freeSpace]}) / #{cap})"     
+                      
+                            # vm's can span multiple datastores, so instead of grabbing the first one
+                            # let's find the first datastore with the available space on a LUN the vm 
+                            # is already using, or use a specified LUN (if given)
+                      
+                            
+                            if ( store.summary[:freeSpace] - vmdk_size_B ) > 0
+                              # also let's not use more than 90% of total space to save room for snapshots.
+                              cap_remains = 100 * ( (store.summary[:freeSpace].to_f - vmdk_size_B.to_f ) / store.summary[:capacity].to_f )
+                              if(cap_remains.to_i > 10)
+                                candidates.push(store)
+                              end 
+                            end
+                          end
+                          if candidates.length > 0
+                            vmdk_datastore = candidates[0]
+                          else
+                            puts "Insufficient space on all LUNs designated or assigned to the virtual machine. Please specify a new target."
+                            vmdk_datastore = nil
+                          end
+                          return vmdk_datastore
+                        end
+
+
+			def find_datastores_regex(regex)
+                          stores = Array.new()
+                          puts "Looking for all datastores that match /#{regex}/"
+                          dcname = get_config(:vsphere_dc)
+                          dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"
+                          baseEntity = dc.datastore
+                          baseEntity.each do |ds|
+                            if ds.name.match /#{regex}/
+                              stores.push ds
+                            end
+                          end
+                          return stores
+                        end
+
 			def find_datastore(dsName)
 				dcname = get_config(:vsphere_dc)
 				dc = config[:vim].serviceInstance.find_datacenter(dcname) or abort "datacenter not found"

data/lib/chef/knife/vsphere_vm_vmdk_add.rb

@@ -15,7 +15,12 @@ class Chef::Knife::VsphereVmVmdkAdd < Chef::Knife::BaseVsphereCommand
   option :vmdk_type, 
     :long => "--vmdk-type TYPE",
     :description => "Type of VMDK"
-  $default[:vmdk_type] = "thin"
+  # this is a bad idea as it will let you overcommit SAN by 400% or more. thick is a more "sane" default
+  $default[:vmdk_type] = "thin"      
+
+  option :target_lun, 
+    :long => "--target-lun NAME",
+    :description => "name of target LUN"
 
   def run
     $stdout.sync = true
@@ -37,42 +42,177 @@ class Chef::Knife::VsphereVmVmdkAdd < Chef::Knife::BaseVsphereCommand
     vim = get_vim_connection
     vdm = vim.serviceContent.virtualDiskManager
     vm = get_vm(vmname)
+    if vm.nil?
+        puts "Could not find #{vmname}"
+        return 
+    end
 
-    vmdk_datastore = vm.datastore[0]
-    vmdk_fileName = "#{vmname}/#{vmname}_1.vmdk"
-    vmdk_name = "[#{vmdk_datastore.name}] #{vmdk_fileName}"
+    target_lun = get_config(:target_lun) unless get_config(:target_lun).nil?
     vmdk_size_kb = size.to_i * 1024 * 1024
+    vmdk_size_B  = size.to_i * 1024 * 1024 * 1024 
+
+    if target_lun.nil?
+      vmdk_datastore = choose_datastore(vm.datastore,size)
+      exit -1 if vmdk_datastore.nil?
+    else
+        vmdk_datastores = find_datastores_regex(target_lun)
+        vmdk_datastore = choose_datastore(vmdk_datastores,size)
+        exit -1 if vmdk_datastore.nil?
+        vmdk_dir  = "[#{vmdk_datastore.name}] #{vmname}"
+        # create the vm folder on the LUN or subsequent operations will fail.
+        if not vmdk_datastore.exists? vmname
+          dc = get_datacenter
+          dc._connection.serviceContent.fileManager.MakeDirectory :name => vmdk_dir, :datacenter => dc, :createParentDirectories => false
+        end
+    end
+
+    puts "Choosing: #{vmdk_datastore.name}"
+
+    # now we need to inspect the files in this datastore to get our next file name
+    next_vmdk = 1
+    pc = vmdk_datastore._connection.serviceContent.propertyCollector
+    vms = vmdk_datastore.vm
+    vmFiles = pc.collectMultiple vms, 'layoutEx.file'
+    vmFiles.keys.each do |vm|
+        vmFiles[vm]["layoutEx.file"].each do |layout|
+          if layout.name.match(/^\[#{vmdk_datastore.name}\] #{vmname}\/#{vmname}_([0-9]+).vmdk/)
+            num = $1
+            if next_vmdk <= num.to_i
+              next_vmdk = num.to_i + 1
+            end
+          end
+        end
+    end
+    vmdk_fileName = "#{vmname}/#{vmname}_#{next_vmdk}.vmdk"
+    vmdk_name = "[#{vmdk_datastore.name}] #{vmdk_fileName}"
     vmdk_type = get_config(:vmdk_type)
     vmdk_type = "preallocated" if vmdk_type == "thick"
+    puts "Next vmdk name is => #{vmdk_name}"
     
-    vmdk_spec = RbVmomi::VIM::FileBackedVirtualDiskSpec(
-      :adapterType => "lsiLogic",
-      :capacityKb => vmdk_size_kb,
-      :diskType => vmdk_type
-    )
+    # create the disk
+    if not vmdk_datastore.exists? vmdk_fileName
+      vmdk_spec = RbVmomi::VIM::FileBackedVirtualDiskSpec(
+        :adapterType => "lsiLogic",
+        :capacityKb => vmdk_size_kb,
+        :diskType => vmdk_type
+      )
+      ui.info "Creating VMDK"
+      ui.info "#{ui.color "Capacity:", :cyan} #{size} GB"
+      ui.info "#{ui.color "Disk:", :cyan} #{vmdk_name}"
+
+      if get_config(:noop)
+        ui.info "#{ui.color "Skipping disk creation process because --noop specified.", :red}"
+      else
+        vdm.CreateVirtualDisk_Task(
+          :datacenter => get_datacenter,
+          :name => vmdk_name,
+          :spec => vmdk_spec
+        ).wait_for_completion
+      end
+    end
+    ui.info "Attaching VMDK to #{vmname}"
 
-    ui.info "Creating VMDK"
-    ui.info "#{ui.color "Capacity:", :cyan} #{size} GB"
-    ui.info "#{ui.color "Disk:", :cyan} #{vmdk_name}"
+    # now we run through the SCSI controllers to see if there's an available one
+    available_controllers = Array.new()
+    use_controller = nil
+    scsi_tree = Hash.new()
+    vm.config.hardware.device.each do |device|
+      if device.class == RbVmomi::VIM::VirtualLsiLogicController
+        if scsi_tree[device.controllerKey].nil?
+            scsi_tree[device.key]=Hash.new()
+            scsi_tree[device.key]['children'] = Array.new();
+            scsi_tree[device.key]['device'] = device;
+        end
+      end
+      if device.class == RbVmomi::VIM::VirtualDisk
+        if scsi_tree[device.controllerKey].nil?
+            scsi_tree[device.controllerKey]=Hash.new()
+            scsi_tree[device.controllerKey]['children'] = Array.new();
+        end
+        scsi_tree[device.controllerKey]['children'].push(device)
+      end
+    end
+    scsi_tree.keys.sort.each do |controller|
+      if scsi_tree[controller]['children'].length < 15
+          available_controllers.push(scsi_tree[controller]['device'].deviceInfo.label)
+      end
+    end
 
-    if get_config(:noop)
-      ui.info "#{ui.color "Skipping disk creation process because --noop specified.", :red}"
+    if available_controllers.length > 0 
+      use_controller = available_controllers[0]
+      puts "using #{use_controller}"
     else
-      vdm.CreateVirtualDisk_Task(
-        :datacenter => get_datacenter,
-        :name => vmdk_name,
-        :spec => vmdk_spec
-      ).wait_for_completion
+
+      if scsi_tree.keys.length < 4
+
+        # Add a controller if none are available
+        puts "no controllers available. Will attempt to create"
+        new_scsi_key       = scsi_tree.keys.sort[scsi_tree.length - 1] + 1
+        new_scsi_busNumber = scsi_tree[scsi_tree.keys.sort[scsi_tree.length - 1]]['device'].busNumber + 1
+
+        controller_device = RbVmomi::VIM::VirtualLsiLogicController(
+          :key       => new_scsi_key,
+          :busNumber => new_scsi_busNumber,
+          :sharedBus => :noSharing
+        )
+
+        device_config_spec = RbVmomi::VIM::VirtualDeviceConfigSpec(
+          :device => controller_device,
+          :operation => RbVmomi::VIM::VirtualDeviceConfigSpecOperation("add")
+        )
+  
+        vm_config_spec = RbVmomi::VIM::VirtualMachineConfigSpec(
+          :deviceChange => [device_config_spec]
+        )
+
+        if get_config(:noop)
+          ui.info "#{ui.color "Skipping controller creation process because --noop specified.", :red}"
+        else
+          vm.ReconfigVM_Task(:spec => vm_config_spec).wait_for_completion
+        end
+      else
+        ui.info "Controllers maxed out at 4."
+        exit -1;
+      end
+    end
+     
+    # now go back and get the new device's name
+    vm.config.hardware.device.each do |device|
+      if device.class == RbVmomi::VIM::VirtualLsiLogicController
+        if device.key == new_scsi_key
+          use_controller = device.deviceInfo.label
+        end
+      end
     end
 
-    ui.info "Attaching VMDK to #{vmname}"
+    # add the disk
+    controller = find_device(vm,use_controller)
+
+    used_unitNumbers = Array.new()
+    scsi_tree.keys.sort.each do |c|
+      if controller.key == scsi_tree[c]['device'].key
+        used_unitNumbers.push(scsi_tree[c]['device'].scsiCtlrUnitNumber)
+        scsi_tree[c]['children'].each do |disk|
+          used_unitNumbers.push(disk.unitNumber)
+        end
+      end
+    end
+    available_unitNumbers = Array.new
+    (0 .. 15).each do |scsi_id|
+      if used_unitNumbers.grep(scsi_id).length > 0 
+      else
+          available_unitNumbers.push(scsi_id)
+      end
+    end
 
-    controller = find_device(vm,"SCSI controller 0")
+    # ensure we don't try to add the controllers SCSI ID
+    new_unitNumber = available_unitNumbers.sort[0]
+     puts "using SCSI ID #{new_unitNumber}"
 
     vmdk_backing = RbVmomi::VIM::VirtualDiskFlatVer2BackingInfo(
       :datastore => vmdk_datastore,
       :diskMode => "persistent",
-      :fileName => vmdk_name,
+      :fileName => vmdk_name
     )
 
     device = RbVmomi::VIM::VirtualDisk(
@@ -80,7 +220,7 @@ class Chef::Knife::VsphereVmVmdkAdd < Chef::Knife::BaseVsphereCommand
       :capacityInKB => vmdk_size_kb,
       :controllerKey => controller.key,
       :key => -1,
-      :unitNumber => controller.device.size + 1
+      :unitNumber => new_unitNumber
     )
 
     device_config_spec = RbVmomi::VIM::VirtualDeviceConfigSpec(

data/lib/knife-vsphere/version.rb

@@ -1,4 +1,4 @@
-module KnifeVsphere
-  VERSION = "0.6.0"
-end
-
+module KnifeVsphere
+  VERSION = "0.7.0"
+end
+

metadata

@@ -2,7 +2,7 @@
 name: knife-vsphere
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Ezra Pagel
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-06-02 00:00:00 -05:00
+date: 2013-06-05 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency