rvc 1.5.0 → 1.6.0

data/lib/rvc/modules/esxcli.rb

@@ -0,0 +1,193 @@
+# 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.
+
+raw_opts :execute, "Execute an esxcli command"
+
+EsxcliCache = TTLCache.new 60
+
+def lookup_esxcli host, args
+  cur = EsxcliCache[host, :esxcli]
+  i = 0
+  while i < args.length
+    k = args[i]
+    if cur.namespaces.member? k
+      cur = cur.namespaces[k]
+    elsif cur.commands.member? k
+      cur = cur.commands[k]
+      break
+    else
+      err "nonexistent esxcli namespace or command #{k.inspect}"
+    end
+    i += 1
+  end
+  return cur
+end
+
+rvc_completor :execute do |line, args, word, argnum|
+  if argnum == 0
+    # HostSystem argument
+    RVC::Completion.fs_candidates word
+  else
+    # esxcli namespace/method/arguments
+    host = lookup_single! args[0], VIM::HostSystem
+    o = lookup_esxcli host, args[1...argnum]
+
+    case o
+    when VIM::EsxcliCommand
+      parser = o.option_parser
+      candidates = parser.specs.map { |k,v| "--#{v[:long]}" }.sort
+    when VIM::EsxcliNamespace
+      candidates = o.namespaces.keys + o.commands.keys
+    else
+      fail "unreachable"
+    end
+
+    candidates.grep(/^#{Regexp.escape word}/).
+               map { |x| [x, ' '] }
+  end
+end
+
+def execute *args
+  host_path = args.shift or err "host argument required"
+  host = lookup_single! host_path, VIM::HostSystem
+  o = lookup_esxcli host, args
+
+  case o
+  when VIM::EsxcliCommand
+    cmd = o
+    parser = cmd.option_parser
+    begin
+      opts = parser.parse args
+    rescue Trollop::CommandlineError
+      err "error: #{$!.message}"
+    rescue Trollop::HelpNeeded
+      parser.educate
+      return
+    end
+    begin
+      opts.reject! { |k,v| !opts.member? :"#{k}_given" }
+      result = cmd.call(opts)
+    rescue RbVmomi::Fault
+      puts "#{$!.message}"
+      puts "cause: #{$!.faultCause}" if $!.respond_to? :faultCause and $!.faultCause
+      $!.faultMessage.each { |x| puts x } if $!.respond_to? :faultMessage
+      $!.errMsg.each { |x| puts "error: #{x}" } if $!.respond_to? :errMsg
+    end
+    output_formatted cmd, result
+  when VIM::EsxcliNamespace
+    ns = o
+    unless ns.commands.empty?
+      puts "Available commands:"
+      ns.commands.each do |k,v|
+        puts "#{k}: #{v.cli_info.help}"
+      end
+      puts unless ns.namespaces.empty?
+    end
+    unless ns.namespaces.empty?
+      puts "Available namespaces:"
+      ns.namespaces.each do |k,v|
+        puts "#{k}: #{v.cli_info.help}"
+      end
+    end
+  end
+end
+
+rvc_alias :execute, :esxcli
+rvc_alias :execute, :x
+
+def output_formatted cmd, result
+  hints = Hash[cmd.cli_info.hints]
+  formatter = hints['formatter']
+  formatter = "none" if formatter == ""
+  sym = :"output_formatted_#{formatter}"
+  if respond_to? sym
+    send sym, result, cmd.cli_info, hints
+  else
+    puts "Unknown formatter #{formatter.inspect}"
+    pp result
+  end
+end
+
+def output_formatted_none result, info, hints
+  pp result if result != true
+end
+
+def output_formatted_simple result, info, hints
+  case result
+  when Array
+    result.each do |r|
+      output_formatted_simple r, info, hints
+      puts
+    end
+  when RbVmomi::BasicTypes::DataObject
+    prop_descs = result.class.ancestors.
+                        take_while { |x| x != RbVmomi::BasicTypes::DataObject &&
+                                         x != VIM::DynamicData }.
+                        map(&:props_desc).flatten(1)
+    prop_descs.each do |desc|
+      print "#{desc['name']}: "
+      pp result.send desc['name']
+    end
+  else
+    pp result
+  end
+end
+
+def table_key str
+  str.downcase.gsub(/[^\w\d_]/, '')
+end
+
+def output_formatted_table result, info, hints
+  if result.empty?
+    puts "Empty result"
+    return
+  end
+
+  columns =
+    if hints.member? 'table-columns'
+      hints['table-columns'].split ','
+    elsif k = hints.keys.find { |k| k =~ /^fields:/ }
+      hints[k].split ','
+    else []
+    end
+  ordering = columns.map { |x| table_key x }
+
+  units = Hash[hints.select { |k,v| k =~ /^units:/ }.map { |k,v| [table_key(k.match(/[^.]+$/).to_s), v] }]
+
+  table = Terminal::Table.new :headings => columns
+  result.each do |r|
+    row = []
+    r.class.full_props_desc.each do |desc|
+      name = desc['name']
+      key = table_key name
+      next unless idx = ordering.index(key)
+      val = r.send name
+      unit = units[key]
+      row[idx] =
+        case unit
+        when nil then val
+        when '%' then "#{val}#{unit}"
+        else "#{val} #{unit}"
+        end
+    end
+    table.add_row row
+  end
+  puts table
+end

data/lib/rvc/modules/find.rb

@@ -0,0 +1,125 @@
+# 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 :find do
+  summary "Find objects matching certain criteria"
+  arg :args, "Paths or +terms", :required => false, :multi => true
+  opt :mark, "Store results in an aggregate mark", :default => 'A'
+  opt :type, "Type of objects to return", :multi => true, :type => :string
+end
+
+rvc_alias :find
+
+def find args, opts
+  args = args.group_by do |arg|
+    case arg
+    when /^\+/ then :term
+    else :root
+    end
+  end
+
+  results = find_items args[:term], args[:root], opts[:type]
+
+  CMD.mark.mark opts[:mark], results
+
+  i = 0
+  cwd = $shell.fs.cur.rvc_path_str
+  cwd_prefix = /^#{Regexp.escape cwd}\//
+  results.each do |r|
+    puts "#{i} #{r.rvc_path_str.gsub(cwd_prefix, '')}"
+    CMD.mark.mark i.to_s, [r]
+    i += 1
+  end
+end
+
+def find_items terms = nil, roots = nil, types = nil
+  roots ||= ['.']
+  terms ||= []
+
+  types.each { |t| terms <<  "+type=#{t}" }
+  roots = roots.map { |x| lookup x }.flatten(1)
+  terms = terms.map { |x| term x[1..-1] }
+
+  candidates = leaves roots, types
+  results = candidates.select { |r| terms.all? { |t| t[r] } }
+end
+
+def leaves roots, types = []
+  leaves = Set.new
+  new_nodes = roots
+  while not new_nodes.empty?
+    nodes = new_nodes
+    new_nodes = Set.new
+    nodes.each do |node|
+      if (node.class.traverse? or roots.member? node) and
+          (types & (node.field('type') || [])).empty?
+        node.children.each { |k,v| v.rvc_link(node, k); new_nodes << v }
+      else
+        leaves << node
+      end
+    end
+  end
+  leaves
+end
+
+def term x
+  case x
+  when /^([\w.]+)(!)?(>=|<=|=|>|<|~)/
+    lhs = $1
+    negate = $2 != nil
+    op = $3
+    rhs = $'
+    lambda do |o|
+      a = o.field(lhs)
+      a = [a].compact unless a.is_a? Enumerable
+      return negate if a.empty?
+      type = a.first.class
+      fail "all objects in field #{lhs.inspect} must have the same type" unless a.all? { |x| x.is_a? type }
+      b = coerce_str type, rhs
+      a.any? do |x|
+        case op
+        when '='  then x == b
+        when '>'  then x > b
+        when '>=' then x >= b
+        when '<'  then x < b
+        when '<=' then x <= b
+        when '~'  then x =~ Regexp.new(b)
+        end
+      end ^ negate
+    end
+  when /^\w+$/
+    lambda { |o| o.field(x) }
+  else
+    err "failed to parse expression #{x.inspect}"
+  end
+end
+
+def coerce_str type, v
+  fail "expected String, got #{v.class}" unless v.is_a? String
+  if type <= Integer then v.to_i
+  elsif type == Float then v.to_f
+  elsif type == TrueClass or type == FalseClass then v == 'true'
+  elsif type == NilClass then v == 'nil' ? nil : !nil
+  elsif v == 'nil' then nil
+  elsif type == String then v
+  elsif type.respond_to? :parse then type.parse(v)
+  else fail "unexpected coercion type #{type}"
+  end
+end

data/lib/rvc/modules/issue.rb

@@ -0,0 +1,33 @@
+# 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 :show do
+  summary "Show issues on the given entities"
+  arg :entity, nil, :lookup => VIM::ManagedEntity, :multi => true
+end
+
+def show objs
+  issues = objs.map(&:configIssue).flatten.uniq
+  issues.each do |issue|
+    puts issue.fullFormattedMessage
+  end
+end
+
+rvc_alias :show, :issues

data/lib/rvc/modules/perf.rb

@@ -0,0 +1,284 @@
+begin
+  require 'gnuplot'
+  RVC::HAVE_GNUPLOT = true
+rescue LoadError
+  RVC::HAVE_GNUPLOT = false
+end
+
+TIMEFMT = '%Y-%m-%dT%H:%M:%SZ'
+
+DISPLAY_TIMEFMT = {
+  :realtime => '%H:%M',
+  1 => '%H:%M',
+  2 => '%m/%d',
+  3 => '%m/%d',
+  4 => '%Y/%m/%d',
+}
+
+opts :plot do
+  summary "Plot a graph of the given performance counters"
+  arg :counter, "Counter name"
+  arg :obj, "", :lookup => VIM::ManagedEntity, :multi => true
+  opt :terminal, "Display plot on terminal", :default => ENV['DISPLAY'].nil?
+  opt :start, "Start time", :type => :date, :short => 's'
+  opt :end, "End time", :type => :date, :short => 'e'
+end
+
+def plot counter_name, objs, opts
+  err "The gnuplot gem is not installed" unless RVC::HAVE_GNUPLOT
+  vim = single_connection objs
+  pm = vim.serviceContent.perfManager
+  group_key, counter_key, rollup_type = counter_name.split('.', 3)
+
+  now = Time.now
+  opts[:end] ||= now
+  opts[:start] ||= opts[:end] - 1800
+
+  err "end time is in the future" unless opts[:end] <= Time.now
+  ago = now - opts[:start]
+
+  if ago < 3600
+    #puts "Using realtime interval, period = 20 seconds."
+    interval_id = 20
+    display_timefmt = DISPLAY_TIMEFMT[:realtime]
+  else
+    intervals = pm.historicalInterval
+    interval = intervals.find { |x| now - x.length < opts[:start] }
+    err "start time is too long ago" unless interval
+    #puts "Using historical interval #{interval.name.inspect}, period = #{interval.samplingPeriod} seconds."
+    interval_id = interval.samplingPeriod
+    display_timefmt = DISPLAY_TIMEFMT[interval.key]
+  end
+
+  all_counters = Hash[pm.perfCounter.map { |x| [x.key, x] }]
+
+  metrics = pm.QueryAvailablePerfMetric(
+    :entity => objs.first,
+    :interval => interval_id)
+
+  metric = metrics.find do |metric|
+    counter = all_counters[metric.counterId]
+    counter.groupInfo.key == group_key &&
+      counter.nameInfo.key == counter_key &&
+      counter.rollupType == rollup_type
+  end or err "no such metric"
+  counter = all_counters[metric.counterId]
+
+  specs = objs.map do |obj|
+    {
+      :entity => obj,
+      :metricId => [metric],
+      :intervalId => interval_id,
+      :startTime => opts[:start],
+      :endTime => opts[:end],
+      :format => 'csv',
+    }
+  end
+
+  with_gnuplot(true) do |gp|
+    plot = Gnuplot::Plot.new(gp) do |plot|
+      if objs.size == 1
+        plot.title "#{counter_name} on #{objs[0].name}"
+      else
+        plot.title counter_name
+      end
+
+      plot.ylabel counter.unitInfo.label
+      plot.xlabel "Time"
+      plot.terminal 'dumb' if opts[:terminal]
+
+      plot.set 'xdata', 'time'
+      plot.set 'format', "x '#{display_timefmt}'"
+      plot.set 'timefmt', TIMEFMT.inspect
+
+      if counter.unitInfo.key == 'percent'
+        plot.set 'yrange', '[0:100]'
+      end
+
+      plot.data = retrieve_datasets pm, counter, specs
+    end
+    gp.puts
+  end
+end
+
+def retrieve_datasets pm, counter, specs
+  results = pm.QueryPerf(:querySpec => specs)
+  datasets = results.map do |result|
+    times = result.sampleInfoCSV.split(',').select { |x| x['T']  }
+    data = result.value[0].value.split(',').map(&:to_i)
+
+    if counter.unitInfo.key == 'percent'
+      times.length.times do |i|
+        times[i] = data[i] = nil if data[i] < 0
+      end
+
+      times.compact!
+      data.compact!
+      data.map! { |x| x/100.0 }
+    end
+
+    Gnuplot::DataSet.new([times, data]) do |ds|
+      ds.notitle if specs.size == 1
+      ds.with = "lines"
+      ds.using = '1:2'
+      ds.title = result.entity.name
+    end
+  end
+end
+
+def with_gnuplot persist
+  if $rvc_gnuplot
+    yield $rvc_gnuplot
+  else
+    cmd = Gnuplot.gnuplot(persist) or err 'gnuplot not found'
+    $rvc_gnuplot = IO::popen(cmd, "w")
+    begin
+      yield $rvc_gnuplot
+    ensure
+      gp = $rvc_gnuplot
+      $rvc_gnuplot = nil
+      gp.close
+    end
+  end
+end
+
+
+opts :watch do
+  summary "Watch a graph of the given performance counters"
+  arg :counter, "Counter name"
+  arg :objs, "", :lookup => VIM::ManagedEntity, :multi => true
+  opt :interval, "Seconds between updates", :short => 'i', :default => 10
+  opt :terminal, "Display plot on terminal", :default => ENV['DISPLAY'].nil?
+end
+
+def watch counter_name, objs, opts
+  err "The gnuplot gem is not installed" unless RVC::HAVE_GNUPLOT
+  with_gnuplot false do |gp|
+    puts "Press Ctrl-C to stop."
+    while true
+      plot counter_name, objs, :terminal => opts[:terminal]
+      sleep opts[:interval]
+      if opts[:terminal]
+        $stdout.write "\e[25A"
+        $stdout.flush
+      end
+    end
+  end
+rescue Interrupt
+end
+
+
+opts :counters do
+  summary "Display available perf counters"
+  arg :obj, nil, :lookup => VIM::ManagedEntity
+end
+
+def counters obj
+  pm = obj._connection.serviceContent.perfManager
+  interval = pm.provider_summary(obj).refreshRate
+  if interval == -1
+    # Object does not support real time stats
+    interval = nil
+  end
+
+  metrics = pm.QueryAvailablePerfMetric(
+    :entity => obj, 
+    :intervalId => interval)
+  available_counters = metrics.map(&:counterId).uniq.
+                               map { |id| pm.perfcounter_idhash[id] }
+
+  groups = available_counters.group_by { |counter| counter.groupInfo }
+  groups.sort_by { |group,counters| group.key }.each do |group,counters|
+    puts "#{group.label}:"
+    counters.sort_by(&:pretty_name).each do |counter|
+      puts " #{counter.pretty_name}: #{counter.nameInfo.label} (#{counter.unitInfo.label})"
+    end
+  end
+end
+
+
+opts :counter do
+  summary "Retrieve detailed information about a perf counter"
+  arg :metric, nil, :type => :string
+  arg :obj, nil, :lookup => VIM::ManagedEntity, :required => false
+end
+
+def counter counter_name, obj
+  vim = obj ? obj._connection : lookup_single('~@')
+  pm = vim.serviceContent.perfManager
+  counter = pm.perfcounter_hash[counter_name] or err "no such counter #{counter_name.inspect}"
+
+  intervals = pm.historicalInterval
+  active_intervals = lambda { |level| intervals.select { |x| x.level >= level } }
+  active_intervals_text = lambda do |level|
+    xs = active_intervals[level]
+    xs.empty? ? 'none' : xs.map(&:name).map(&:inspect) * ', '
+  end
+
+  puts "Label: #{counter.nameInfo.label}"
+  puts "Summary: #{counter.nameInfo.summary}"
+  puts "Unit label: #{counter.unitInfo.label}"
+  puts "Unit summary: #{counter.unitInfo.summary}"
+  puts "Rollup type: #{counter.rollupType}"
+  puts "Stats type: #{counter.statsType}"
+  puts "Level: #{counter.level}"
+  puts " Enabled in intervals: #{active_intervals_text[counter.level]}"
+  puts "Per-device level: #{counter.perDeviceLevel}"
+  puts " Enabled in intervals: #{active_intervals_text[counter.perDeviceLevel]}"
+
+  if obj
+    interval = pm.provider_summary(obj).refreshRate
+    if interval == -1
+      # Object does not support real time stats
+      interval = nil
+    end
+    puts "Real time interval: #{interval || 'N/A'}"
+    metrics = pm.QueryAvailablePerfMetric(:entity => obj, :intervalId => interval)
+    metrics.select! { |x| x.counterId == counter.key }
+    instances = metrics.map(&:instance).reject(&:empty?)
+    unless instances.empty?
+      puts "Instances:"
+      instances.map do |x|
+        puts "  #{x}"
+      end
+    end
+  end
+end
+
+opts :stats do
+  summary "Retrieve performance stats for given object"
+  arg :metrics, nil, :type => :string
+  arg :obj, nil, :multi => true, :lookup => VIM::ManagedEntity
+  opt :samples, "Number of samples to retrieve", :type => :int
+end
+
+def stats metrics, objs, opts
+  metrics = metrics.split(",")
+  obj = objs.first
+  pm = obj._connection.serviceContent.perfManager
+  interval = pm.provider_summary(obj).refreshRate
+  start_time = nil
+  if interval == -1
+    # Object does not support real time stats
+    interval = 300
+    start_time = Time.now - 300 * 5
+  end
+  stat_opts = {
+    :interval => interval,
+    :startTime => start_time,
+  }
+  stat_opts[:max_samples] = opts[:samples] if opts[:samples]
+  res = pm.retrieve_stats objs, metrics, stat_opts
+
+  table = Terminal::Table.new
+  table.add_row ['Object', 'Metric', 'Values', 'Unit']
+  table.add_separator
+  objs.each do |obj|
+    metrics.each do |metric|
+      stat = res[obj][:metrics][metric]
+      metric_info = pm.perfcounter_hash[metric]
+      table.add_row([obj.name, metric, stat.join(','), metric_info.unitInfo.label])
+    end
+  end
+  puts table
+end