rvc 1.5.0 → 1.6.0

data/lib/rvc/modules/vnc.rb

@@ -18,7 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-VNC = ENV['VNC'] || search_path('vinagre') || search_path('tightvnc') || search_path('vncviewer')
+VNC = ENV['VNC'] || search_path('tightvnc') || search_path('vncviewer') || search_path('vinagre')
 
 opts :view do
   summary "Spawn a VNC client"
@@ -29,8 +29,8 @@ rvc_alias :view, :vnc
 rvc_alias :view, :V
 
 def view vm
-  ip = reachable_ip vm.runtime.host
-  extraConfig = vm.config.extraConfig
+  ip = reachable_ip vm.collect('runtime.host')[0]
+  extraConfig, = vm.collect('config.extraConfig')
   already_enabled = extraConfig.find { |x| x.key == 'RemoteDisplay.vnc.enabled' && x.value.downcase == 'true' }
   if already_enabled
     puts "VNC already enabled"
@@ -68,7 +68,7 @@ end
 
 
 def reachable_ip host
-  ips = host.config.network.vnic.map { |x| x.spec.ip.ipAddress } # TODO optimize
+  ips = host.collect('config.network.vnic')[0].map { |x| x.spec.ip.ipAddress }
   ips.find do |x|
     begin
       Timeout.timeout(1) { TCPSocket.new(x, 443).close; true }
@@ -95,17 +95,54 @@ def vnc_password
 end
 
 # Override this to spawn a VNC client differently
+# 
+# We can save the vnc pasword out to a file, then call vncviewer with it
+# directly so we don't need to "password" auth.
 def vnc_client ip, port, password
-  if VNC
-    fork do
-      $stderr.reopen("#{ENV['HOME']||'.'}/.rvc-vmrc.log", "w")
-      Process.setpgrp
-      exec VNC, "#{ip}:#{port}"
-    end
-    puts "spawning #{VNC}"
-    puts "#{ip}:#{port} password: #{password}"
-  else
+  unless VNC
     puts "no VNC client configured"
     puts "#{ip}:#{port} password: #{password}"
+    return false
+  end
+
+  if File.basename(VNC) == 'vncviewer' # or other vnc clients that support the same -passwd
+    tightvnc = %x(#{VNC} --version 2>&1).lines.first['TightVNC'] != nil
+    file = Tempfile.new('rvcvncpass')
+    filename = file.path
+    begin
+      if tightvnc
+        IO.popen("vncpasswd -f > #{filename}", 'w+') do |vncpass|
+          vncpass.puts password
+          vncpass.puts password
+        end
+      else
+        IO.popen("vncpasswd #{filename}", 'w+') do |vncpass|
+          vncpass.puts password
+          vncpass.puts password
+        end
+      end
+
+      vnc_client_connect ip, port, password, "-passwd #{filename}"
+    ensure
+      sleep 3 # we have to do this, as the vncviewer forks, and we've no simple way of working out if that thread has read the file yet.
+      file.close
+      file.unlink
+    end
+  else
+    vnc_client_connect ip, port, password
   end
 end
+
+def vnc_client_connect ip, port, password, vnc_opts=nil
+  fork do
+    $stdout.reopen("#{ENV['HOME']||'.'}/.rvc-vnc.log", "w")
+    $stderr.reopen("#{ENV['HOME']||'.'}/.rvc-vnc.err", "w")
+    Process.setpgrp
+    exec [ VNC, vnc_opts, "#{ip}:#{port}" ].join ' '
+  end
+  puts "spawning #{VNC}"
+  print "#{ip}:#{port} password: #{password}"
+  print " options: #{vnc_opts}" unless vnc_opts.nil?
+  puts
+end
+

data/lib/rvc/option_parser.rb

@@ -20,6 +20,13 @@
 
 require 'trollop'
 
+begin
+  require 'chronic'
+  RVC::HAVE_CHRONIC = true
+rescue LoadError
+  RVC::HAVE_CHRONIC = false
+end
+
 module RVC
 
 class OptionParser < Trollop::Parser
@@ -33,7 +40,10 @@ class OptionParser < Trollop::Parser
     @seen_not_required = false
     @seen_multi = false
     @applicable = Set.new
-    super &b
+    super() do
+      opt :help, "Show this message", :short => 'h'
+      instance_eval &b
+    end
   end
 
   def summary str
@@ -47,7 +57,9 @@ class OptionParser < Trollop::Parser
 
   def opt name, *a
     super
-    @applicable << @specs[name][:lookup] if @specs[name][:lookup]
+    spec = @specs[name]
+    @applicable << spec[:lookup] if spec[:lookup]
+    spec[:type] = :string if spec[:lookup] || spec[:lookup_parent]
     @has_options = true unless name == :help
   end
 
@@ -112,6 +124,16 @@ class OptionParser < Trollop::Parser
     return args, opts
   end
 
+  def parse_date_parameter param, arg
+    if RVC::HAVE_CHRONIC
+      Chronic.parse(param)
+    else
+      Time.parse param
+    end
+  rescue
+    raise ::Trollop::CommandlineError, "option '#{arg}' needs a time"
+  end
+
   def postprocess_arg x, spec
     if spec[:lookup]
       RVC::Util.lookup!(x, spec[:lookup]).
@@ -138,4 +160,30 @@ class OptionParser < Trollop::Parser
   end
 end
 
+class RawOptionParser
+  attr_reader :applicable
+
+  def initialize cmd, summary
+    @cmd = cmd
+    @summary = summary
+    @applicable = []
+  end
+
+  def summary?
+    @summary
+  end
+
+  def parse args
+    [args, {}]
+  end
+
+  def has_options?
+    false
+  end
+
+  def educate
+    # XXX
+  end
+end
+
 end

data/lib/rvc/readline-ffi.rb

@@ -22,7 +22,8 @@ require 'ffi'
 
 module RVC::ReadlineFFI
   extend FFI::Library
-  ffi_lib "readline.so"
+  libreadline = ENV['RVC_READLINE'] == nil ? 'readline.so' : ENV['RVC_READLINE']
+  ffi_lib libreadline
   callback :rl_linebuf_func_t, [ :string, :int ], :bool
   attach_variable :rl_char_is_quoted_p, :rl_char_is_quoted_p, :rl_linebuf_func_t
   attach_variable :rl_line_buffer, :rl_line_buffer, :string

data/lib/rvc/shell.rb

@@ -58,7 +58,7 @@ class Shell
       end
     rescue SystemExit, IOError
       raise
-    rescue RVC::Util::UserError, RuntimeError, RbVmomi::Fault
+    rescue RVC::Util::UserError, RuntimeError, RbVmomi::Fault, Trollop::CommandlineError
       if ruby or debug
         puts "#{$!.class}: #{$!.message}"
         puts $!.backtrace * "\n"
@@ -73,51 +73,52 @@ class Shell
     rescue Exception
       puts "#{$!.class}: #{$!.message}"
       puts $!.backtrace * "\n"
+    ensure
+      $stdout.flush
     end
   end
 
-  def eval_command input
+  def self.parse_input input
     cmd, *args = Shellwords.shellwords(input)
-    return unless cmd
-    RVC::Util.err "invalid command" unless cmd.is_a? String
-    case cmd
-    when RVC::FS::MARK_PATTERN
-      CMD.basic.cd RVC::Util.lookup_single(cmd)
-    else
-      if cmd.include? '.'
-        module_name, cmd, = cmd.split '.'
-      elsif ALIASES.member? cmd
-        module_name, cmd, = ALIASES[cmd].split '.'
-      else
-        RVC::Util.err "unknown alias #{cmd}"
-      end
-
-      m = MODULES[module_name] or RVC::Util.err("unknown module #{module_name}")
+    return nil unless cmd
+    if cmd.include? '.'
+      module_name, cmd, = cmd.split '.'
+    elsif ALIASES.member? cmd
+      module_name, cmd, = ALIASES[cmd].split '.'
+    end
+    [MODULES[module_name], cmd.to_sym, args]
+  end
 
-      opts_block = m.opts_for(cmd.to_sym)
-      parser = RVC::OptionParser.new cmd, &opts_block
+  def eval_command input
+    m, cmd, args = Shell.parse_input input
+    RVC::Util.err "invalid command" unless m != nil and
+                                           cmd.is_a? Symbol and
+                                           m.has_command? cmd
+    parser = m.opts_for(cmd)
 
-      begin
-        args, opts = parser.parse args
-      rescue Trollop::HelpNeeded
-        parser.educate
-        return
-      end
+    begin
+      args, opts = parser.parse args
+    rescue Trollop::HelpNeeded
+      parser.educate
+      return
+    end
 
-      if parser.has_options?
-        m.send cmd.to_sym, *(args + [opts])
-      else
-        m.send cmd.to_sym, *args
-      end
+    if parser.has_options?
+      m.send cmd.to_sym, *(args + [opts])
+    else
+      m.send cmd.to_sym, *args
     end
-    nil
   end
 
   def eval_ruby input, file="<input>"
     result = @ruby_evaluator.do_eval input, file
     if $interactive
       if input =~ /\#$/
-        introspect_object result
+        if result.is_a? Class
+          introspect_class result
+        else
+          introspect_object result
+        end
       else
         pp result
       end
@@ -205,7 +206,7 @@ class RubyEvaluator
     rescue Exception => e
       bt = e.backtrace
       bt = bt.reverse.drop_while { |x| !(x =~ /toplevel/) }.reverse
-      bt[-1].gsub! ':in `toplevel\'', ''
+      bt[-1].gsub! ':in `toplevel\'', '' if bt[-1]
       e.set_backtrace bt
       raise
     end

data/lib/rvc/util.rb

@@ -18,6 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'delegate'
+
 module RVC
 module Util
   extend self
@@ -104,6 +106,7 @@ module Util
   end
 
   def progress tasks
+    results = {}
     interested = %w(info.progress info.state info.entityName info.error info.name)
     connection = single_connection tasks
     connection.serviceInstance.wait_for_multiple_tasks interested, tasks do |h|
@@ -120,8 +123,10 @@ module Util
             $stdout.write "\e[K#{text}#{progress_bar}\n"
           elsif state == 'error'
             error = props['info.error']
+            results[task] = error
             $stdout.write "\e[K#{name} #{entityName}: #{error.fault.class.wsdl_name}: #{error.localizedMessage}\n"
           else
+            results[task] = task.info.result if state == 'success'
             $stdout.write "\e[K#{name} #{entityName}: #{state}\n"
           end
         end
@@ -130,7 +135,13 @@ module Util
       end
     end
     $stdout.write "\e[#{tasks.size}B" if interactive?
-    true
+    results
+  end
+
+  def one_progress task
+    progress([task])[task].tap do |r|
+      raise r if r.is_a? VIM::LocalizedMethodFault
+    end
   end
 
   def terminal_columns
@@ -160,7 +171,7 @@ module Util
       tcsetpgrp
       exec cmd
     end
-    Process.waitpid2 pid
+    Process.waitpid2 pid rescue nil
     tcsetpgrp
     nil
   end
@@ -194,5 +205,112 @@ module Util
 
     Hash[results.map { |r| [r['name'], r.obj] }]
   end
+
+  def status_color str, status
+    $terminal.color(str, *VIM::ManagedEntity::STATUS_COLORS[status])
+  end
+
+  def metric num
+    MetricNumber.new(num.to_f, '', false).to_s
+  end
+
+  def retrieve_fields objs, fields
+    Hash[objs.map do |o|
+      begin
+        [o, Hash[fields.map { |f| [f, o.field(f)] }]]
+      rescue VIM::ManagedObjectNotFound
+        next
+      end
+    end]
+  end
+end
+end
+
+class Numeric
+  def metric
+    RVC::Util.metric self
+  end
+end
+
+class TimeDiff < SimpleDelegator
+  def to_s
+    i = self.to_i
+    seconds = i % 60
+    i /= 60
+    minutes = i % 60
+    i /= 60
+    hours = i
+    [hours, minutes, seconds].join ':'
+  end
+
+  def self.parse str
+    a = str.split(':', 3).reverse
+    seconds = a[0].to_i rescue 0
+    minutes = a[1].to_i rescue 0
+    hours = a[2].to_i rescue 0
+    TimeDiff.new(hours * 3600 + minutes * 60 + seconds)
+  end
 end
+
+class MetricNumber < SimpleDelegator
+  attr_reader :unit, :binary
+
+  def initialize val, unit, binary=false
+    @unit = unit
+    @binary = binary
+    super val.to_f
+  end
+
+  def to_s
+    limit = @binary ? 1024 : 1000
+    if self < limit
+      prefix = ''
+      multiple = 1
+    else
+      prefixes = @binary ? BINARY_PREFIXES : DECIMAL_PREFIXES
+      prefixes = prefixes.sort_by { |k,v| v }
+      prefix, multiple = prefixes.find { |k,v| self/v < limit }
+      prefix, multiple = prefixes.last unless prefix
+    end
+    ("%0.2f %s%s" % [self/multiple, prefix, @unit]).strip
+  end
+
+  # http://physics.nist.gov/cuu/Units/prefixes.html
+  DECIMAL_PREFIXES = {
+    'k' => 10 ** 3,
+    'M' => 10 ** 6,
+    'G' => 10 ** 9,
+    'T' => 10 ** 12,
+    'P' => 10 ** 15,
+  }
+
+  # http://physics.nist.gov/cuu/Units/binary.html
+  BINARY_PREFIXES = {
+    'Ki' => 2 ** 10,
+    'Mi' => 2 ** 20,
+    'Gi' => 2 ** 30,
+    'Ti' => 2 ** 40,
+    'Pi' => 2 ** 50,
+  }
+
+  CANONICAL_PREFIXES = Hash[(DECIMAL_PREFIXES.keys + BINARY_PREFIXES.keys).map { |x| [x.downcase, x] }]
+
+  def self.parse str
+    if str =~ /^([0-9,.]+)\s*([kmgtp]i?)?/i
+      x = $1.delete(',').to_f
+      binary = false
+      if $2
+        prefix = $2.downcase
+        binary = prefix[1..1] == 'i'
+        prefixes = binary ? BINARY_PREFIXES : DECIMAL_PREFIXES
+        multiple = prefixes[CANONICAL_PREFIXES[prefix]]
+      else
+        multiple = 1
+      end
+      units = $'
+      new x*multiple, units, binary
+    else
+      raise "Problem parsing SI number #{str.inspect}"
+    end
+  end
 end

data/test/test_fs.rb

@@ -18,16 +18,20 @@ class FSTest < Test::Unit::TestCase
 
   def setup
     @context = RVC::FS.new Root
+    session = RVC::MemorySession.new
+    $shell = RVC::Shell.new session
+    $shell.instance_variable_set :@fs, @context
   end
 
   def teardown
     @context = nil
+    $shell = nil
   end
 
   def test_new
     assert_equal Root, @context.cur
     assert_equal "", @context.display_path
-    assert_equal 0, @context.marks.size
+    assert_equal 0, $shell.session.marks.size
     assert_equal [['', Root]], @context.cur.rvc_path
   end
 
@@ -93,20 +97,20 @@ class FSTest < Test::Unit::TestCase
     assert_equal nil, obj
 
     ['foo', '~', '7', ''].each do |mark|
-      @context.mark mark, [b_obj]
+      $shell.session.set_mark mark, [b_obj]
       obj = @context.lookup("~#{mark}")[0]
       assert_equal [['', Root], ['a', NodeA], ['b', NodeB]], obj.rvc_path
 
-      @context.mark mark, []
+      $shell.session.set_mark mark, []
       obj = @context.lookup("~#{mark}")[0]
       assert_equal nil, obj
     end
 
-    @context.mark '7', [b_obj]
+    $shell.session.set_mark '7', [b_obj]
     obj = @context.lookup("7")[0]
     assert_equal [['', Root], ['a', NodeA], ['b', NodeB]], obj.rvc_path
 
-    @context.mark '7', []
+    $shell.session.set_mark '7', []
     obj = @context.lookup("7")[0]
     assert_equal nil, obj
   end