rvc 1.6.0 → 1.7.0

data/lib/rvc/modules/datacenter.rb

@@ -18,6 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'rvc/vim'
+
 opts :create do
   summary "Create a datacenter"
   arg :dest, nil, :lookup_parent => [VIM::Folder, VIM]

data/lib/rvc/modules/datastore.rb

@@ -18,7 +18,10 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'terminal-table/import'
+require 'rvc/vim'
+VIM::Datastore
+
+require 'terminal-table'
 
 opts :download do
   summary "Download a file from a datastore"
@@ -27,34 +30,9 @@ opts :download do
 end
 
 def download file, local_path
-  main_http = file.datastore._connection.http
-  http = Net::HTTP.new(main_http.address, main_http.port)
-  http.use_ssl = true
-  http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-  #http.set_debug_output $stderr
-  http.start
-  err "certificate mismatch" unless main_http.peer_cert.to_der == http.peer_cert.to_der
+  download_path = http_path file.datastore.send(:datacenter).name, file.datastore.name, file.path
 
-  headers = { 'cookie' => file.datastore._connection.cookie }
-  path = http_path file.datastore.send(:datacenter).name, file.datastore.name, file.path
-  http.request_get(path, headers) do |res|
-    case res
-    when Net::HTTPOK
-      len = res.content_length
-      count = 0
-      File.open(local_path, 'wb') do |io|
-        res.read_body do |segment|
-          count += segment.length
-          io.write segment
-          $stdout.write "\e[0G\e[Kdownloading #{count}/#{len} bytes (#{(count*100)/len}%)"
-          $stdout.flush
-        end
-      end
-      $stdout.puts
-    else
-      err "download failed: #{res.message}"
-    end
-  end
+  http_download file.datastore._connection, download_path, local_path
 end
 
 
@@ -69,54 +47,9 @@ def upload local_path, dest
   err "local file does not exist" unless File.exists? local_path
   real_datastore_path = "#{dir.path}/#{datastore_filename}"
 
-  main_http = dir.datastore._connection.http
-  http = Net::HTTP.new(main_http.address, main_http.port)
-  http.use_ssl = true
-  http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-  #http.set_debug_output $stderr
-  http.start
-  err "certificate mismatch" unless main_http.peer_cert.to_der == http.peer_cert.to_der
+  upload_path = http_path dir.datastore.send(:datacenter).name, dir.datastore.name, real_datastore_path
 
-  File.open(local_path, 'rb') do |io|
-    stream = ProgressStream.new(io, io.stat.size) do |s|
-      $stdout.write "\e[0G\e[Kuploading #{s.count}/#{s.len} bytes (#{(s.count*100)/s.len}%)"
-      $stdout.flush
-    end
-
-    headers = {
-      'cookie' => dir.datastore._connection.cookie,
-      'content-length' => io.stat.size.to_s,
-      'Content-Type' => 'application/octet-stream',
-    }
-    path = http_path dir.datastore.send(:datacenter).name, dir.datastore.name, real_datastore_path
-    request = Net::HTTP::Put.new path, headers
-    request.body_stream = stream
-    res = http.request(request)
-    $stdout.puts
-    case res
-    when Net::HTTPOK
-    else
-      err "upload failed: #{res.message}"
-    end
-  end
-end
-
-class ProgressStream
-  attr_reader :io, :len, :count
-
-  def initialize io, len, &b
-    @io = io
-    @len = len
-    @count = 0
-    @cb = b
-  end
-
-  def read n
-    io.read(n).tap do |c|
-      @count += c.length if c
-      @cb[self]
-    end
-  end
+  http_upload dir.datastore._connection, local_path, upload_path
 end
 
 
@@ -256,7 +189,7 @@ def find_orphans ds, opts
   if data.empty?
     puts "No orphans found"
   else
-    puts(table do
+    puts(Terminal::Table.new do
       data.sort_by { |a| a[1] }.each do |x|
         dir, dirSize, numFiles = x
         self.headings = 'Directory', 'Space Used', '# Files'
@@ -287,14 +220,14 @@ def find_orphans ds, opts
     RbVmomi::VIM::Datastore::FakeDatastoreFolder.new(ds, "#{dirInfo[0]}")
   end
   opts[:mark] ||= "#{dsName}_orphans"
-  CMD.mark.mark opts[:mark], results
+  shell.cmds.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]
+    shell.cmds.mark.mark i.to_s, [r]
     i += 1
   end
 end

data/lib/rvc/modules/device.rb

@@ -1,3 +1,26 @@
+# 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.
+
+require 'rvc/vim'
+VIM::Datastore
+
 opts :connect do
   summary "Connect a virtual device"
   arg :device, nil, :lookup => VIM::VirtualDevice, :multi => true
@@ -21,13 +44,14 @@ end
 opts :remove do
   summary "Remove a virtual device"
   arg :device, nil, :lookup => VIM::VirtualDevice, :multi => true
+  opt :no_destroy, "Do not delete backing files"
 end
 
-def remove devs
+def remove devs, opts
   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
+      fileOp = (dev.backing.is_a?(VIM::VirtualDeviceFileBackingInfo) && !opts[:no_destroy]) ? 'destroy' : nil
       { :operation => :remove, :fileOperation => fileOp, :device => dev }
     end
     spec = { :deviceChange => device_changes }
@@ -82,15 +106,26 @@ end
 opts :add_disk do
   summary "Add a hard drive to a virtual machine"
   arg :vm, nil, :lookup => VIM::VirtualMachine
+  arg :path, "Filename on the datastore", :lookup_parent => VIM::Datastore::FakeDatastoreFolder, :required => false
   opt :size, 'Size', :default => '10G'
   opt :controller, 'Virtual controller', :type => :string, :lookup => VIM::VirtualController
+  opt :file_op, 'File operation (create|reuse|replace)', :default => 'create'
 end
 
-def add_disk vm, opts
+def add_disk vm, path, 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(
+
+  if path
+    dir, file = *path
+    filename = "#{dir.datastore_path}/#{file}"
+  else
+    filename = "#{File.dirname(vm.summary.config.vmPathName)}/#{id}.vmdk"
+  end
+
+  opts[:file_op] = nil if opts[:file_op] == 'reuse'
+
+  _add_device vm, opts[:file_op], VIM::VirtualDisk(
     :key => -1,
     :backing => VIM.VirtualDiskFlatVer2BackingInfo(
       :fileName => filename,

data/lib/rvc/modules/diagnostics.rb

@@ -0,0 +1,169 @@
+# Copyright (c) 2012 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.
+
+DEFAULT_SERVER_PLACEHOLDER = '0.0.0.0'
+
+def wait_for_multiple_tasks tasks, timeout
+  if tasks == []
+    return []
+  end
+  pc = tasks.first._connection.serviceContent.propertyCollector
+  done = false
+  t1 = Time.now
+  while !done && (Time.now - t1) < timeout
+    tasks_props = pc.collectMultiple(tasks, 'info.state')
+    if tasks_props.reject{|t,f| ['success', 'error'].member?(f['info.state'])}.empty?
+      done = true
+    end
+    sleep 2
+  end
+  tasks_props = pc.collectMultiple(tasks, 'info.state', 'info.error')
+  results = Hash[tasks_props.map do |task, props|
+    result = if props['info.state'] == 'success'
+      task.info.result
+    elsif props['info.state'] == 'error'
+      props['info.error']
+    else
+      "Timed out"
+    end
+    [task, result]
+  end]
+  results
+end
+
+
+opts :vm_create do
+  summary "Check that VMs can be created on all hosts in a cluster"
+  arg :cluster, nil, :lookup => VIM::ComputeResource, :multi => true
+  opt :datastore, "Datastore to put (temporary) VMs on", :lookup => VIM::Datastore
+  opt :vm_folder, "VM Folder to place (temporary) VMs in", :lookup => VIM::Folder
+  opt :timeout, "Time to wait for VM creation to finish", :type => :int, :default => 3 * 60
+end
+
+def vm_create clusters, opts
+  datastore = opts[:datastore]
+  vm_folder = opts[:vm_folder]
+  err "datastore is a required parameter" unless datastore
+  err "vm_folder is a required parameter" unless vm_folder
+
+  puts "Creating one VM per host ... (timeout = #{opts[:timeout]} sec)"
+  result = _vm_create clusters, datastore, vm_folder, opts
+
+  errors = result.select{|h, x| x['status'] != 'green'}
+  errors.each do |host, info|
+    puts "Failed to create VM on host #{host} (in cluster #{info['cluster']}): #{info['error']}"
+  end
+  if errors.length == 0
+    puts "Success"
+  end
+end
+
+def _vm_create clusters, datastore, vm_folder, opts = {}
+  pc = datastore._connection.serviceContent.propertyCollector
+  datastore_path = "[#{datastore.name}]"
+  run = Time.now.to_i % 1000
+  tasks_map = {}
+  cluster_host_map = {}
+  clusters_props = pc.collectMultiple(clusters, 'name', 'resourcePool', 'host')
+  all_hosts = clusters_props.map{|c, p| p['host']}.flatten
+  hosts_props = pc.collectMultiple(all_hosts, 'name')
+
+  hosts_infos = Hash[all_hosts.map{|host| [host, {}]}]
+  
+  clusters.each do |cluster|
+    cluster_props = clusters_props[cluster]
+    rp = cluster_props['resourcePool']
+    hosts = cluster_props['host']
+    hosts.map do |host|
+      cluster_host_map[host] = cluster
+      config = {
+        :name => "VM-on-#{hosts_props[host]['name']}-#{run}",
+        :guestId => 'otherGuest',
+        :files => { :vmPathName => datastore_path },
+        :numCPUs => 1,
+        :memoryMB => 16,
+        :deviceChange => [
+          {
+            :operation => :add,
+            :device => VIM.VirtualCdrom(
+              :key => -2,
+              :connectable => {
+                :allowGuestControl => true,
+                :connected => true,
+                :startConnected => true,
+              },
+              :backing => VIM.VirtualCdromIsoBackingInfo(
+                :fileName => datastore_path
+              ),
+              :controllerKey => 200,
+              :unitNumber => 0
+            )
+          }
+        ],
+      }
+      task = vm_folder.CreateVM_Task(:config => config,
+                                     :pool => rp,
+                                     :host => host)
+      tasks_map[task] = host
+      hosts_infos[host][:create_task] = task
+    end
+  end
+  
+  create_tasks = tasks_map.keys
+  create_results = wait_for_multiple_tasks create_tasks, opts[:timeout]
+  create_results.each { |t, r| hosts_infos[tasks_map[t]][:create_result] = r }
+
+  vms = create_results.select{|t, x| x.is_a? VIM::VirtualMachine}
+  destroy_tasks = Hash[vms.map{|t, x| [x.Destroy_Task, t]}]
+
+  destroy_results = wait_for_multiple_tasks destroy_tasks.keys, opts[:timeout]
+  destroy_results.each do |t, r|
+    create_task = destroy_tasks[t]
+    hosts_infos[tasks_map[create_task]][:destroy_result] = r 
+  end
+
+  out = {}
+  all_hosts.each do |host|
+    host_info = hosts_infos[host]
+    host_props = hosts_props[host]
+    cluster = cluster_host_map[host]
+    cluster_props = clusters_props[cluster]
+
+    result = host_info[:create_result]
+    result = host_info[:destroy_result] if result.is_a?(VIM::VirtualMachine)
+    if result == nil
+      error_str = nil
+      status = 'green'
+    elsif result.is_a?(String)
+      error_str = result
+      status = 'red'
+    else
+      error_str = "#{result.fault.class.wsdl_name}: #{result.localizedMessage}"
+      status = 'red'
+    end
+
+    out[host_props['name']] = {
+      'cluster' => cluster_props['name'],
+      'status' => status,
+      'error' => error_str
+    }    
+  end
+  out
+end

data/lib/rvc/modules/esxcli.rb

@@ -18,9 +18,13 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'rvc/vim'
+
+require 'rvc/ttl_cache'
+
 raw_opts :execute, "Execute an esxcli command"
 
-EsxcliCache = TTLCache.new 60
+EsxcliCache = RVC::TTLCache.new 60
 
 def lookup_esxcli host, args
   cur = EsxcliCache[host, :esxcli]
@@ -40,14 +44,14 @@ def lookup_esxcli host, args
   return cur
 end
 
-rvc_completor :execute do |line, args, word, argnum|
-  if argnum == 0
+rvc_completor :execute do |word, args|
+  if args.length == 1
     # HostSystem argument
-    RVC::Completion.fs_candidates word
+    shell.completion.fs_candidates word
   else
     # esxcli namespace/method/arguments
     host = lookup_single! args[0], VIM::HostSystem
-    o = lookup_esxcli host, args[1...argnum]
+    o = lookup_esxcli host, args[1...-1]
 
     case o
     when VIM::EsxcliCommand

data/lib/rvc/modules/find.rb

@@ -18,6 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'rvc/vim'
+
 opts :find do
   summary "Find objects matching certain criteria"
   arg :args, "Paths or +terms", :required => false, :multi => true
@@ -37,14 +39,14 @@ def find args, opts
 
   results = find_items args[:term], args[:root], opts[:type]
 
-  CMD.mark.mark opts[:mark], results
+  shell.cmds.mark.mark opts[:mark], results
 
   i = 0
-  cwd = $shell.fs.cur.rvc_path_str
+  cwd = shell.fs.cur.rvc_path_str
   cwd_prefix = /^#{Regexp.escape cwd}\//
   results.each do |r|
     puts "#{i} #{r.rvc_path_str.gsub(cwd_prefix, '')}"
-    CMD.mark.mark i.to_s, [r]
+    shell.cmds.mark.mark i.to_s, [r]
     i += 1
   end
 end

data/lib/rvc/modules/host.rb

@@ -18,14 +18,35 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'rvc/vim'
+
 opts :reboot do
-  summary "Reboot a host"
+  summary "Reboot hosts"
   arg :host, nil, :lookup => VIM::HostSystem, :multi => true
-  opt :force, "Reboot even if in maintenance mode", :default => false
+  opt :force, "Reboot even if not in maintenance mode", :default => false
+  opt :wait, "Wait for the host to be connected again", :type => :boolean
 end
 
 def reboot hosts, opts
   tasks hosts, :RebootHost, :force => opts[:force]
+
+  if opts[:wait]
+    puts "Waiting for hosts to reboot ..."
+    # There is no proper way to wait for a host to reboot, so we
+    # implement a heuristic that is close enough:
+    # First we wait for a moment to give the host time to actually
+    # disconnect. Then we just wait for it to be responding again.
+    sleep 3 * 60
+
+    hosts.each do |host|
+      # We could use the property collector here to wait for an
+      # update instead of polling.
+      while !(host.runtime.connectionState == "connected" && host.runtime.powerState == "poweredOn")
+        sleep 10
+      end
+      puts "Host #{host.name} is back up"
+    end
+  end
 end
 
 
@@ -76,10 +97,18 @@ opts :enter_maintenance_mode do
   summary "Put hosts into maintenance mode"
   arg :host, nil, :lookup => VIM::HostSystem, :multi => true
   opt :timeout, "Timeout", :default => 0
+  opt :evacuate_powered_off_vms, "Evacuate powered off vms", :type => :boolean
+  opt :no_wait, "Don't wait for Task to complete", :type => :boolean
 end
 
 def enter_maintenance_mode hosts, opts
-  tasks hosts, :EnterMaintenanceMode, :timeout => opts[:timeout]
+  if opts[:no_wait]
+    hosts.each do |host|
+      host.EnterMaintenanceMode_Task(:timeout => opts[:timeout], :evacuatePoweredOffVms => opts[:evacuate_powered_off_vms])
+    end
+  else
+    tasks hosts, :EnterMaintenanceMode, :timeout => opts[:timeout], :evacuatePoweredOffVms => opts[:evacuate_powered_off_vms]
+  end
 end
 
 
@@ -160,3 +189,17 @@ def add_nfs_datastore hosts, opts
     datastoreSystem.CreateNasDatastore :spec => spec
   end
 end
+
+
+opts :rescan_storage do
+  summary "Rescan HBAs and VMFS"
+  arg :host, nil, :lookup => VIM::HostSystem, :multi => true
+end
+
+def rescan_storage hosts
+  hosts.each do |host|
+    storageSystem = host.configManager.storageSystem
+    storageSystem.RescanAllHba
+    storageSystem.RescanVmfs
+  end
+end