rvc 1.5.0 → 1.6.0

data/lib/rvc/modules/vim.rb

@@ -30,10 +30,31 @@ URI_REGEX = %r{
     @
   )?
   ([^@:]+)
-  (?::(.*))?
+  (?::(\d{1,5}))?
+  (?::([0-9a-z]{64}))?
   $
 }x
 
+class RbVmomi::VIM
+  include RVC::InventoryObject
+
+  def children
+    rootFolder.children
+  end
+
+  def self.folder?
+    true
+  end
+
+  def display_info
+    puts serviceContent.about.fullName
+  end
+
+  def _connection
+    self
+  end
+end
+
 opts :connect do
   summary 'Open a connection to ESX/VC'
   arg :uri, "Host to connect to"
@@ -49,14 +70,15 @@ def connect uri, opts
   username = match[1] || ENV['RBVMOMI_USER']
   password = match[2] || ENV['RBVMOMI_PASSWORD']
   host = match[3]
-  path = match[4]
+  port = match[4] || 443
+  certdigest = match[5] || opts[:certdigest]
   bad_cert = false
 
   vim = nil
   loop do
     begin
       vim = RbVmomi::VIM.new :host => host,
-                             :port => 443,
+                             :port => port,
                              :path => '/sdk',
                              :ns => 'urn:vim25',
                              :rev => (opts[:rev]||'4.0'),
@@ -73,15 +95,27 @@ def connect uri, opts
   end
 
   if bad_cert
-    # Fall back to SSH-style known_hosts
     peer_public_key = vim.http.peer_cert.public_key
-    check_known_hosts(host, peer_public_key)
+    # if user specified a hash on the commandline, verify against that
+    if certdigest
+      if certdigest != Digest::SHA2.hexdigest(peer_public_key.to_s())
+        err "Bad certificate digest specified for #{host}!"
+      end
+    else
+      # Fall back to SSH-style known_hosts
+      check_known_hosts(host, peer_public_key)
+    end
   end
 
   unless opts[:rev]
     # negotiate API version
     rev = vim.serviceContent.about.apiVersion
-    vim.rev = [rev, ENV['RVC_VIMREV'] || '5.0'].min
+    env_rev = ENV['RVC_VIMREV']
+    if env_rev && env_rev.to_f == 0
+      vim.rev = env_rev
+    else
+      vim.rev = [rev, env_rev || '5.0'].min
+    end
   end
 
   isVC = vim.serviceContent.about.apiType == "VirtualCenter"
@@ -106,15 +140,19 @@ def connect uri, opts
     loaded_from_keychain = password
   end
 
-  password_given = password != nil
-  loop do
-    begin
-      password = prompt_password unless password_given
-      vim.serviceContent.sessionManager.Login :userName => username,
-                                              :password => password
-      break
-    rescue RbVmomi::VIM::InvalidLogin
-      err $!.message if password_given
+  if opts[:cookie]
+    vim.cookie = opts[:cookie]
+  else
+    password_given = password != nil
+    loop do
+      begin
+        password = prompt_password unless password_given
+        vim.serviceContent.sessionManager.Login :userName => username,
+                                                :password => password
+        break
+      rescue RbVmomi::VIM::InvalidLogin
+        err $!.message if password_given
+      end
     end
   end
 
@@ -147,7 +185,7 @@ def prompt_password
 end
 
 def keychain_password username , hostname
-   return nil unless RbConfig::CONFIG['host_os'] =~ /^darwin10/
+   return nil unless RbConfig::CONFIG['host_os'] =~ /^darwin1[01]/
 
   begin
     require 'osx_keychain'
@@ -198,16 +236,6 @@ def check_known_hosts host, peer_public_key
   end
 end
 
-class RbVmomi::VIM
-  def display_info
-    puts serviceContent.about.fullName
-  end
-
-  def _connection
-    self
-  end
-end
-
 
 opts :tasks do
   summary "Watch tasks in progress"
@@ -269,3 +297,52 @@ def tasks
     view.DestroyView if view
   end
 end
+
+
+opts :logbundles do
+  summary "Download log bundles"
+  arg :servers, "VIM connection and/or ESX hosts", :lookup => [RbVmomi::VIM, VIM::HostSystem], :multi => true
+  opt :dest, "Destination directory", :default => '.'
+end
+
+DEFAULT_SERVER_PLACEHOLDER = '0.0.0.0'
+
+def logbundles servers, opts
+  vim = single_connection servers
+  diagMgr = vim.serviceContent.diagnosticManager
+  name = vim.host
+  FileUtils.mkdir_p opts[:dest]
+
+  hosts = servers.grep VIM::HostSystem
+  include_default = servers.member? vim
+
+  puts "#{Time.now}: Generating log bundles..."
+  bundles =
+    begin
+      diagMgr.GenerateLogBundles_Task(:includeDefault => include_default, :host => hosts).wait_for_completion
+    rescue VIM::TaskInProgress
+      $!.task.wait_for_completion
+    end
+
+  dest_path = nil
+  bundles.each do |b|
+    uri = URI.parse(b.url.sub('*', DEFAULT_SERVER_PLACEHOLDER))
+    bundle_name = b.system ? b.system.name : name
+    dest_path = File.join(opts[:dest], "#{bundle_name}-" + File.basename(uri.path))
+    puts "#{Time.now}: Downloading bundle #{b.url} to #{dest_path}"
+    uri.host = vim.http.address if uri.host == DEFAULT_SERVER_PLACEHOLDER
+    Net::HTTP.get_response uri do |res|
+      File.open dest_path, 'w' do |io|
+        res.read_body do |data|
+          io.write data
+          if $stdout.tty?
+            $stdout.write '.'
+            $stdout.flush
+          end
+        end
+      end
+      puts if $stdout.tty?
+    end
+  end
+  dest_path
+end

data/lib/rvc/modules/vm.rb

@@ -68,13 +68,39 @@ def suspend vms
 end
 
 
+opts :wait_for_shutdown do
+  summary "Waits for a VM to shutdown"
+  arg :vm, nil, :multi => true, :lookup => VIM::VirtualMachine
+  opt :timeout, "Timeout in seconds", :type => :int, :default => 300
+  opt :delay, "Interval in seconds", :type => :int, :default => 5
+end
+
+def wait_for_shutdown vms, opts
+  finish_time = Time.now + opts[:timeout]
+  while Time.now < finish_time
+    all_off = true
+    vms.each do |vm|
+      if vm.summary.runtime.powerState == 'poweredOn'
+        all_off = false
+      end
+    end
+    return if all_off
+    sleep [opts[:delay], finish_time - Time.now].min
+  end
+  puts "WARNING: At least one VM did not shut down!"
+end
+
+
 opts :shutdown_guest do
   summary "Shut down guest OS"
   arg :vm, nil, :multi => true, :lookup => VIM::VirtualMachine
+  opt :timeout, "Timeout for guest shut down in seconds", :type => :int, :default => nil
+  opt :delay, "Interval between checks for guest shut down in seconds", :type => :int, :default => nil
 end
 
-def shutdown_guest vms
+def shutdown_guest vms, opts
   vms.each(&:ShutdownGuest)
+  wait_for_shutdown vms, opts unless opts[:timeout].nil?
 end
 
 
@@ -102,44 +128,25 @@ opts :create do
   summary "Create a new VM"
   arg :name, "Destination", :lookup_parent => VIM::Folder
   opt :pool, "Resource pool", :short => 'p', :type => :string, :lookup => VIM::ResourcePool
-  opt :host, "Host", :short => 'h', :type => :string, :lookup => VIM::HostSystem
+  opt :host, "Host", :short => 'o', :type => :string, :lookup => VIM::HostSystem
   opt :datastore, "Datastore", :short => 'd', :type => :string, :lookup => VIM::Datastore
-  opt :disksize, "Size in KB of primary disk (or add a unit of <M|G|T>)", :short => 's', :type => :string, :default => "4000000"
   opt :memory, "Size in MB of memory", :short => 'm', :type => :int, :default => 128
-  opt :cpucount, "Number of CPUs", :short => 'c', :type => :int, :default => 1
+  opt :cpus, "Number of CPUs", :short => 'c', :type => :int, :default => 1
+  opt :guest_id, "Guest OS", :short => 'g', :default => "otherGuest" # XXX tab complete
+
   text <<-EOB
 
-Example:
-  vm.create -p ~foo/resourcePool/pools/prod -d ~data/bigdisk -s 10g ~vms/new
+  No disks or network adapters are initially present. Use device.add_disk and
+  device.add_net to do this.
 
+Example:
+  vm.create ~/vm/foo --pool ~/host/my_cluster/resourcePool --datastore ~/datastore/my_datastore
+  device.add_disk ~/vm/foo -s 30G
+  device.add_net ~/vm/foo ~/network/VM\\ Network
   EOB
 end
 
 
-def realdisksize( size )
-  size.downcase!
-  if size =~ /([0-9][0-9,]*)([mgt])?/i
-    size = $1.delete(',').to_i
-    unit = $2
-
-    case unit
-    when 'm'
-      return size * 1024
-    when 'g'
-      return size * ( 1024 ** 2 )
-    when 't'
-      return size * ( 1024 ** 3 )
-    when nil
-      return size
-    else
-      err "Unknown size modifer of '#{unit}'"
-    end
-  else
-    err "Problem with #{size}"
-  end
-end
-
-
 def create dest, opts
   err "must specify resource pool (--pool)" unless opts[:pool]
   err "must specify datastore (--datastore)" unless opts[:datastore]
@@ -148,33 +155,12 @@ def create dest, opts
   datastore_path = "[#{opts[:datastore].name}]"
   config = {
     :name => name,
-    :guestId => 'otherGuest',
+    :guestId => opts[:guest_id],
     :files => { :vmPathName => datastore_path },
     :numCPUs => opts[:cpucount],
     :memoryMB => opts[:memory],
     :deviceChange => [
       {
-        :operation => :add,
-        :device => VIM.VirtualLsiLogicController(
-          :key => 1000,
-          :busNumber => 0,
-          :sharedBus => :noSharing
-        )
-      }, {
-        :operation => :add,
-        :fileOperation => :create,
-        :device => VIM.VirtualDisk(
-          :key => -1,
-          :backing => VIM.VirtualDiskFlatVer2BackingInfo(
-            :fileName => datastore_path,
-            :diskMode => :persistent,
-            :thinProvisioned => true
-          ),
-          :controllerKey => 1000,
-          :unitNumber => 0,
-          :capacityInKB => realdisksize( opts[:disksize] )
-        )
-      }, {
         :operation => :add,
         :device => VIM.VirtualCdrom(
           :key => -2,
@@ -189,19 +175,6 @@ def create dest, opts
           :controllerKey => 200,
           :unitNumber => 0
         )
-      }, {
-        :operation => :add,
-        :device => VIM.VirtualE1000(
-          :key => -3,
-          :deviceInfo => {
-            :label => 'Network Adapter 1',
-            :summary => 'VM Network'
-          },
-          :backing => VIM.VirtualEthernetCardNetworkBackingInfo(
-            :deviceName => 'VM Network'
-          ),
-          :addressType => 'generated'
-        )
       }
     ],
   }
@@ -211,30 +184,6 @@ def create dest, opts
 end
 
 
-opts :insert_cdrom do
-  summary "Put a disc in a virtual CDROM drive"
-  arg :vm, nil, :lookup => VIM::VirtualMachine
-  arg :iso, "Path to the ISO image on a datastore", :lookup => VIM::Datastore::FakeDatastoreFile
-end
-
-def insert_cdrom vm, iso
-  device = vm.config.hardware.device.grep(VIM::VirtualCdrom)[0]
-  err "No virtual CDROM drive found" unless device
-
-  device.backing = VIM.VirtualCdromIsoBackingInfo(:fileName => iso.datastore_path)
-
-  spec = {
-    :deviceChange => [
-      {
-        :operation => :edit,
-        :device => device
-      }
-    ]
-  }
-  
-  vm.ReconfigVM_Task(:spec => spec)
-end
-
 opts :register do
   summary "Register a VM already in a datastore"
   arg :file, "RVC path to the VMX file", :lookup => VIM::Datastore::FakeDatastoreFile
@@ -326,22 +275,26 @@ def kill vms
   CMD.basic.destroy vms unless vms.empty?
 end
 
-
 opts :answer do
   summary "Answer a VM question"
-  arg :vm, nil, :lookup => VIM::VirtualMachine
   arg :choice, "Answer ID"
+  arg :vm, nil, :lookup => VIM::VirtualMachine, :multi => true
 end
 
-def answer vm, str
-  q = vm.runtime.question
-  err "no question" unless q
-  choice = q.choice.choiceInfo.find { |x| x.label == str }
-  err("invalid answer") unless choice
-  vm.AnswerVM :questionid => q.path, :answerChoice => choice.key
+def answer str, vms
+  vms.each do |vm|
+    begin
+      if q = vm.runtime.question
+        choice = q.choice.choiceInfo.find { |x| x.label == str }
+        err("invalid answer") unless choice
+        vm.AnswerVM :questionId => q.id, :answerChoice => choice.key
+      end
+    rescue
+      puts "#{vm.name rescue vm}: #{$!.message}"
+    end
+  end
 end
 
-
 opts :layout do
   summary "Display info about VM files"
   arg :vm, nil, :lookup => VIM::VirtualMachine
@@ -354,43 +307,6 @@ def layout vm
 end
 
 
-opts :devices do
-  summary "Display info about VM devices"
-  arg :vm, nil, :lookup => VIM::VirtualMachine
-end
-
-def devices vm
-  devs = vm.config.hardware.device
-  devs.each do |dev|
-    tags = []
-    tags << (dev.connectable.connected ? :connected : :disconnected) if dev.props.member? :connectable
-    puts "#{dev.deviceInfo.label} (#{dev.class}): #{dev.deviceInfo.summary}; #{tags * ' '}"
-  end
-end
-
-
-opts :connect do
-  summary "Connect a virtual device"
-  arg :vm, nil, :lookup => VIM::VirtualMachine
-  arg :label, "Device label"
-end
-
-def connect vm, label
-  change_device_connectivity vm, label, true
-end
-
-
-opts :disconnect do
-  summary "Disconnect a virtual device"
-  arg :vm, nil, :lookup => VIM::VirtualMachine
-  arg :label, "Device label"
-end
-
-def disconnect vm, label
-  change_device_connectivity vm, label, false
-end
-
-
 opts :find do
   summary "Display a menu of VMX files to register"
   arg :datastore, nil, :lookup => VIM::Datastore
@@ -417,37 +333,37 @@ def find ds, opts
 end
 
 
-opts :extraConfig do
+opts :extra_config do
   summary "Display extraConfig options"
   arg :vm, nil, :lookup => VIM::VirtualMachine
   arg :regex, "Regexes to filter keys", :multi => true, :required => false
 end
 
-def extraConfig vm, regexes
-  _extraConfig(vm, *regexes.map { |x| /#{x}/ })
+def extra_config vm, regexes
+  _extra_config(vm, *regexes.map { |x| /#{x}/ })
 end
 
 
-opts :setExtraConfig do
+opts :set_extra_config do
   summary "Set extraConfig options"
   arg :vm, nil, :lookup => VIM::VirtualMachine
   arg 'key=value', "extraConfig key/value pairs", :multi => true
 end
 
-def setExtraConfig vm, pairs
+def set_extra_config vm, pairs
   h = Hash[pairs.map { |x| x.split('=', 2).tap { |a| a << '' if a.size == 1 } }]
-  _setExtraConfig vm, h
+  _set_extra_config vm, h
 end
 
 
-def _setExtraConfig vm, hash
+def _set_extra_config vm, hash
   cfg = {
     :extraConfig => hash.map { |k,v| { :key => k, :value => v } },
   }
   vm.ReconfigVM_Task(:spec => cfg).wait_for_completion
 end
 
-def _extraConfig vm, *regexes
+def _extra_config vm, *regexes
   vm.config.extraConfig.each do |h|
     if regexes.empty? or regexes.any? { |r| h[:key] =~ r }
       puts "#{h[:key]}: #{h[:value]}"
@@ -492,6 +408,34 @@ def rvc vm, opts
   system_fg(cmd, env)
 end
 
+opts :rdp do
+  summary "Connect via RDP"
+  arg :vms, nil, :lookup => VIM::VirtualMachine, :multi => true
+  opt :resolution, "Desired resolution", :type => :string, :default => ($rdpResolution ? $rdpResolution : '1024x768')
+  opt :username, "Username", :type => :string, :default => 'Administrator'
+  opt :password, "Password", :type => :string, :default => ($rdpDefaultPassword ? $rdpDefaultPassword : '')
+end
+
+rvc_alias :rdp, :rdp
+
+def rdp vms, h
+  resolution = h[:resolution]
+  if !resolution
+    resolution = $rdpResolution ? $rdpResolution : '1024x768'  
+  end
+  vms.each do |vm|
+    ip = vm_ip vm
+
+    begin
+      timeout(1) { TCPSocket.new ip, 3389; up = true }
+    rescue
+      puts "#{vm.name}: Warning: Looks like the RDP port is not responding"
+    end
+    
+    cmd = "rdesktop -u '#{h[:username]}' -p '#{h[:password]}' -g#{resolution} #{ip} >/dev/null 2>&1 &"
+    system(cmd)
+  end
+end
 
 opts :ping do
   summary "Ping a VM"
@@ -542,71 +486,11 @@ ensure
 end
 
 
-opts :add_net_device do
-  summary "Add a network adapter to a virtual machine"
-  arg :vm, nil, :lookup => VIM::VirtualMachine
-  opt :type, "Adapter type", :default => 'e1000'
-  opt :network, "Network to connect to", :default => 'VM Network'
-end
-
-def add_net_device vm, opts
-  case opts[:type]
-  when 'e1000'
-    _add_net_device vm, VIM::VirtualE1000, opts[:network]
-  when 'vmxnet3'
-    _add_net_device vm, VIM::VirtualVmxnet3, opts[:network]
-  else err "unknown device"
-  end
-end
-
-
-def _add_device vm, dev
-  spec = {
-    :deviceChange => [
-      { :operation => :add, :device => dev },
-    ]
-  }
-  vm.ReconfigVM_Task(:spec => spec).wait_for_completion
-end
-
-def _add_net_device vm, klass, network
-  _add_device vm, klass.new(
-    :key => -1,
-    :deviceInfo => {
-      :summary => network,
-      :label => `uuidgen`.chomp
-    },
-    :backing => VIM.VirtualEthernetCardNetworkBackingInfo(
-      :deviceName => network
-    ),
-    :addressType => 'generated'
-  )
-end
-
-
-opts :remove_device do
-  summary "Remove a virtual device"
-  arg :vm, nil, :lookup => VIM::VirtualMachine
-  arg :label, "Device label"
-end
-
-def remove_device vm, label
-  dev = vm.config.hardware.device.find { |x| x.deviceInfo.label == label }
-  err "no such device" unless dev
-  spec = {
-    :deviceChange => [
-      { :operation => :remove, :device => dev },
-    ]
-  }
-  vm.ReconfigVM_Task(:spec => spec).wait_for_completion
-end
-
-
 opts :migrate do
   summary "Migrate a VM"
   arg :vm, nil, :lookup => VIM::VirtualMachine, :multi => true
   opt :pool, "Resource pool", :short => 'p', :type => :string, :lookup => VIM::ResourcePool
-  opt :host, "Host", :short => 'h', :type => :string, :lookup => VIM::HostSystem
+  opt :host, "Host", :short => 'o', :type => :string, :lookup => VIM::HostSystem
 end
 
 def migrate vms, opts
@@ -621,10 +505,10 @@ opts :clone do
   arg :src, nil, :lookup => VIM::VirtualMachine
   arg :dst, "Path to new VM", :lookup_parent => VIM::Folder
   opt :pool, "Resource pool", :short => 'p', :type => :string, :lookup => VIM::ResourcePool
-  opt :host, "Host", :short => 'h', :type => :string, :lookup => VIM::HostSystem
+  opt :host, "Host", :short => 'o', :type => :string, :lookup => VIM::HostSystem
   opt :template, "Create a template", :short => 't'
   opt :linked, "Create a linked clone", :short => 'l'
-  opt :powerOn, "Power on VM after clone"
+  opt :power_on, "Power on VM after clone"
 end
 
 def clone src, dst, opts
@@ -645,12 +529,11 @@ def clone src, dst, opts
                               :pool => opts[:pool],
                             },
                             :template => opts[:template],
-                            :powerOn => opts[:powerOn],
+                            :powerOn => opts[:power_on],
                           })
   progress [task]
 end
 
-
 def deltaize_disks vm
   real_disks = vm.config.hardware.device.grep(VIM::VirtualDisk).select { |x| x.backing.parent == nil }
   unless real_disks.empty?
@@ -703,6 +586,8 @@ opts :modify_memory do
 end
 
 def modify_memory vm, opts
+  err "VM needs to be off" unless vm.summary.runtime.powerState == 'poweredOff'
+  err "memory must be a multiple of 4MB" unless ( opts[:size]  % 4 ) == 0
   spec = { :memoryMB => opts[:size] }
   tasks [vm], :ReconfigVM, :spec => spec
 end
@@ -730,18 +615,6 @@ def find_vmx_files ds
   files
 end
 
-def change_device_connectivity vm, label, connected
-  dev = vm.config.hardware.device.find { |x| x.deviceInfo.label == label }
-  err "no such device" unless dev
-  dev.connectable.connected = connected
-  spec = {
-    :deviceChange => [
-      { :operation => :edit, :device => dev },
-    ]
-  }
-  vm.ReconfigVM_Task(:spec => spec).wait_for_completion
-end
-
 def vm_ip vm
   summary = vm.summary