rvc 1.6.0 → 1.7.0

data/lib/rvc/shell.rb

@@ -18,19 +18,35 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'rvc/namespace'
+require 'rvc/connection'
+require 'rvc/ruby_evaluator'
+require 'shellwords'
+
 module RVC
 
 class Shell
-  attr_reader :fs, :connections, :session
-  attr_accessor :debug
+  attr_reader :fs, :completion
+  attr_reader :connections, :connection
+  attr_accessor :debug, :cmds
 
-  def initialize session
-    @session = session
+  def initialize
     @persist_ruby = false
-    @fs = RVC::FS.new RVC::RootNode.new
-    @ruby_evaluator = RubyEvaluator.new @fs
-    @connections = {}
+    @fs = RVC::FS.new RVC::RootNode.new(self)
+    @ruby_evaluator = RVC::RubyEvaluator.new self
+    @completion = RVC::Completion.new self
+    @connection = NullConnection.new
+    @connections = { '' => @connection }
     @debug = false
+    @cmds = nil
+  end
+
+  def switch_connection name
+    @connection = @connections[name] || fail("no such connection")
+  end
+
+  def inspect
+    "#<RVC::Shell:#{object_id}>"
   end
 
   def eval_input input
@@ -79,34 +95,35 @@ class Shell
   end
 
   def self.parse_input input
-    cmd, *args = Shellwords.shellwords(input)
-    return nil unless cmd
-    if cmd.include? '.'
-      module_name, cmd, = cmd.split '.'
-    elsif ALIASES.member? cmd
-      module_name, cmd, = ALIASES[cmd].split '.'
+    begin
+      cmdpath, *args = Shellwords.shellwords(input)
+    rescue ArgumentError # unmatched double quote
+      cmdpath, *args = Shellwords.shellwords(input + '"')
     end
-    [MODULES[module_name], cmd.to_sym, args]
+    return nil unless cmdpath
+    cmdpath = cmdpath.split('.').map(&:to_sym)
+    [cmdpath, args]
   end
 
   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)
+    cmdpath, args = Shell.parse_input input
+
+    RVC::Util.err "invalid input" unless cmdpath
+
+    cmd = cmds.lookup cmdpath
+    RVC::Util.err "invalid command" unless cmd
 
     begin
-      args, opts = parser.parse args
+      args, opts = cmd.parser.parse args
     rescue Trollop::HelpNeeded
-      parser.educate
+      cmd.parser.educate
       return
     end
 
-    if parser.has_options?
-      m.send cmd.to_sym, *(args + [opts])
+    if cmd.parser.has_options?
+      cmd.invoke *(args + [opts])
     else
-      m.send cmd.to_sym, *args
+      cmd.invoke *args
     end
   end
 
@@ -154,7 +171,7 @@ class Shell
         introspect_class klasses.map(&:ancestors).inject(&:&)[0]
       end
     else
-      puts obj.class
+      introspect_class obj.class
     end
   end
 
@@ -179,68 +196,36 @@ class Shell
         puts " #{name}(#{params.map { |x| "#{x['name']} : #{q[x['wsdl_type'] || 'void']}#{x['is-array'] ? '[]' : ''}" } * ', '}) : #{q[desc['result']['wsdl_type'] || 'void']}"
       end
     else
-      puts klass
-    end
-  end
-
-  def delete_numeric_marks
-    @session.marks.grep(/^\d+$/).each { |x| @session.set_mark x, nil }
-  end
-end
-
-class RubyEvaluator
-  include RVC::Util
-
-  def initialize fs
-    @binding = toplevel
-    @fs = fs
-  end
-
-  def toplevel
-    binding
-  end
-
-  def do_eval input, file
-    begin
-      eval input, @binding, file
-    rescue Exception => e
-      bt = e.backtrace
-      bt = bt.reverse.drop_while { |x| !(x =~ /toplevel/) }.reverse
-      bt[-1].gsub! ':in `toplevel\'', '' if bt[-1]
-      e.set_backtrace bt
-      raise
+      puts "#{klass} < #{klass.superclass}"
+      puts
+      methods_by_class = klass.instance_methods.map { |x| klass.instance_method(x) }.group_by { |m| m.owner }
+      klass.ancestors.each do |ancestor|
+        break if ancestor == Object
+        if ancestor == klass
+          puts "Methods:"
+        else
+          puts "Methods from #{ancestor}:"
+        end
+        methods_by_class[ancestor].sort_by { |m| m.name }.each do |m|
+          if m.respond_to? :parameters
+            puts " #{m.name}(#{m.parameters.map { |mode,name| "#{name}#{mode==:opt ? '?' : ''}" } * ', '})"
+          else
+            puts " #{m.name}"
+          end
+        end
+      end
     end
   end
 
-  def this
-    @fs.cur
-  end
-
-  def dc
-    @fs.lookup("~").first
-  end
+  BULTIN_MODULE_PATH = [File.expand_path(File.join(File.dirname(__FILE__), 'modules')),
+                        File.join(ENV['HOME'], ".rvc")]
+  ENV_MODULE_PATH = (ENV['RVC_MODULE_PATH'] || '').split ':'
 
-  def conn
-    @fs.lookup("~@").first
-  end
-
-  def method_missing sym, *a
-    super unless $shell
-    str = sym.to_s
-    if a.empty?
-      if MODULES.member? str
-        MODULES[str]
-      elsif str =~ /_?([\w\d]+)(!?)/ && objs = $shell.session.get_mark($1)
-        if $2 == '!'
-          objs
-        else
-          objs.first
-        end
-      else
-        super
-      end
-    else
-      super
+  def reload_modules verbose=true
+    @cmds = RVC::Namespace.new 'root', self, nil
+    module_path = (BULTIN_MODULE_PATH+ENV_MODULE_PATH).select { |d| File.directory?(d) }
+    module_path.each do |dir|
+      @cmds.load_module_dir dir, verbose
     end
   end
 end

data/lib/rvc/uri_parser.rb

@@ -0,0 +1,59 @@
+# 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.
+require 'uri'
+
+module RVC
+
+class URIParser
+  # XXX comments
+  # TODO certdigest
+  URI_REGEX = %r{
+    ^
+    (?:
+     (\w+):// # scheme
+    )?
+    (?:
+      ([^@:]+) # username
+      (?::
+        ([^@]*) # password
+      )?
+      @
+    )?
+    ([^@:]+) # host
+    (?::(\d{1,5}))? # port
+    $
+  }x
+
+  # Loosely parse a URI. This is more forgiving than a standard URI parser.
+  def self.parse str
+    match = URI_REGEX.match str
+    Util.err "invalid URI" unless match
+
+    URI::Generic.build({}).tap do |uri|
+      uri.scheme = match[1] if match[1]
+      uri.user = match[2] if match[2]
+      uri.password = match[3] if match[3]
+      uri.host = match[4] if match[4]
+      uri.port = match[5].to_i if match[5]
+    end
+  end
+end
+
+end

data/lib/rvc/util.rb

@@ -24,34 +24,6 @@ module RVC
 module Util
   extend self
 
-  # XXX just use an optional argument for type
-  def lookup path
-    $shell.fs.lookup path
-  end
-
-  def lookup_single path
-    objs = lookup path
-    err "Not found: #{path.inspect}" if objs.empty?
-    err "More than one match for #{path.inspect}" if objs.size > 1
-    objs.first
-  end
-
-  def lookup! path, types
-    types = [types] unless types.is_a? Enumerable
-    lookup(path).tap do |objs|
-      objs.each do |obj|
-        err "Expected #{types*'/'} but got #{obj.class} at #{path.inspect}" unless types.any? { |type| obj.is_a? type }
-      end
-    end
-  end
-
-  def lookup_single! path, type
-    objs = lookup!(path, type)
-    err "Not found: #{path.inspect}" if objs.empty?
-    err "More than one match for #{path.inspect}" if objs.size > 1
-    objs.first
-  end
-
   def menu items
     items.each_with_index { |x, i| puts "#{i} #{x}" }
     input = Readline.readline("? ", false)
@@ -215,14 +187,129 @@ module Util
   end
 
   def retrieve_fields objs, fields
+    pc = nil
+    if objs.length == 0
+      return {}
+    end
+    conn = objs.first._connection
+    pc = conn.propertyCollector
+    perfmgr = conn.serviceContent.perfManager
+    objs_props = Hash[objs.map{|o| [o, o.field_properties(fields)]}]
+    buckets = {}
+    objs_props.each{|o,p| buckets[p] ||= []; buckets[p] << o}
+    props_values = {}
+    buckets.each do |props, o|
+      begin
+        props_values.merge!(pc.collectMultiple(o, *props))
+      rescue VIM::ManagedObjectNotFound => ex
+        o -= [ex.obj]
+        retry
+      end
+    end
+    
+    buckets = {}
+    objs.each do |o|
+      metrics = o.perfmetrics(fields)
+      if metrics.length > 0
+        buckets[metrics] ||= []
+        buckets[metrics] << o
+      end
+    end
+    perf_values = {}
+    buckets.each do |metrics, os|
+      # XXX: Would be great if we could collapse metrics into a single call
+      metrics.each do |metric|
+        begin
+          stats = perfmgr.retrieve_stats os, metric[:metrics], metric[:opts]
+          os.each do |o|
+            perf_values[o] = {}
+            metric[:metrics].map do |x| 
+              if stats[o] 
+                perf_values[o][x] = stats[o][:metrics][x]
+              end
+            end
+          end
+        rescue VIM::ManagedObjectNotFound => ex
+          o -= [ex.obj]
+          retry
+        end
+      end
+    end
+    
     Hash[objs.map do |o|
       begin
-        [o, Hash[fields.map { |f| [f, o.field(f)] }]]
+        [o, Hash[fields.map do |f| 
+          [f, o.field(f, props_values[o], perf_values[o])] 
+        end]]
       rescue VIM::ManagedObjectNotFound
         next
       end
     end]
   end
+
+  def http_clone main_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
+    return http
+  end
+
+  def http_download connection, http_path, local_path
+    http = http_clone connection.http
+
+    headers = { 'cookie' => connection.cookie }
+    http.request_get(http_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
+  end
+
+
+  def http_upload connection, local_path, http_path
+    err "local file does not exist" unless File.exists? local_path
+
+    http = http_clone connection.http
+
+    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' => connection.cookie,
+        'content-length' => io.stat.size.to_s,
+        'Content-Type' => 'application/octet-stream',
+      }
+
+      request = Net::HTTP::Put.new http_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
 end
 end
 
@@ -314,3 +401,21 @@ class MetricNumber < SimpleDelegator
     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
+end

data/lib/rvc/{extensions/PerfCounterInfo.rb → version.rb}

@@ -18,9 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-class RbVmomi::VIM::PerfCounterInfo
-  def name
-    "#{groupInfo.key}.#{nameInfo.key}.#{rollupType}"
-  end
+module RVC
+  VERSION = File.read(File.join(File.dirname(__FILE__), '..', '..', 'VERSION'))
 end