rvc 1.5.0 → 1.6.0

data/lib/rvc/extensions/DistributedVirtualPortgroup.rb

@@ -19,20 +19,284 @@
 # THE SOFTWARE.
 
 class RbVmomi::VIM::DistributedVirtualPortgroup
+  field 'vlan' do
+    summary 'VLAN configuration for the portgroup'
+    property 'config.defaultPortConfig'
+    block do |config|
+      translate_vlan config.vlan
+    end
+    default
+  end
+
+  field 'vds_name' do
+    summary 'Parent vDS of the portgroup'
+    property 'config.distributedVirtualSwitch'
+    block { |vds| vds.config.name }
+  end
+
+  #field 'active ports' do
+  #  summary 'number of active ports'
+  #  property 'config'
+  #  block do |config|
+  #    vds = config.distributedVirtualSwitch
+  #    ports = vds.FetchDVPorts(:criteria => {
+  #                               :portgroupKey => [self.key], :inside => true,
+  #                               :active => true})
+  #    ports.size
+  #  end
+  #  default
+  #end
+
+  field 'status' do
+    default false
+  end
+
+
+  def summarize
+    vds = self.config.distributedVirtualSwitch
+    pc = vds._connection.propertyCollector
+    ports = vds.FetchDVPorts(:criteria => {
+                               :portgroupKey => [self.key], :inside => true,
+                               :active => true})
+
+    if ports.empty?
+      puts "No active ports in portgroup"
+      return
+    end
+
+    objects = []
+    ports.each { |port|
+      objects << port.proxyHost
+      objects << port.connectee.connectedEntity
+    }
+
+    spec = {
+      :objectSet => objects.map { |obj| { :obj => obj } },
+      :propSet => [{:type => "ManagedEntity", :pathSet => %w(name) }]
+    }
+
+    props = pc.RetrieveProperties(:specSet => [spec])
+    t = table(['key', 'name', 'vlan', 'blocked', 'host', 'connectee'])
+    data = []
+
+    names = {}
+    props.each { |prop| names[prop.obj] = prop['name'] }
+    ports.each { |port|
+      port_key = begin port.key.to_i; rescue port.key; end
+      # XXX map resource pools, vlan config properly
+      data << [port_key, port.config.name,
+      #puts [port_key, port.config.name,
+               translate_vlan(port.config.setting.vlan),
+               port.state.runtimeInfo.blocked,
+               names[port.proxyHost],
+               #port.config.setting.networkResourcePoolKey.value,
+               "#{names[port.connectee.connectedEntity]}"]
+    }
+    data.sort { |x,y| x[0] <=> y[0] }.each { |row| t << row }
+    puts t
+  end
+
   def display_info
-    config, = collect(:config)
-    puts "name: #{config.name}"
-    puts "ports: #{config.numPorts}"
-    puts "description: #{config.description}"
-    puts "switch: #{config.distributedVirtualSwitch.name}"
+    vds = self.config.distributedVirtualSwitch
+    self.config.defaultPortConfig.dump_config vds, ""
+  end
+
+
+  def self.folder?
+    true
+  end
+
+  def children
+    vds = self.config.distributedVirtualSwitch
+
+    ports = vds.FetchDVPorts(:criteria => {:portgroupKey => [self.key],
+                               :inside => true, :active => true})
+    children = {}
+    begin
+      # try to sort port keys in numeric order
+      keys = ports.map {|port| [port.key.to_i, port]}.sort {|x,y| x[0] <=> y[0]}
+    rescue
+      keys = ports.map { |port| port.key }
+    end
+    keys.each { |i| children["port-#{i[0]}"] = i[1] }
+    children['all'] = RVC::FakeFolder.new(self, :get_all_ports)
+
+    children
   end
 
-  def self.ls_properties
-    %w(name config.distributedVirtualSwitch)
+  def traverse_one arc
+    if arc == 'all'
+      RVC::FakeFolder.new(self, :get_all_ports)
+    else
+      port_num = arc.gsub(/^port-/, '').to_i
+      vds = self.config.distributedVirtualSwitch
+      ports = vds.FetchDVPorts(:criteria => {:portKey => [port_num.to_s]})
+      return ports[0]
+    end
+  end
+
+  def rvc_ls
+    children = self.children
+    name_map = children.invert
+    children, fake_children = children.partition { |k,v| v.is_a? VIM::ManagedEntity }
+    i = 0
+
+    pc = self.config.distributedVirtualSwitch._connection.propertyCollector
+
+    objects = []
+    fake_children.each do |name, port|
+      if port.respond_to?(:connectee)
+        objects << port.connectee.connectedEntity
+      end
+    end
+
+    if objects.any? { |x| x.is_a? VIM::VirtualMachine }
+      spec = {
+        :objectSet => objects.map { |obj| { :obj => obj } },
+        :propSet => [{:type => "VirtualMachine",
+                       :pathSet => %w(guest.net config.hardware.device name)}]
+      }
+
+      prop_sets = pc.RetrieveProperties(:specSet => [spec])
+    else
+      prop_sets = []
+    end
+
+    #pp prop_sets
+
+    ips = {}
+    macs = {}
+    device_macs = {}
+    names = {}
+    prop_sets.each do |prop_set|
+      prop_set.propSet.each do |prop|
+        if prop.name == "guest.net"
+          prop.val.each do |nicinfo|
+            #XXX nicinfo.ipConfig has more info and IPv6
+            ips[prop_set.obj.to_s +
+                nicinfo.deviceConfigId.to_s] = nicinfo.ipAddress
+            macs[prop_set.obj.to_s +
+                 nicinfo.deviceConfigId.to_s] = nicinfo.macAddress
+          end
+        elsif prop.name == "config.hardware.device"
+          prop.val.each do |device|
+            if device.class < VIM::VirtualEthernetCard
+              device_macs[prop_set.obj.to_s +
+                          device.key.to_s] = device.macAddress
+            end
+          end
+        elsif prop.name == "name"
+          names[prop_set.obj] = prop.val
+        end
+      end
+    end
+    #pp ip
+    #pp mac
+    #pp device_mac
+
+    fake_children.each do |name,child|
+      print "#{i} #{name}"
+      if child.class.folder?
+        print "/"
+      end
+      if child.respond_to?(:connectee)
+        vm_name = names[child.connectee.connectedEntity]
+        mac = macs[child.connectee.connectedEntity.to_s +
+                   child.connectee.nicKey]
+        ip = ips[child.connectee.connectedEntity.to_s + child.connectee.nicKey]
+        device_mac = device_macs[child.connectee.connectedEntity.to_s +
+                                 child.connectee.nicKey]
+        if mac and ip
+          puts " (#{mac} #{ip} #{vm_name})"
+        elsif device_mac
+          puts " (#{device_mac} #{vm_name})"
+        else
+          puts ""
+        end
+      else
+        puts ""
+      end
+      child.rvc_link self, name
+      CMD.mark.mark i.to_s, [child]
+      i += 1
+    end
+  end
+
+  def get_all_ports
+    hash = {}
+    vds = self.config.distributedVirtualSwitch
+    begin
+      keys = self.portKeys.map { |key| key.to_i }.sort
+    rescue
+      keys = self.portKeys
+    end
+    keys.each { |key| hash["port-#{key}"] = LazyDVPort.new(self, key) }
+    hash
+  end
+end
+
+#XXX can we use a lazy delegate but not fetch the object during `ls`?
+class LazyDVPort
+  include RVC::InventoryObject
+
+  def initialize(pg, key)
+    @pg = pg
+    @key = key
+  end
+
+  def get_real_port
+    @port ||= @pg.config.distributedVirtualSwitch.FetchDVPorts(:criteria => {:portKey => [@key]})[0]
+  end
+
+  def display_info
+    self.get_real_port.display_info
+  end
+end
+
+def translate_vlan vlan
+  case "#{vlan.class}"
+  when "VmwareDistributedVirtualSwitchVlanIdSpec"
+    config = vlan.vlanId == 0 ? "-" : vlan.vlanId.to_s + " (tagging)"
+  when "VmwareDistributedVirtualSwitchTrunkVlanSpec"
+    config = vlan.vlanId.map { |r|
+      if r.start != r.end
+        "#{r.start}-#{r.end}"
+      else
+        "#{r.start}"
+      end
+    }.join(',') + " (trunked)"
+  when "Array"
+    config = vlan.map { |r|
+      if r.start != r.end
+        "#{r.start}-#{r.end}"
+      else
+        "#{r.start}"
+      end
+    }.join(',')
+    if config == "0"
+      config = "-"
+    else
+      config += " (trunked)"
+    end
+  when "VmwareDistributedVirtualSwitchPvlanSpec"
+    # XXX needs to be mapped
+    config = vlan.pvlanId.to_s + " (pvlan?)"
+  end
+
+  config
+end
+
+def translate_respool vds, pk, show_inheritance = true
+  if pk.value == '-1'
+    poolName = "-"
+  else
+    poolName = vds.networkResourcePool.find_all { |pool|
+      pk.value == pool.key
+    }[0].name
   end
 
-  def ls_text r
-    # XXX optimize
-    " (dvpg): <#{r['config.distributedVirtualSwitch'].name}"
+  if show_inheritance and !pk.inherited
+    poolName += "*"
   end
+  poolName
 end

data/lib/rvc/extensions/DistributedVirtualSwitch.rb

@@ -19,6 +19,68 @@
 # THE SOFTWARE.
 
 class RbVmomi::VIM::DistributedVirtualSwitch
+  field 'type' do
+    summary 'Type of the object'
+    block do
+      ['vds']
+    end
+  end
+
+  field 'hosts' do
+    summary 'Host members of the vDS'
+    property 'config'
+    block do |config|
+      hostnames = config.host.map { |host| host.config.host.name }
+      size = hostnames.size
+      if size > 10
+        hostnames = hostnames[0..10]
+        size -= 10
+        hostnames << "(and #{size} more...)"
+      end
+      hostnames.join "\n"
+    end
+    default
+  end
+
+  field 'vlans' do
+    summary 'VLANs in use by the vDS'
+    property 'portgroup'
+    block do |portgroups|
+      trunk_ranges = []
+      tag_ranges = []
+      portgroups.each do |pg|
+        vlan = pg.config.defaultPortConfig.vlan
+        if vlan.class == VIM::VmwareDistributedVirtualSwitchVlanIdSpec
+          if vlan.vlanId != 0
+            tag_ranges << Range.new(vlan.vlanId,vlan.vlanId)
+          end
+        elsif vlan.class == VIM::VmwareDistributedVirtualSwitchTrunkVlanSpec
+          vlan.vlanId.each { |range| trunk_ranges << Range.new(range.start,range.end) }
+        end
+      end
+      trunks = RVC::MODULES['vds'].merge_ranges(trunk_ranges).map { |r|
+        if r.begin == r.end then "#{r.begin}" else "#{r.begin}-#{r.end}" end
+      }.join ','
+
+      tags = RVC::MODULES['vds'].merge_ranges(tag_ranges).map { |r|
+        if r.begin == r.end then "#{r.begin}" else "#{r.begin}-#{r.end}" end
+      }.join ','
+      str = ""
+      if !trunk_ranges.empty?
+        str += "#{trunks} (trunked)"
+      end
+      if !tag_ranges.empty?
+        str += "\n#{tags} (switch tagged)\n"
+      end
+      str
+    end
+    default
+  end
+
+  field 'status' do
+    default false
+  end
+
   def display_info
     config, = collect(:config)
     puts "name: #{config.name}"
@@ -28,13 +90,72 @@ class RbVmomi::VIM::DistributedVirtualSwitch
     puts "standalone ports: #{config.numStandalonePorts}"
     puts "maximum ports: #{config.maxPorts}"
     puts "netIORM: #{config.networkResourceManagementEnabled}"
+    puts "Default Port Configuration:"
+    config.defaultPortConfig.dump_config self, "  ", false
+  end
+
+  def summarize
+    t = table(['portgroup name', 'num ports', 'vlan', 'resource pool'])
+    self.portgroup.each { |pg|
+      if pg.config.defaultPortConfig
+         respool = translate_respool self, pg.config.defaultPortConfig.networkResourcePoolKey
+         vlan = pg.config.defaultPortConfig.vlan
+      end
+
+      if pg.config.defaultPortConfig
+         t << [pg.config.name, pg.config.numPorts, translate_vlan(vlan), respool]
+      else
+         t << [pg.config.name, pg.config.numPorts, nil, nil]
+      end
+    }
+    puts t
+  end
+
+  def portgroup_children
+    portgroups = {}
+    self.portgroup.each { |pg|
+      portgroups[pg.name] = pg
+    }
+    portgroups
+  end
+
+  def respool_children
+    respools = {}
+    self.networkResourcePool.each do |pool|
+      respools[pool.name] = pool
+    end
+
+    respools
   end
 
-  def self.ls_properties
-    %w(name summary.description)
+  def hosts_children
+    hosts = {}
+    self.config.host.each do |hostinfo|
+      host = hostinfo.config.host
+      hosts[host.collect(:name).first] = host
+    end
+    hosts
+  end
+
+  def children
+    portgroups = RVC::FakeFolder.new(self, :portgroup_children)
+    portgroups.define_singleton_method :display_info, lambda {
+      vds = self.rvc_parent
+      RVC::MODULES['basic'].table vds.portgroup, {}
+    }
+
+    {
+      'portgroups' => portgroups,
+      'respools' => RVC::FakeFolder.new(self, :respool_children),
+      'hosts' => RVC::FakeFolder.new(self, :hosts_children),
+    }
   end
 
   def ls_text r
-    " (dvs)"
+    " (vds)"
+  end
+
+  def self.folder?
+    true
   end
 end

data/lib/rvc/extensions/Folder.rb

@@ -20,14 +20,21 @@
 
 class RbVmomi::VIM::Folder
   def traverse_one arc
-    @soap.searchIndex.FindChild :entity => self, :name => arc
+    _connection.searchIndex.FindChild :entity => self, :name => arc
   end
 
   def children
-    RVC::Util.collect_children self, :childEntity
+    RVC::Util.collect_children(self, :childEntity).reject { |name, item|
+      # hack -- we want to display dvportgroups under the dvs folder
+      item.class == RbVmomi::VIM::DistributedVirtualPortgroup
+    }
   end
 
   def self.folder?
     true
   end
+
+  def self.traverse?
+    true
+  end
 end