rvc 1.6.0 → 1.7.0

data/lib/rvc/modules/basic.rb

@@ -18,6 +18,10 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'rvc/vim'
+
+require 'terminal-table'
+
 opts :type do
   summary "Display information about a VMODL type"
   arg :name, "VMODL type name"
@@ -27,69 +31,71 @@ rvc_alias :type
 
 def type name
   klass = RbVmomi::VIM.type(name) rescue err("#{name.inspect} is not a VMODL type.")
-  $shell.introspect_class klass
+  shell.introspect_class klass
   nil
 end
 
 
 opts :help do
   summary "Display this text"
-  arg :path, "Limit commands to those applicable to the given object", :required => false
+  arg :cmd, "Command or namespace to display help for", :required => false
 end
 
 rvc_alias :help
 
 HELP_ORDER = %w(basic vm)
 
-def help path
-  if mod = RVC::MODULES[path]
-    opts = mod.instance_variable_get(:@opts)
-    opts.each do |method_name,parser|
-      help_summary parser, path, method_name
-    end
-    return
-  elsif tgt = RVC::ALIASES[path]
-    fail unless tgt =~ /^(.+)\.(.+)$/
-    RVC::MODULES[$1].opts_for($2.to_sym).educate
-    return
-  elsif path =~ /^(.+)\.(.+)$/ and
-        mod = RVC::MODULES[$1] and
-        parser = mod.opts_for($2.to_sym)
-    parser.educate
-    return
+def help input
+  if input
+    cmdpath, args = Shell.parse_input input
+    o = shell.cmds.lookup(cmdpath, Namespace) || shell.cmds.lookup(cmdpath)
+    RVC::Util.err "invalid command or namespace" unless o
+  else
+    o = shell.cmds
   end
 
-  obj = lookup_single(path) if path
-
-  if obj
-    puts "Relevant commands for #{obj.class}:"
-  else
-    puts "All commands:"
+  case o
+  when Command
+    o.parser.educate
+  when Namespace
+    help_namespace o
   end
 
-  MODULES.sort_by do |mod_name,mod|
-    HELP_ORDER.index(mod_name) || HELP_ORDER.size
-  end.each do |mod_name,mod|
-    opts = mod.instance_variable_get(:@opts)
-    opts.each do |method_name,parser|
-      next unless obj.nil? or parser.applicable.any? { |x| obj.is_a? x }
-      help_summary parser, mod_name, method_name
+  # TODO apropos
+  puts (<<-EOS)
+
+To see commands in a namespace: help namespace_name
+To see detailed help for a command: help namespace_name.command_name
+  EOS
+end
+
+# TODO namespace summaries
+def help_namespace ns
+  unless ns.namespaces.empty?
+    puts "Namespaces:"
+    ns.namespaces.sort_by do |child_name,child|
+      HELP_ORDER.index(child_name.to_s) || HELP_ORDER.size
+    end.each do |child_name,child|
+      puts child_name
     end
   end
 
-  if not obj
-    puts (<<-EOS)
+  puts unless ns.namespaces.empty? or ns.commands.empty?
 
-To see detailed help for a command, use its --help option.
-To show only commands relevant to a specific object, use "help /path/to/object".
-    EOS
+  unless ns.commands.empty?
+    puts "Commands:"
+    ns.commands.sort_by do |cmd_name,cmd|
+      HELP_ORDER.index(cmd_name.to_s) || HELP_ORDER.size
+    end.each do |cmd_name,cmd|
+      help_summary cmd
+    end
   end
 end
 
-def help_summary parser, mod_name, method_name
-  aliases = ALIASES.select { |k,v| v == "#{mod_name}.#{method_name}" }.map(&:first)
+def help_summary cmd
+  aliases = shell.cmds.aliases.select { |k,v| shell.cmds.lookup(v) == cmd }.map(&:first)
   aliases_text = aliases.empty? ? '' : " (#{aliases*', '})"
-  puts "#{mod_name}.#{method_name}#{aliases_text}: #{parser.summary?}" if parser.summary?
+  puts "#{cmd.name}#{aliases_text}: #{cmd.summary}"
 end
 
 
@@ -100,8 +106,8 @@ end
 rvc_alias :debug
 
 def debug
-  debug = $shell.debug = !$shell.debug
-  $shell.connections.each do |name,conn|
+  debug = shell.debug = !shell.debug
+  shell.connections.each do |name,conn|
     conn.debug = debug if conn.respond_to? :debug
   end
   puts "debug mode #{debug ? 'en' : 'dis'}abled"
@@ -116,14 +122,14 @@ end
 rvc_alias :cd
 
 def cd obj
-  $shell.fs.cd(obj)
-  $shell.session.set_mark '', [find_ancestor(RbVmomi::VIM::Datacenter)].compact
-  $shell.session.set_mark '@', [find_ancestor(RbVmomi::VIM)].compact
-  $shell.delete_numeric_marks
+  shell.fs.cd(obj)
+  shell.fs.marks[''] = [find_ancestor(RbVmomi::VIM::Datacenter)].compact
+  shell.fs.marks['@'] = [find_ancestor(RbVmomi::VIM)].compact
+  shell.fs.delete_numeric_marks
 end
 
 def find_ancestor klass
-  $shell.fs.cur.rvc_path.map { |k,v| v }.reverse.find { |x| x.is_a? klass }
+  shell.fs.cur.rvc_path.map { |k,v| v }.reverse.find { |x| x.is_a? klass }
 end
 
 
@@ -148,7 +154,7 @@ def ls obj
   fake_children.each do |name,child|
     puts "#{i} #{name}#{child.ls_text(nil)}"
     child.rvc_link obj, name
-    CMD.mark.mark i.to_s, [child]
+    shell.cmds.mark.mark i.to_s, [child]
     i += 1
   end
 
@@ -179,7 +185,7 @@ def ls obj
     colored_name = status_color name, r['overallStatus']
     puts "#{i} #{colored_name}#{realname && " [#{realname}]"}#{text}"
     r.obj.rvc_link obj, name
-    CMD.mark.mark i.to_s, [r.obj]
+    shell.cmds.mark.mark i.to_s, [r.obj]
     i += 1
   end
 end
@@ -200,10 +206,10 @@ end
 
 rvc_alias :show
 
-rvc_completor :show do |line, args, word, index|
-  choices = RVC::Completion.fs_candidates word
+rvc_completor :show do |word, args|
+  choices = shell.completion.fs_candidates word
   obj = lookup_single '.'
-  if index == 0
+  if args.length == 1
     if obj.class == VIM::Datacenter || obj.class == VIM
       choices << ['portgroups', ' ']
       choices << ['vds', ' ']
@@ -234,7 +240,7 @@ def show arg0, arg1
   case arg0
   when 'running-config'
     if obj.class < VIM::DistributedVirtualSwitch
-      MODULES['vds'].show_running_config obj
+      shell.cmds.vds.show_running_config obj
     else
       if arg1 != '.'
         err "'#{arg1}' is not a vDS!"
@@ -243,11 +249,11 @@ def show arg0, arg1
       end
     end
   when 'portgroups'
-    MODULES['vds'].show_all_portgroups [obj]
+    shell.cmds.vds.show_all_portgroups [obj]
   when 'vds'
-    MODULES['vds'].show_all_vds [obj]
+    shell.cmds.vds.show_all_vds [obj]
   when 'interface'
-    MODULES['vds'].show_all_ports [obj]
+    shell.cmds.vds.show_all_ports [obj]
   #when 'vlan'
   else
     path = lookup_single arg0
@@ -340,9 +346,8 @@ end
 rvc_alias :disconnect
 
 def disconnect connection
-  k, = $shell.connections.find { |k,v| v == connection }
-  $shell.connections.delete k
-  $shell.session.set_connection k, nil
+  k, = shell.connections.find { |k,v| v == connection }
+  shell.connections.delete k
 end
 
 
@@ -423,11 +428,11 @@ shown by the "fields" command.
   opt :reverse, "Reverse sort order"
 end
 
-rvc_completor :table do |line, args, word, argnum|
-  if argnum > 0 and args[argnum-1] == '-f'
+rvc_completor :table do |word, args|
+  if index > 0 and args[-2] == '-f'
     RVC::Field::ALL_FIELD_NAMES.map { |x| [x, ' '] }
   else
-    RVC::Completion.fs_candidates word
+    shell.completion.fs_candidates word
   end
 end
 

data/lib/rvc/modules/cluster.rb

@@ -18,6 +18,9 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'rvc/vim'
+require "terminal-table"
+
 opts :create do
   summary "Create a cluster"
   arg :dest, nil, :lookup_parent => VIM::Folder
@@ -32,33 +35,39 @@ end
 opts :add_host do
   summary "Add a host to a cluster"
   arg :cluster, nil, :lookup => VIM::ClusterComputeResource
-  arg :hostname, nil
+  arg :hostnames, nil, :multi => true
   opt :username, "Username", :short => 'u', :default => 'root'
   opt :password, "Password", :short => 'p', :default => ''
+  opt :insecure, "Ignore SSL thumbprint", :short => 'k'
+  opt :force, "Force, e.g when host is already managed by other VC"
 end
 
-def add_host cluster, hostname, opts
+def add_host cluster, hostnames, opts
   sslThumbprint = nil
-  while true
-    spec = {
-      :force => false,
-      :hostName => hostname,
-      :userName => opts[:username],
-      :password => opts[:password],
-      :sslThumbprint => sslThumbprint,
-    }
-    task = cluster.AddHost_Task :spec => spec,
-                                :asConnected => true
-    begin
-      one_progress task
-      break
-    rescue VIM::SSLVerifyFault
-      puts "SSL thumbprint: #{$!.fault.thumbprint}"
-      $stdout.write "Accept this thumbprint? (y/n) "
-      $stdout.flush
-      answer = $stdin.readline.chomp
-      err "Aborted" unless answer == 'y' or answer == 'yes'
-      sslThumbprint = $!.fault.thumbprint
+  hostnames.each do |hostname|
+    while true
+      spec = {
+        :force => opts[:force],
+        :hostName => hostname,
+        :userName => opts[:username],
+        :password => opts[:password],
+        :sslThumbprint => sslThumbprint,
+      }
+      task = cluster.AddHost_Task :spec => spec,
+                                  :asConnected => true
+      begin
+        one_progress task
+        break
+      rescue VIM::SSLVerifyFault
+        unless opts[:insecure]
+          puts "SSL thumbprint: #{$!.fault.thumbprint}"
+          $stdout.write "Accept this thumbprint? (y/n) "
+          $stdout.flush
+          answer = $stdin.readline.chomp
+          err "Aborted" unless answer == 'y' or answer == 'yes'
+        end
+        sslThumbprint = $!.fault.thumbprint
+      end
     end
   end
 end
@@ -78,3 +87,89 @@ def configure_ha cluster, opts
   )
   one_progress(cluster.ReconfigureComputeResource_Task :spec => spec, :modify => true)
 end
+
+opts :recommendations do
+  summary "List recommendations"
+  arg :cluster, nil, :lookup => VIM::ClusterComputeResource
+end
+
+def recommendations cluster
+  # Collect everything we need from VC with as few calls as possible
+  pc = cluster._connection.serviceContent.propertyCollector
+  recommendation, hosts, datastores = cluster.collect 'recommendation', 'host', 'datastore'
+  if recommendation.length == 0
+    puts "None"
+    return
+  end
+  targets = recommendation.map { |x| x.target }
+  recommendation.each { |x| targets += x.action.map { |y| y.target } }
+  targets += hosts
+  targets += datastores
+  targets.compact!
+  name_map = pc.collectMultiple(targets, 'name')
+
+  # Compose the output (tries to avoid making any API calls)
+  out = Terminal::Table.new(['Key', 'Reason', 'Target', 'Actions']) do
+    recommendation.each do |r|
+      target_name = r.target ? name_map[r.target]['name'] : ""
+      actions = r.action.map do |a|
+        action = "#{a.class.wsdl_name}: #{name_map[a.target]['name']}"
+        dst = nil
+        if a.is_a?(RbVmomi::VIM::ClusterMigrationAction)
+          dst = a.drsMigration.destination
+        end
+        if a.is_a?(RbVmomi::VIM::StorageMigrationAction)
+          dst = a.destination
+        end
+        if dst
+          if !name_map[dst]
+            name_map[dst] = {'name' => dst.name}
+          end
+          action += " (to #{name_map[dst]['name']})"
+        end
+        action
+      end
+      add_row [r.key, r.reasonText, target_name, actions.join("\n")]
+    end
+  end
+  puts out
+end
+
+opts :apply_recommendations do
+  summary "Apply recommendations"
+  arg :cluster, nil, :lookup => VIM::ClusterComputeResource
+  opt :key, "Key of a recommendation to execute", :type => :string, :multi => true
+  opt :type, "Type of actions to perform", :type => :string, :multi => true
+end
+
+def apply_recommendations cluster, opts
+  pc = cluster._connection.serviceContent.propertyCollector
+  recommendation = cluster.recommendation
+  if opts[:key] && opts[:key].length > 0
+    recommendation.select! { |x| opts[:key].member?(x.key) }
+  end
+  if opts[:type] && opts[:type].length > 0
+    recommendation.select! { |x| (opts[:type] & x.action.map { |y| y.class.wsdl_name }).length > 0 }
+  end
+  all_tasks = []
+
+  # We do recommendations in chunks, because VC can't process more than a
+  # few migrations anyway and this way we get more fair queuing, less
+  # timeouts of long queued migrations and a better RVC user experience
+  # due to less queued tasks at a time. It would otherwise be easy to
+  # exceed the screensize with queued tasks
+  while recommendation.length > 0
+    recommendation.pop(20).each do |r|
+      targets = r.action.map { |y| y.target }
+      recent_tasks = pc.collectMultiple(targets, 'recentTask')
+      prev_tasks = targets.map { |x| recent_tasks[x]['recentTask'] }
+      cluster.ApplyRecommendation(:key => r.key)
+      recent_tasks = pc.collectMultiple(targets, 'recentTask')
+      tasks = targets.map { |x| recent_tasks[x]['recentTask'] }
+      all_tasks += (tasks.flatten - prev_tasks.flatten)
+    end
+
+    progress all_tasks
+  end
+end
+

data/lib/rvc/modules/connection.rb

@@ -0,0 +1,40 @@
+# 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.
+
+opts :switch do
+  summary "Switch to another connection"
+  arg :name, "Connection name"
+end
+
+def switch name
+  shell.switch_connection name
+end
+
+
+opts :list do
+  summary "List connections"
+end
+
+def list
+  shell.connections.each do |name, conn|
+    next if name.empty?
+    puts name
+  end
+end

data/lib/rvc/modules/core.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 :quit do
   summary "Exit RVC"
 end
@@ -42,22 +44,8 @@ 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
-
+  shell.reload_modules opts[:verbose]
+  RbVmomi::VIM.reload_extensions
 ensure
   $VERBOSE = old_verbose
 end