rvc 1.5.0 → 1.6.0

data/lib/rvc/modules/cluster.rb

@@ -48,9 +48,9 @@ def add_host cluster, hostname, opts
       :sslThumbprint => sslThumbprint,
     }
     task = cluster.AddHost_Task :spec => spec,
-                                :asConnected => false
+                                :asConnected => true
     begin
-      task.wait_for_completion
+      one_progress task
       break
     rescue VIM::SSLVerifyFault
       puts "SSL thumbprint: #{$!.fault.thumbprint}"
@@ -62,3 +62,19 @@ def add_host cluster, hostname, opts
     end
   end
 end
+
+
+opts :configure_ha do
+  summary "Configure HA on a cluster"
+  arg :cluster, nil, :lookup => VIM::ClusterComputeResource
+  opt :disabled, "Disable HA", :default => false
+end
+
+def configure_ha cluster, opts
+  spec = VIM::ClusterConfigSpecEx(
+    :dasConfig => {
+      :enabled => !opts[:disabled],
+    }
+  )
+  one_progress(cluster.ReconfigureComputeResource_Task :spec => spec, :modify => true)
+end

data/lib/rvc/modules/core.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2011 VMware, Inc.  All Rights Reserved.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+opts :quit do
+  summary "Exit RVC"
+end
+
+rvc_alias :quit
+rvc_alias :quit, :exit
+rvc_alias :quit, :q
+
+def quit
+  exit
+end
+
+
+opts :reload do
+  summary "Reload RVC command modules and extensions"
+  opt :verbose, "Display filenames loaded", :short => 'v', :default => false
+end
+
+rvc_alias :reload
+
+def reload opts
+  old_verbose = $VERBOSE
+  $VERBOSE = nil unless opts[:verbose]
+
+  RVC.reload_modules opts[:verbose]
+
+  typenames = Set.new(VIM.loader.typenames.select { |x| VIM.const_defined? x })
+  dirs = VIM.extension_dirs
+  dirs.each do |path|
+    Dir.open(path) do |dir|
+      dir.each do |file|
+        next unless file =~ /\.rb$/
+        next unless typenames.member? $`
+        file_path = File.join(dir, file)
+        puts "loading #{$`} extensions from #{file_path}" if opts[:verbose]
+        load file_path
+      end
+    end
+  end
+
+ensure
+  $VERBOSE = old_verbose
+end

data/lib/rvc/modules/datastore.rb

@@ -18,6 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'terminal-table/import'
+
 opts :download do
   summary "Download a file from a datastore"
   arg 'datastore-path', "Filename on the datastore", :lookup => VIM::Datastore::FakeDatastoreFile
@@ -163,3 +165,159 @@ end
 def http_path dc_name, ds_name, path
   "/folder/#{URI.escape path}?dcPath=#{URI.escape dc_name}&dsName=#{URI.escape ds_name}"
 end
+
+
+opts :find_orphans do
+  summary "Finds directories on the datastore that don't belong to any registered VM"
+  arg :datastore, nil, :lookup => VIM::Datastore
+  opt :mark, "Name of the mark to save results in", :required => false, :type => :string
+end
+
+def find_orphans ds, opts
+  pc = ds._connection.serviceContent.propertyCollector
+  vms = ds.vm
+  
+  puts "Collecting file information about #{vms.length} VMs ... (this may take a while)"
+  dsName = ds.name
+  vmFiles = pc.collectMultiple vms, 'layoutEx.file'
+  
+  puts "Collecting file information on datastore '#{dsName}' ..."
+  dsBrowser = ds.browser
+  result = dsBrowser.SearchDatastore_Task(
+    :datastorePath => "[#{dsName}] ",
+    :searchSpec => {
+      :details => {
+        :fileType => true,
+        :fileSize => false,
+        :fileOwner => false,
+        :modification => false
+      }
+    }
+  ).wait_for_completion
+  dsDirectories = result.file.grep(RbVmomi::VIM::FolderFileInfo).map(&:path)
+  
+  puts "Checking for any VMs that got added inbetween ..."
+  addedVms = ds.vm - vms
+  if addedVms.length > 0
+    puts "Processing #{addedVms.length} new VMs ..."
+    vmFiles.merge!(pc.collectMultiple addedVms, 'layoutEx.file')
+  end
+  
+  begin 
+    perDSUsage = pc.collectMultiple vms, 'storage.perDatastoreUsage'
+  rescue RbVmomi::Fault => ex
+    if ex.fault.is_a?(RbVmomi::VIM::ManagedObjectNotFound)
+      vms = vms - [ex.fault.obj]
+      retry
+    end
+    perDSUsage = []
+    raise
+  end
+
+  puts "Cross-referencing VM files with files on datastore '#{dsName}' ..."
+  vmFilenameHash = Hash[vmFiles.map do |vm, info| 
+    [
+      vm, 
+      info["layoutEx.file"].map{|x| x.name}.select{|x| x =~ /^\[#{dsName}\] /}.map{|x| x.gsub(/^\[#{dsName}\] /, '')}
+    ]
+  end]
+  filenames = vmFilenameHash.values.flatten(1)
+  vmDirectories = filenames.map{ |x| x.split('/').first }.uniq
+  orphanDirectories = (dsDirectories - vmDirectories).reject { |x| x =~ /^\./ }
+  puts "Found #{orphanDirectories.length} potentially orphaned directories"
+  
+  puts "Composing list of potentially orphaned files ... (this may take a while)"
+  data = orphanDirectories.map do |dir|
+    begin 
+      result = dsBrowser.SearchDatastoreSubFolders_Task(
+        :datastorePath => "[#{dsName}] #{dir}/",
+        :searchSpec => {
+          :details => {
+            :fileType => false,
+            :fileSize => true,
+            :fileOwner => false,
+            :modification => false
+          }
+        }
+      ).wait_for_completion
+      files = result.map(&:file).flatten
+      dirSize = files.map(&:fileSize).sum
+      $stdout.write "."
+      $stdout.flush
+      [dir, dirSize, files.length]
+    rescue 
+      puts "failed to search #{dir.inspect}: #{$!.message}"
+      nil
+    end
+  end.compact
+  puts
+  puts
+  
+  if data.empty?
+    puts "No orphans found"
+  else
+    puts(table do
+      data.sort_by { |a| a[1] }.each do |x|
+        dir, dirSize, numFiles = x
+        self.headings = 'Directory', 'Space Used', '# Files'
+        add_row [dir, "#{dirSize.metric}B", numFiles]
+      end
+    end)
+  end
+
+  puts
+
+  totalSize = data.map{|x| x[1]}.sum
+  dsSummary = ds.summary
+  vmDsUsage = perDSUsage.map{|vm, x| x['storage.perDatastoreUsage'].find{|y| y.datastore == ds}}.reject{|x| x == nil}
+  committed = vmDsUsage.map{|x| x.committed}.sum
+  unshared = vmDsUsage.map{|x| x.unshared}.sum
+  otherSpace = (dsSummary.capacity - dsSummary.freeSpace) - unshared
+  puts "Provisioned on Datastore:  #{dsSummary.uncommitted.metric}B"
+  puts "Capacity of Datastore: #{dsSummary.capacity.metric}B"
+  puts "Free Space on Datastore: #{dsSummary.freeSpace.metric}B"
+  puts "VMs Provisioned on Datastore: #{vmDsUsage.map(&:uncommitted).sum.metric}B"
+  puts "VMs Used on Datastore: #{committed.metric}B"
+  puts "VMs Unshared on Datastore: #{vmDsUsage.map(&:unshared).sum.metric}B"
+  puts "Unaccounted space: #{otherSpace.metric}B"
+  puts "Total size of detected potential orphans: #{totalSize.metric}B"
+  puts
+
+  results = data.map do |dirInfo|
+    RbVmomi::VIM::Datastore::FakeDatastoreFolder.new(ds, "#{dirInfo[0]}")
+  end
+  opts[:mark] ||= "#{dsName}_orphans"
+  CMD.mark.mark opts[:mark], results
+  puts "Saved results to mark '#{opts[:mark]}'"
+
+  i = 0
+  results.each do |r|
+    display_path = r.path
+    puts "#{i} #{display_path}"
+    CMD.mark.mark i.to_s, [r]
+    i += 1
+  end
+end
+
+
+opts :delete do
+  summary "Deletes the specified files or folders from the datastore"
+  arg :objs, nil, :multi => true, :lookup => RVC::InventoryObject
+end
+
+def delete objs
+  fm = nil
+  tasks = objs.map do |obj|
+    isFolder = obj.is_a?(RbVmomi::VIM::Datastore::FakeDatastoreFolder) 
+    isFile = obj.is_a?(RbVmomi::VIM::Datastore::FakeDatastoreFile)
+    err "Parameter is neither file nor folder" if !isFolder && !isFile
+     
+    ds = obj.datastore
+    dc = ds.path.find{|x| x[0].is_a? RbVmomi::VIM::Datacenter}[0]
+    fm ||= ds._connection.serviceContent.fileManager
+    dsPath = "[#{ds.name}] #{obj.path}"
+    puts "Deleting #{dsPath}"
+    fm.DeleteDatastoreFile_Task(:name => dsPath, :datacenter => dc)
+  end
+  progress(tasks)
+end

data/lib/rvc/modules/device.rb

@@ -0,0 +1,275 @@
+opts :connect do
+  summary "Connect a virtual device"
+  arg :device, nil, :lookup => VIM::VirtualDevice, :multi => true
+end
+
+def connect devs
+  change_devices_connectivity devs, true
+end
+
+
+opts :disconnect do
+  summary "Disconnect a virtual device"
+  arg :device, nil, :lookup => VIM::VirtualDevice, :multi => true
+end
+
+def disconnect devs
+  change_devices_connectivity devs, false
+end
+
+
+opts :remove do
+  summary "Remove a virtual device"
+  arg :device, nil, :lookup => VIM::VirtualDevice, :multi => true
+end
+
+def remove devs
+  vm_devs = devs.group_by(&:rvc_vm)
+  tasks = vm_devs.map do |vm,my_devs|
+    device_changes = my_devs.map do |dev|
+      fileOp = dev.backing.is_a?(VIM::VirtualDeviceFileBackingInfo) ? 'destroy' : nil
+      { :operation => :remove, :fileOperation => fileOp, :device => dev }
+    end
+    spec = { :deviceChange => device_changes }
+    vm.ReconfigVM_Task(:spec => spec)
+  end
+
+  progress tasks
+end
+
+
+opts :add_net do
+  summary "Add a network adapter to a virtual machine"
+  arg :vm, nil, :lookup => VIM::VirtualMachine
+  arg :network, nil, :lookup => VIM::Network
+  opt :type, "Adapter type", :default => 'e1000'
+end
+
+NET_DEVICE_CLASSES = {
+  'e1000' => VIM::VirtualE1000,
+  'vmxnet3' => VIM::VirtualVmxnet3,
+}
+
+def add_net vm, network, opts
+  klass = NET_DEVICE_CLASSES[opts[:type]] or err "unknown network adapter type #{opts[:type].inspect}"
+
+  case network
+  when VIM::DistributedVirtualPortgroup
+    switch, pg_key = network.collect 'config.distributedVirtualSwitch', 'key'
+    port = VIM.DistributedVirtualSwitchPortConnection(
+      :switchUuid => switch.uuid,
+      :portgroupKey => pg_key)
+    summary = network.name
+    backing = VIM.VirtualEthernetCardDistributedVirtualPortBackingInfo(:port => port)
+  when VIM::Network
+    summary = network.name
+    backing = VIM.VirtualEthernetCardNetworkBackingInfo(:deviceName => network.name)
+  else fail
+  end
+
+  _add_device vm, nil, klass.new(
+    :key => -1,
+    :deviceInfo => {
+      :summary => summary,
+      :label => "",
+    },
+    :backing => backing,
+    :addressType => 'generated'
+  )
+end
+
+
+opts :add_disk do
+  summary "Add a hard drive to a virtual machine"
+  arg :vm, nil, :lookup => VIM::VirtualMachine
+  opt :size, 'Size', :default => '10G'
+  opt :controller, 'Virtual controller', :type => :string, :lookup => VIM::VirtualController
+end
+
+def add_disk vm, opts
+  controller, unit_number = pick_controller vm, opts[:controller], [VIM::VirtualSCSIController, VIM::VirtualIDEController]
+  id = "disk-#{controller.key}-#{unit_number}"
+  filename = "#{File.dirname(vm.summary.config.vmPathName)}/#{id}.vmdk"
+  _add_device vm, :create, VIM::VirtualDisk(
+    :key => -1,
+    :backing => VIM.VirtualDiskFlatVer2BackingInfo(
+      :fileName => filename,
+      :diskMode => :persistent,
+      :thinProvisioned => true
+    ),
+    :capacityInKB => MetricNumber.parse(opts[:size]).to_i/1000,
+    :controllerKey => controller.key,
+    :unitNumber => unit_number
+  )
+end
+
+
+opts :add_cdrom do
+  summary "Add a cdrom drive"
+  arg :vm, nil, :lookup => VIM::VirtualMachine
+  opt :controller, 'Virtual controller', :type => :string, :lookup => VIM::VirtualIDEController
+end
+
+def add_cdrom vm, opts
+  controller, unit_number = pick_controller vm, opts[:controller], [VIM::VirtualIDEController]
+  id = "cdrom-#{controller.key}-#{unit_number}"
+  _add_device vm, nil, VIM.VirtualCdrom(
+    :controllerKey => controller.key,
+    :key => -1,
+    :unitNumber => unit_number,
+    :backing => VIM.VirtualCdromAtapiBackingInfo(
+      :deviceName => id,
+      :useAutoDetect => false
+    ),
+    :connectable => VIM.VirtualDeviceConnectInfo(
+      :allowGuestControl => true,
+      :connected => true,
+      :startConnected => true
+    )
+  )
+end
+
+
+opts :insert_cdrom do
+  summary "Put a disc in a virtual CDROM drive"
+  arg :dev, nil, :lookup => VIM::VirtualDevice
+  arg :iso, "Path to the ISO image on a datastore", :lookup => VIM::Datastore::FakeDatastoreFile
+end
+
+def insert_cdrom dev, iso
+  vm = dev.rvc_vm
+  backing = VIM.VirtualCdromIsoBackingInfo(:fileName => iso.datastore_path)
+
+  spec = {
+    :deviceChange => [
+      {
+        :operation => :edit,
+        :device => dev.class.new(
+          :key => dev.key,
+          :controllerKey => dev.controllerKey,
+          :backing => backing)
+      }
+    ]
+  }
+
+  progress [vm.ReconfigVM_Task(:spec => spec)]
+end
+
+
+SCSI_CONTROLLER_TYPES = {
+  'pvscsi' => VIM::ParaVirtualSCSIController,
+  'buslogic' => VIM::VirtualBusLogicController,
+  'lsilogic' => VIM::VirtualLsiLogicController,
+  'lsilogic-sas' => VIM::VirtualLsiLogicSASController,
+}
+
+SCSI_BUS_NUMBERS = [0, 1, 2, 3]
+
+opts :add_scsi_controller do
+  summary "Add a virtual SCSI controller to a VM"
+  arg :vm, nil, :lookup => VIM::VirtualMachine
+  opt :type, SCSI_CONTROLLER_TYPES.keys*'/', :default => 'lsilogic' # TODO tab complete
+  opt :sharing, VIM::VirtualSCSISharing.values*'/', :default => 'noSharing' # TODO tab complete
+  opt :hot_add, "Enable hot-add/remove", :default => nil
+end
+
+def add_scsi_controller vm, opts
+  klass = SCSI_CONTROLLER_TYPES[opts[:type]] or err "invalid SCSI controller type #{opts[:type].inspect}"
+  err "invalid value for --sharing" unless VIM::VirtualSCSISharing.values.member? opts[:sharing]
+
+  existing_devices, = vm.collect 'config.hardware.device'
+  used_bus_numbers = existing_devices.grep(VIM::VirtualSCSIController).map(&:busNumber)
+  bus_number = (SCSI_BUS_NUMBERS - used_bus_numbers).min
+  err "unable to allocate a bus number, too many SCSI controllers" unless bus_number
+
+  controller = klass.new(
+    :key => -1,
+    :busNumber => bus_number,
+    :sharedBus => opts[:sharing],
+    :hotAddRemove => opts[:hot_add]
+  )
+
+  _add_device vm, nil, controller
+end
+
+
+opts :add_serial do
+  summary "Add a virtual serial port to a VM"
+  arg :vm, nil, :lookup => VIM::VirtualMachine
+end
+
+def add_serial vm
+  # create an initial no-op backing
+  backing = VIM::VirtualSerialPortURIBackingInfo(:direction => :client, :serviceURI => 'localhost:0')
+  _add_device vm, nil, VIM::VirtualSerialPort(:yieldOnPoll => true, :key => -1, :backing => backing)
+end
+
+
+opts :connect_serial_uri do
+  summary "Connect a virtual serial port to the given network URI"
+  arg :dev, nil, :lookup => VIM::VirtualSerialPort
+  arg :uri, "URI", :type => :string
+  opt :client, "Connect to another machine", :short => 'c'
+  opt :server, "Listen for incoming connections", :short => 's'
+  conflicts :client, :server
+end
+
+def connect_serial_uri dev, uri, opts
+  err "must specify --client or --server" unless opts[:client] || opts[:server]
+  direction = opts[:client] ? 'client' : 'server'
+  dev = dev.dup
+  dev.backing = VIM::VirtualSerialPortURIBackingInfo(:direction => direction, :serviceURI => uri)
+  spec = { :deviceChange => [ { :operation => :edit, :device => dev } ] }
+  progress [dev.rvc_vm.ReconfigVM_Task(:spec => spec)]
+end
+
+
+def _add_device vm, fileOp, dev
+  spec = {
+    :deviceChange => [
+      { :operation => :add, :fileOperation => fileOp, :device => dev },
+    ]
+  }
+  task = vm.ReconfigVM_Task(:spec => spec)
+  result = progress([task])[task]
+  if result == nil
+    new_device = vm.collect('config.hardware.device')[0].grep(dev.class).last
+    puts "Added device #{new_device.name}"
+  end
+end
+
+def change_devices_connectivity devs, connected
+  if dev = devs.find { |dev| dev.connectable.nil? }
+    err "#{dev.name} is not connectable."
+  end
+
+  vm_devs = devs.group_by(&:rvc_vm)
+  tasks = vm_devs.map do |vm,my_devs|
+    device_changes = my_devs.map do |dev|
+      dev = dev.dup
+      dev.connectable = dev.connectable.dup
+      dev.connectable.connected = connected
+      dev.connectable.startConnected = connected
+      { :operation => :edit, :device => dev }
+    end
+    spec = { :deviceChange => device_changes }
+    vm.ReconfigVM_Task(:spec => spec)
+  end
+
+  progress tasks
+end
+
+def pick_controller vm, controller, controller_classes
+  existing_devices, = vm.collect 'config.hardware.device'
+
+  controller ||= existing_devices.find do |dev|
+    controller_classes.any? { |klass| dev.is_a? klass } &&
+      dev.device.length < 2
+  end
+  err "no suitable controller found" unless controller
+
+  used_unit_numbers = existing_devices.select { |dev| dev.controllerKey == controller.key }.map(&:unitNumber)
+  unit_number = (used_unit_numbers.max||-1) + 1
+
+  [controller, unit_number]
+end