rvc 1.2.2 → 1.3.0

data/README.rdoc

@@ -81,6 +81,13 @@ When the working directory is a descendant of a Datacenter object, the mark "~"
 refers to the Datacenter. For example "~/datastore" is a convenient way to get
 the datastore folder of the current datacenter.
 
+=== Aggregate marks
+
+More than one object can be given to the "mark" command. The resulting mark can
+be used with any command that accepts multiple objects. The "mark.edit" command
+opens up an editor showing the objects referenced by the given mark and allows
+you to remove some or add more.
+
 === Ruby mode
 
 Beginning an input line with "/" causes RVC to treat it as Ruby code and eval
@@ -89,7 +96,9 @@ it. This gives you direct access to the underlying RbVmomi library. If the line
 
 Marks can be easily used in Ruby mode since there are magic variables with the
 same names. Since some marks, like numeric ones, aren't valid variable names,
-they also exist with a "_" prefix.
+they also exist with a "_" prefix. By default only the first object in an
+aggregate mark will be returned; to get an array of them all use the '!'
+suffix.
 
 The methods "this", "conn", and "dc" are provided in Ruby mode, returning the
 current object, connection, and datacenter respectively. The connection object

data/VERSION

@@ -1 +1 @@
-1.2.2
+1.3.0

data/bin/rvc

@@ -19,6 +19,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 require 'readline'
+require "highline/import"
 require 'pp'
 require 'trollop'
 require 'rbvmomi'
@@ -49,6 +50,7 @@ where [options] are:
 EOS
 
   opt :insecure, "don't verify ssl certificate", :short => 'k', :default => (ENV['RBVMOMI_INSECURE'] == '1')
+  opt :really_insecure, "don't use ~/.rvc/known_hosts", :short => 'K', :default => (ENV['RBVMOMI_REALLY_INSECURE'] == '1')
   opt :path, "Initial directory", :short => :none, :default => ENV['RVC_PATH'], :type => :string
   opt :create_directory, "Create the initial directory if it doesn't exist", :short => :none
   opt :cmd, "command to evaluate", :short => 'c', :multi => true, :type => :string
@@ -63,7 +65,7 @@ $shell = RVC::Shell.new
 ARGV.each do |uri|
   begin
     puts "Connecting to #{uri}..." if ARGV.size > 1
-    CMD.vim.connect uri, :insecure => $opts[:insecure]
+    CMD.vim.connect uri, :insecure => $opts[:insecure], :really_insecure => $opts[:really_insecure]
   rescue UserError
     puts "Failed to connect to #{uri}: #{$!.message}"
     exit 1
@@ -81,15 +83,15 @@ if $opts[:path]
   rescue UserError
     raise unless $opts[:create_directory]
     parent_path = File.dirname($opts[:path])
-    lookup(parent_path).CreateFolder(:name => File.basename($opts[:path]))
-    CMD.basic.cd $opts[:path]
+    lookup_single(parent_path).CreateFolder(:name => File.basename($opts[:path]))
+    CMD.basic.cd lookup_single($opts[:path])
   end
 elsif $shell.connections.size == 1
   conn_name, conn = $shell.connections.first
   if conn.serviceContent.about.apiType == 'VirtualCenter'
-    CMD.basic.cd conn_name
+    CMD.basic.cd lookup_single(conn_name)
   else
-    CMD.basic.cd "#{conn_name}/ha-datacenter/vm"
+    CMD.basic.cd lookup_single("#{conn_name}/ha-datacenter/vm")
   end
 end
 
@@ -97,7 +99,7 @@ unless CMD.vmrc.find_vmrc
   $stderr.puts "VMRC is not installed. You will be unable to view virtual machine consoles. Use the vmrc.install command to install it."
 end
 
-CMD.basic.ls '.'
+CMD.basic.ls lookup_single('.')
 
 while true
   begin

data/lib/rvc/completion.rb

@@ -87,18 +87,18 @@ module Completion
     ret.sort.select { |e| e.match(prefix_regex) }
   end
 
+  # TODO convert to globbing
   def self.child_candidates word
-    els, absolute, trailing_slash = Path.parse word
-    last = trailing_slash ? '' : (els.pop || '')
-    els.map! { |x| x.gsub '\\', '' }
-    base_loc = absolute ? Location.new($shell.fs.root) : $shell.fs.loc
-    found_loc = $shell.fs.traverse(base_loc, els).first or return []
-    cur = found_loc.obj
-    els.unshift '' if absolute
+    arcs, absolute, trailing_slash = Path.parse word
+    last = trailing_slash ? '' : (arcs.pop || '')
+    arcs.map! { |x| x.gsub '\\', '' }
+    base = absolute ? $shell.fs.root : $shell.fs.cur
+    cur = $shell.fs.traverse(base, arcs).first or return []
+    arcs.unshift '' if absolute
     children = Cache[cur, :children] rescue []
     children.
       select { |k,v| k.gsub(' ', '\\ ') =~ /^#{Regexp.escape(last)}/ }.
-      map { |k,v| (els+[k])*'/' }.
+      map { |k,v| (arcs+[k])*'/' }.
       map { |x| x.gsub ' ', '\\ ' }
   end
 

data/lib/rvc/fs.rb

@@ -20,125 +20,89 @@
 
 module RVC
 
-class Location
-  attr_reader :stack
-
-  def initialize root
-    @stack = [['', root]]
-  end
-
-  def initialize_copy src
-    super
-    @stack = @stack.dup
-  end
-
-  def push name, obj
-    @stack << [name, obj]
-  end
-
-  def pop
-    @stack.pop
-  end
-
-  def obj
-    @stack.empty? ? nil : @stack[-1][1]
-  end
-
-  def path
-    @stack.map { |name,obj| name }
-  end
-end
-
 class FS
-  attr_reader :root, :loc, :marks
+  attr_reader :root, :cur, :marks
 
   MARK_PATTERN = /^~(?:([\d\w]*|~|@))$/
   REGEX_PATTERN = /^%/
   GLOB_PATTERN = /\*/
 
   def initialize root
+    fail unless root.is_a? RVC::InventoryObject
     @root = root
-    @loc = Location.new root
+    @cur = root
     @marks = {}
   end
 
-  def cur
-    @loc.obj
-  end
-
   def display_path
-    @loc.path * '/'
+    @cur.rvc_path.map { |arc,obj| arc } * '/'
   end
 
-  def cd new_loc
-    mark '~', @loc
-    @loc = new_loc
+  def cd dst
+    fail unless dst.is_a? RVC::InventoryObject
+    mark '~', [@cur]
+    @cur = dst
   end
 
   def lookup path
-    lookup_loc(path).map(&:obj)
+    arcs, absolute, trailing_slash = Path.parse path
+    base = absolute ? @root : @cur
+    traverse(base, arcs)
   end
 
-  def lookup_loc path
-    els, absolute, trailing_slash = Path.parse path
-    base_loc = absolute ? Location.new(@root) : @loc
-    traverse(base_loc, els)
+  # Starting from base, traverse each path element in arcs. Since the path
+  # may contain wildcards, this function returns a list of matches.
+  def traverse base, arcs
+    objs = [base]
+    arcs.each_with_index do |arc,i|
+      objs.map! { |obj| traverse_one obj, arc, i==0 }
+      objs.flatten!
+    end
+    objs
   end
 
-  def traverse_one loc, el, first
-    case el
+  def traverse_one cur, arc, first
+    case arc
     when '.'
-      [loc]
+      [cur]
     when '..'
-      loc.pop unless loc.obj == @root
-      [loc]
+      [cur.rvc_parent ? cur.rvc_parent : cur]
     when '...'
-      loc.push(el, loc.obj.parent) unless loc.obj == @root
-      [loc]
+      # XXX shouldnt be nil
+      [(cur.respond_to?(:parent) && cur.parent) ? cur.parent : (cur.rvc_parent || cur)]
     when MARK_PATTERN
-      return unless first
-      loc = @marks[$1] or return []
-      [loc.dup]
+      if first and objs = @marks[$1]
+        objs
+      else
+        []
+      end
     when REGEX_PATTERN
       regex = Regexp.new($')
-      loc.obj.children.
-        select { |k,v| k =~ regex }.
-        map { |k,v| loc.dup.tap { |x| x.push(k, v) } }
+      cur.children.select { |k,v| k =~ regex }.map { |k,v| v.rvc_link(cur, k); v }
     when GLOB_PATTERN
-      regex = glob_to_regex el
-      loc.obj.children.
-        select { |k,v| k =~ regex }.
-        map { |k,v| loc.dup.tap { |x| x.push(k, v) } }
+      regex = glob_to_regex arc
+      cur.children.select { |k,v| k =~ regex }.map { |k,v| v.rvc_link(cur, k); v }
     else
       # XXX check for ambiguous child
-      if first and el =~ /^\d+$/ and @marks.member? el
-        loc = @marks[el].dup
+      if first and arc =~ /^\d+$/ and objs = @marks[arc]
+        objs
       else
-        x = loc.obj.traverse_one(el) or return []
-        loc.push el, x
+        if child = cur.traverse_one(arc)
+          child.rvc_link cur, arc
+          [child]
+        else
+          []
+        end
       end
-      [loc]
     end
   end
 
-  # Starting from base_loc, traverse each path element in els. Since the path
-  # may contain wildcards, this function returns a list of matches.
-  def traverse base_loc, els
-    locs = [base_loc.dup]
-    els.each_with_index do |el,i|
-      locs.map! { |loc| traverse_one loc, el, i==0 }
-      locs.flatten!
-    end
-    locs
+  def mark key, objs
+    fail "not an array" unless objs.is_a? Array
+    @marks[key] = objs
   end
 
-  def mark key, loc
-    if loc == nil
-      @marks.delete key
-    else
-      @marks[key] = loc
-    end
-  end
+private
 
   def glob_to_regex str
     Regexp.new "^#{Regexp.escape(str.gsub('*', "\0")).gsub("\0", ".*")}$"

data/lib/rvc/inventory.rb

@@ -35,6 +35,8 @@ module InventoryObject
     m.extend ClassMethods
   end
 
+  attr_reader :rvc_parent, :rvc_arc
+
   def display_info
     puts "class: #{self.class.name}"
   end
@@ -51,8 +53,25 @@ module InventoryObject
     {}
   end
 
-  def parent
-    nil
+  def rvc_path
+    [].tap do |a|
+      cur = self
+      while cur != nil
+        a << [cur.rvc_arc, cur]
+        cur = cur.rvc_parent
+      end
+      a.reverse!
+    end
+  end
+
+  def rvc_path_str
+    rvc_path.map { |k,v| k } * '/'
+  end
+
+  def rvc_link parent, arc
+    return if @rvc_parent
+    @rvc_parent = parent
+    @rvc_arc = arc
   end
 end
 
@@ -72,10 +91,6 @@ class FakeFolder
     true
   end
 
-  def parent
-    @target
-  end
-
   def eql? x
     @target == x.instance_variable_get(:@target) &&
       @method == x.instance_variable_get(:@method)
@@ -93,10 +108,6 @@ class RootNode
     $shell.connections
   end
 
-  def parent
-    nil
-  end
-
   def self.folder?
     true
   end
@@ -115,10 +126,6 @@ class RbVmomi::VIM
     rootFolder.children
   end
 
-  def parent
-    $shell.fs.root
-  end
-
   def self.folder?
     true
   end

data/lib/rvc/known_hosts.rb

@@ -0,0 +1,46 @@
+require 'digest/sha2'
+require 'fileutils'
+
+module RVC
+
+class KnownHosts
+  def filename
+    File.join(ENV['HOME'], ".rvc", "known_hosts");
+  end
+
+  def hash_host protocol, hostname
+    Digest::SHA2.hexdigest([protocol, hostname] * "\0")
+  end
+
+  def hash_public_key public_key
+    Digest::SHA2.hexdigest(public_key)
+  end
+
+  def verify protocol, hostname, public_key
+    expected_hashed_host = hash_host protocol, hostname
+    expected_hashed_public_key = hash_public_key public_key
+    if File.exists? filename
+      fail "bad permissions on known_hosts, expected 0600" unless File.stat(filename).mode & 0666 == 0600
+      File.readlines(filename).each_with_index do |l,i|
+        hashed_host, hashed_public_key = l.split
+        next unless hashed_host == expected_hashed_host
+        if hashed_public_key == expected_hashed_public_key
+          return :ok
+        else
+          return :mismatch, i
+        end
+      end
+    end
+    return :not_found, expected_hashed_public_key
+  end
+
+  def add protocol, hostname, public_key
+    FileUtils.mkdir_p File.dirname(filename)
+    File.open(filename, 'a') do |io|
+      io.chmod 0600
+      io.write "#{hash_host protocol, hostname} #{hash_public_key public_key}\n"
+    end
+  end
+end
+
+end

data/lib/rvc/modules/basic.rb

@@ -113,48 +113,41 @@ end
 
 opts :cd do
   summary "Change directory"
-  arg :path, "Directory to change to"
+  arg :obj, "Directory to change to", :lookup => Object
 end
 
 rvc_alias :cd
 
-def cd path
-  # XXX check for multiple matches
-  new_loc = $shell.fs.lookup_loc(path).first or err "Not found: #{path.inspect}"
-  $shell.fs.cd(new_loc)
-  $shell.fs.mark '', find_ancestor_loc(RbVmomi::VIM::Datacenter)
-  $shell.fs.mark '@', find_ancestor_loc(RbVmomi::VIM)
+def cd obj
+  $shell.fs.cd(obj)
+  $shell.fs.mark '', [find_ancestor(RbVmomi::VIM::Datacenter)].compact
+  $shell.fs.mark '@', [find_ancestor(RbVmomi::VIM)].compact
   $shell.fs.marks.delete_if { |k,v| k =~ /^\d+$/ }
 end
 
-def find_ancestor_loc klass
-  dc_loc = $shell.fs.loc.dup
-  dc_loc.pop while dc_loc.obj and not dc_loc.obj.is_a? klass
-  dc_loc.obj ? dc_loc : nil
+def find_ancestor klass
+  $shell.fs.cur.rvc_path.map { |k,v| v }.reverse.find { |x| x.is_a? klass }
 end
 
 
 opts :ls do
   summary "List objects in a directory"
-  arg :path, "Directory to list", :required => false, :default => '.'
+  arg :obj, "Directory to list", :required => false, :default => '.', :lookup => Object
 end
 
 rvc_alias :ls
 rvc_alias :ls, :l
 
-def ls path
-  # XXX check for multiple matches
-  loc = $shell.fs.lookup_loc(path).first or err "Not found: #{path.inspect}"
-  obj = loc.obj
+def ls obj
   children = obj.children
   name_map = children.invert
   children, fake_children = children.partition { |k,v| v.is_a? VIM::ManagedEntity }
   i = 0
 
-  fake_children.each do |name,obj|
-    puts "#{i} #{name}#{obj.ls_text(nil)}"
-    mark_loc = loc.dup.tap { |x| x.push name, obj }
-    $shell.fs.mark i.to_s, mark_loc
+  fake_children.each do |name,child|
+    puts "#{i} #{name}#{child.ls_text(nil)}"
+    child.rvc_link obj, name
+    $shell.fs.mark i.to_s, [child]
     i += 1
   end
 
@@ -163,9 +156,9 @@ def ls path
   filterSpec = VIM.PropertyFilterSpec(:objectSet => [], :propSet => [])
   filteredTypes = Set.new
 
-  children.each do |name,obj|
-    filterSpec.objectSet << { :obj => obj }
-    filteredTypes << obj.class
+  children.each do |name,child|
+    filterSpec.objectSet << { :obj => child }
+    filteredTypes << child.class
   end
 
   filteredTypes.each do |x|
@@ -183,8 +176,8 @@ def ls path
     text = r.obj.ls_text(r) rescue " (error)"
     realname = r['name'] if name != r['name']
     puts "#{i} #{name}#{realname && " [#{realname}]"}#{text}"
-    mark_loc = loc.dup.tap { |x| x.push name, r.obj }
-    $shell.fs.mark i.to_s, mark_loc
+    r.obj.rvc_link obj, name
+    $shell.fs.mark i.to_s, [r.obj]
     i += 1
   end
 end
@@ -199,6 +192,7 @@ rvc_alias :info
 rvc_alias :info, :i
 
 def info obj
+  puts "path: #{obj.rvc_path_str}"
   if obj.respond_to? :display_info
     obj.display_info
   else
@@ -219,20 +213,30 @@ def destroy objs
 end
 
 
-opts :mark do
-  summary "Save a path for later use"
-  arg :key, "Name for this mark"
-  arg :path, "Any object", :required => false, :default => '.'
+opts :reload_entity do
+  summary "Synchronize management server state"
+  arg :obj, nil, :lookup => VIM::ManagedEntity, :multi => true
+end
+
+rvc_alias :reload_entity
+
+def reload_entity objs
+  objs.each(&:Reload)
 end
 
-rvc_alias :mark
-rvc_alias :mark, :m
 
-def mark key, path
-  err "invalid mark name" unless key =~ /^\w+$/
-  # XXX aggregate marks
-  obj = $shell.fs.lookup_loc(path).first or err "Not found: #{path.inspect}" 
-  $shell.fs.mark key, obj
+opts :show do
+  summary "Basic information about the given objects"
+  arg :obj, nil, :multi => true, :required => false, :lookup => Object
+end
+
+rvc_alias :show
+rvc_alias :show, :w
+
+def show objs
+  objs.each do |obj|
+    puts "#{obj.rvc_path_str}: #{obj.class}"
+  end
 end
 
 

data/lib/rvc/modules/datastore.rb

@@ -30,6 +30,7 @@ def download datastore_path, local_path
   file.datastore.download file.path, local_path
 end
 
+
 opts :upload do
   summary "Upload a file to a datastore"
   arg 'local-path', "Filename on the local machine"
@@ -45,6 +46,7 @@ def upload local_path, datastore_path
   dir.datastore.upload real_datastore_path, local_path
 end
 
+
 opts :mkdir do
   summary "Create a directory on a datastore"
   arg 'path', "Directory to create on the datastore"
@@ -61,3 +63,27 @@ def mkdir datastore_path
                                                           :datacenter => dc,
                                                           :createParentDirectories => false
 end
+
+
+opts :edit do
+  summary "Edit a file"
+  arg "file", nil, :lookup => VIM::Datastore::FakeDatastoreFile
+end
+
+rvc_alias :edit, :vi
+
+def edit file
+  editor = ENV['VISUAL'] || ENV['EDITOR'] || 'vi'
+  filename = File.join(Dir.tmpdir, "rvc.#{Time.now.to_i}.#{rand(65536)}")
+  file.datastore.download(file.path, filename) rescue err("download failed")
+  begin
+    pre_stat = File.stat filename
+    system("#{editor} #{filename}")
+    post_stat = File.stat filename
+    if pre_stat != post_stat
+      file.datastore.upload(file.path, filename) rescue err("upload failed")
+    end
+  ensure
+    File.unlink filename
+  end
+end

data/lib/rvc/modules/mark.rb

@@ -0,0 +1,56 @@
+# 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.
+
+opts :mark do
+  summary "Save an object for later use"
+  arg :key, "Name for this mark"
+  arg :obj, "Any objects", :required => false, :default => ['.'], :multi => true, :lookup => Object
+end
+
+rvc_alias :mark
+rvc_alias :mark, :m
+
+def mark key, objs
+  err "invalid mark name" unless key =~ /^\w+$/
+  $shell.fs.mark key, objs
+end
+
+
+opts :edit do
+  summary "Edit objects referenced by a mark"
+  arg :key, "Name of mark"
+end
+
+rvc_alias :edit, :me
+
+def edit key
+  editor = ENV['VISUAL'] || ENV['EDITOR'] || 'vi'
+  objs = $shell.fs.marks[key] or err "no such mark #{key.inspect}"
+  filename = File.join(Dir.tmpdir, "rvc.#{Time.now.to_i}.#{rand(65536)}")
+  File.open(filename, 'w') { |io| objs.each { |obj| io.puts(obj.rvc_path_str) } }
+  begin
+    system("#{editor} #{filename}")
+    new_paths = File.readlines(filename).map(&:chomp) rescue return
+    new_objs = new_paths.map { |path| lookup(path) }.inject([], &:+)
+    mark key, new_objs
+  ensure
+    File.unlink filename
+  end
+end

data/lib/rvc/modules/vim.rb

@@ -18,6 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'rvc/known_hosts'
+
 URI_REGEX = %r{
   ^
   (?:
@@ -63,13 +65,34 @@ def connect uri, opts
                               :insecure => insecure
       break
     rescue OpenSSL::SSL::SSLError
-      err "Connection failed" unless prompt_insecure
+      err "Connection failed" unless prompt_cert_insecure
       insecure = true
     rescue Errno::EHOSTUNREACH, SocketError
       err $!.message
     end
   end
 
+  if opts[:really_insecure]
+    result = :ok
+  else
+    peer_public_key = vim.http.peer_cert.public_key
+    known_hosts = RVC::KnownHosts.new
+    result, arg = known_hosts.verify 'vim', host, peer_public_key.to_s
+  end
+
+  if result == :not_found
+    puts "The authenticity of host '#{host}' can't be established."
+    puts "Public key fingerprint is #{arg}."
+    err "Connection failed" unless prompt_cert_unknown
+    puts "Warning: Permanently added '#{host}' (vim) to the list of known hosts"
+    known_hosts.add 'vim', host, peer_public_key.to_s
+  elsif result == :mismatch
+    err "Public key fingerprint for host '#{host}' does not match #{known_hosts.filename}:#{arg}."
+  elsif result == :ok
+  else
+    err "Unexpected result from known_hosts check"
+  end
+
   unless opts[:rev]
     # negotiate API version
     rev = vim.serviceContent.about.apiVersion
@@ -114,19 +137,13 @@ def connect uri, opts
 end
 
 def prompt_password
-  system "stty -echo"
-  $stdout.write "password: "
-  $stdout.flush
-  begin
-    ($stdin.gets||exit(1)).chomp
-  ensure
-    system "stty echo"
-    puts
-  end
+  ask("password: ") { |q| q.echo = false }
 end
 
-def prompt_insecure
-  answer = Readline.readline "SSL certificate verification failed. Connect anyway? (y/n) "
-  answer == 'yes' or answer == 'y'
+def prompt_cert_insecure
+  agree("SSL certificate verification failed. Connect anyway (y/n)? ", true)
 end
 
+def prompt_cert_unknown
+  agree("Are you sure you want to continue connecting (y/n)? ", true)
+end

data/lib/rvc/option_parser.rb

@@ -111,9 +111,12 @@ class OptionParser < Trollop::Parser
 
   def postprocess_arg x, spec
     if spec[:lookup]
-      lookup! x, spec[:lookup]
+      lookup!(x, spec[:lookup]).
+        tap { |a| err "no matches for #{x.inspect}" if a.empty? }
     elsif spec[:lookup_parent]
-      lookup!(File.dirname(x), spec[:lookup_parent]).map { |y| [y, File.basename(x)] }
+      lookup!(File.dirname(x), spec[:lookup_parent]).
+        map { |y| [y, File.basename(x)] }.
+        tap { |a| err "no matches for #{File.dirname(x).inspect}" if a.empty? }
     else
       [x]
     end

data/lib/rvc/shell.rb

@@ -81,7 +81,7 @@ class Shell
     err "invalid command" unless cmd.is_a? String
     case cmd
     when RVC::FS::MARK_PATTERN
-      CMD.basic.cd cmd
+      CMD.basic.cd lookup_single(cmd)
     else
       if cmd.include? '.'
         module_name, cmd, = cmd.split '.'
@@ -123,7 +123,7 @@ class Shell
   end
 
   def prompt
-    "#{@fs.display_path}#{@persist_ruby ? '~' : '>'} "
+    "#{@fs.display_path}#{$terminal.color(@persist_ruby ? '~' : '>', :yellow)} "
   end
 
   def introspect_object obj
@@ -204,10 +204,12 @@ class RubyEvaluator
     if a.empty?
       if MODULES.member? str
         MODULES[str]
-      elsif @fs.marks.member?(str)
-        @fs.marks[str].obj
-      elsif str[0..0] == '_' && @fs.marks.member?(str[1..-1])
-        @fs.marks[str[1..-1]].obj
+      elsif str =~ /_?([\w\d]+)(!?)/ && objs = @fs.marks[$1]
+        if $2 == '!'
+          objs
+        else
+          objs.first
+        end
       else
         super
       end

data/lib/rvc/util.rb

@@ -93,6 +93,16 @@ module Util
     progress(objs.map { |obj| obj._call :"#{sym}_Task", args })
   end
 
+  if ENV['LANG'] =~ /UTF/ and RUBY_VERSION >= '1.9.1'
+    PROGRESS_BAR_LEFT = "\u2772"
+    PROGRESS_BAR_MIDDLE = "\u25AC"
+    PROGRESS_BAR_RIGHT = "\u2773"
+  else
+    PROGRESS_BAR_LEFT = "["
+    PROGRESS_BAR_MIDDLE = "="
+    PROGRESS_BAR_RIGHT = "]"
+  end
+
   def progress tasks
     interested = %w(info.progress info.state info.entityName info.error info.name)
     connection = single_connection tasks
@@ -106,7 +116,7 @@ module Util
             progress = props['info.progress']
             barlen = terminal_columns - text.size - 2
             progresslen = ((progress||0)*barlen)/100
-            progress_bar = "[#{'=' * progresslen}#{' ' * (barlen-progresslen)}]"
+            progress_bar = "#{PROGRESS_BAR_LEFT}#{PROGRESS_BAR_MIDDLE * progresslen}#{' ' * (barlen-progresslen)}#{PROGRESS_BAR_RIGHT}"
             $stdout.write "\e[K#{text}#{progress_bar}\n"
           elsif state == 'error'
             error = props['info.error']

data/test/test_fs.rb

@@ -14,6 +14,8 @@ class FSTest < Test::Unit::TestCase
   NodeA = FixtureNode.new('A', 'b' => NodeB, 'c' => NodeC)
   Root = FixtureNode.new('ROOT', 'a' => NodeA, 'd' => NodeD)
 
+  Root.rvc_link nil, ''
+
   def setup
     @context = RVC::FS.new Root
   end
@@ -26,8 +28,7 @@ class FSTest < Test::Unit::TestCase
     assert_equal Root, @context.cur
     assert_equal "", @context.display_path
     assert_equal 0, @context.marks.size
-    assert_equal [''], @context.loc.path
-    assert_equal [['', Root]], @context.loc.stack
+    assert_equal [['', Root]], @context.cur.rvc_path
   end
 
   def test_lookup_simple
@@ -41,79 +42,79 @@ class FSTest < Test::Unit::TestCase
     assert_equal [NodeC], @context.lookup('a/b/.../c')
   end
 
-  def test_lookup_loc_nonexistent
-    loc = @context.lookup_loc 'nonexistent'
-    assert_equal [], loc
+  def test_lookup_nonexistent
+    objs = @context.lookup 'nonexistent'
+    assert_equal [], objs
   end
 
-  def test_lookup_loc_simple
+  def test_lookup_simple_path
     %w(a /a ./a ./a/.).each do |path|
-      loc = @context.lookup_loc(path)[0]
-      assert_equal NodeA, loc.obj
-      assert_equal ['', 'a'], loc.path
-      assert_equal [['', Root], ['a', NodeA]], loc.stack
+      obj = @context.lookup(path)[0]
+      assert_equal NodeA, obj
+      assert_equal [['', Root], ['a', NodeA]], obj.rvc_path
     end
 
     %w(a/b /a/b ./a/b /a/b/.).each do |path|
-      loc = @context.lookup_loc(path)[0]
-      assert_equal NodeB, loc.obj
-      assert_equal ['', 'a', 'b'], loc.path
-      assert_equal [['', Root], ['a', NodeA], ['b', NodeB]], loc.stack
+      obj = @context.lookup(path)[0]
+      assert_equal NodeB, obj
+      assert_equal [['', Root], ['a', NodeA], ['b', NodeB]], obj.rvc_path
     end
   end
 
-  def test_lookup_loc_parent
-    loc = @context.lookup_loc('..')[0]
-    assert_equal [['', Root]], loc.stack
+  def test_lookup_parent
+    obj = @context.lookup('..')[0]
+    assert_equal [['', Root]], obj.rvc_path
 
-    loc = @context.lookup_loc('a/..')[0]
-    assert_equal [['', Root]], loc.stack
+    obj = @context.lookup('a/..')[0]
+    assert_equal [['', Root]], obj.rvc_path
 
-    loc = @context.lookup_loc('a/b/..')[0]
-    assert_equal [['', Root], ['a', NodeA]], loc.stack
+    obj = @context.lookup('a/b/..')[0]
+    assert_equal [['', Root], ['a', NodeA]], obj.rvc_path
   end
 
+=begin
   def test_lookup_loc_realparent
-    loc = @context.lookup_loc('...')[0]
-    assert_equal [['', Root]], loc.stack
+    obj = @context.lookup('...')[0]
+    assert_equal [['', Root]], obj.rvc_path
 
-    loc = @context.lookup_loc('a/...')[0]
-    assert_equal [['', Root], ['a', NodeA], ['...', Root]], loc.stack
+    obj = @context.lookup('a/...')[0]
+    assert_equal [['', Root], ['a', NodeA], ['...', Root]], obj.rvc_path
 
-    loc = @context.lookup_loc('a/b/...')[0]
-    assert_equal [['', Root], ['a', NodeA], ['b', NodeB], ['...', NodeA]], loc.stack
+    obj = @context.lookup('a/b/...')[0]
+    assert_equal [['', Root], ['a', NodeA], ['b', NodeB], ['...', NodeA]], obj.rvc_path
   end
+=end
 
-  def test_lookup_loc_mark
-    b_loc = @context.lookup_loc('a/b')[0]
-    assert_not_nil b_loc
+  def test_lookup_mark
+    b_obj = @context.lookup('a/b')[0]
+    assert_not_nil b_obj
 
-    loc = @context.lookup_loc('~foo')[0]
-    assert_equal nil, loc
+    obj = @context.lookup('~foo')[0]
+    assert_equal nil, obj
 
     ['foo', '~', '7', ''].each do |mark|
-      @context.mark mark, b_loc
-      loc = @context.lookup_loc("~#{mark}")[0]
-      assert_equal [['', Root], ['a', NodeA], ['b', NodeB]], loc.stack
+      @context.mark mark, [b_obj]
+      obj = @context.lookup("~#{mark}")[0]
+      assert_equal [['', Root], ['a', NodeA], ['b', NodeB]], obj.rvc_path
 
-      @context.mark mark, nil
-      loc = @context.lookup_loc("~#{mark}")[0]
-      assert_equal nil, loc
+      @context.mark mark, []
+      obj = @context.lookup("~#{mark}")[0]
+      assert_equal nil, obj
     end
 
-    @context.mark '7', b_loc
-    loc = @context.lookup_loc("7")[0]
-    assert_equal [['', Root], ['a', NodeA], ['b', NodeB]], loc.stack
+    @context.mark '7', [b_obj]
+    obj = @context.lookup("7")[0]
+    assert_equal [['', Root], ['a', NodeA], ['b', NodeB]], obj.rvc_path
 
-    @context.mark '7', nil
-    loc = @context.lookup_loc("7")[0]
-    assert_equal nil, loc
+    @context.mark '7', []
+    obj = @context.lookup("7")[0]
+    assert_equal nil, obj
   end
 
   def test_cd
-    assert_equal [['', Root]], @context.loc.stack
-    @context.cd(@context.lookup_loc("a")[0])
-    assert_equal [['', Root], ['a', NodeA]], @context.loc.stack
+    assert_equal [['', Root]], @context.cur.rvc_path
+    @context.cd(@context.lookup("a")[0])
+    assert_equal [['', Root], ['a', NodeA]], @context.cur.rvc_path
   end
 
   def test_regex
@@ -121,12 +122,12 @@ class FSTest < Test::Unit::TestCase
     dab = [['', Root], ['d', NodeD], ['dab', NodeDab]]
     dabc = [['', Root], ['d', NodeD], ['dabc', NodeDabc]]
     dac = [['', Root], ['d', NodeD], ['dac', NodeDac]]
-    locs = @context.lookup_loc '/d/%^daa'
-    assert_equal [daa], locs.map(&:stack)
-    locs = @context.lookup_loc '/d/%^daa.*'
-    assert_equal [daa], locs.map(&:stack)
-    locs = @context.lookup_loc '/d/%^da.*c'
-    assert_equal [dabc, dac], locs.map(&:stack)
+    objs = @context.lookup '/d/%^daa'
+    assert_equal [daa], objs.map(&:rvc_path)
+    objs = @context.lookup '/d/%^daa.*'
+    assert_equal [daa], objs.map(&:rvc_path)
+    objs = @context.lookup '/d/%^da.*c'
+    assert_equal [dabc, dac], objs.map(&:rvc_path)
   end
 
   def test_glob
@@ -134,11 +135,11 @@ class FSTest < Test::Unit::TestCase
     dab = [['', Root], ['d', NodeD], ['dab', NodeDab]]
     dabc = [['', Root], ['d', NodeD], ['dabc', NodeDabc]]
     dac = [['', Root], ['d', NodeD], ['dac', NodeDac]]
-    locs = @context.lookup_loc '/d/*daa*'
-    assert_equal [daa], locs.map(&:stack)
-    locs = @context.lookup_loc '/d/d*a'
-    assert_equal [daa], locs.map(&:stack)
-    locs = @context.lookup_loc '/d/da*c'
-    assert_equal [dabc, dac], locs.map(&:stack)
+    objs = @context.lookup '/d/*daa*'
+    assert_equal [daa], objs.map(&:rvc_path)
+    objs = @context.lookup '/d/d*a'
+    assert_equal [daa], objs.map(&:rvc_path)
+    objs = @context.lookup '/d/da*c'
+    assert_equal [dabc, dac], objs.map(&:rvc_path)
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: rvc
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors: 
 - Rich Lane
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-14 00:00:00 -07:00
+date: 2011-04-19 00:00:00 -07:00
 default_executable: rvc
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -79,12 +79,14 @@ files:
 - lib/rvc/extensions/VirtualMachine.rb
 - lib/rvc/fs.rb
 - lib/rvc/inventory.rb
+- lib/rvc/known_hosts.rb
 - lib/rvc/modules.rb
 - lib/rvc/modules/basic.rb
 - lib/rvc/modules/cluster.rb
 - lib/rvc/modules/datacenter.rb
 - lib/rvc/modules/datastore.rb
 - lib/rvc/modules/host.rb
+- lib/rvc/modules/mark.rb
 - lib/rvc/modules/resource_pool.rb
 - lib/rvc/modules/vim.rb
 - lib/rvc/modules/vm.rb