ibm_power_hmc 0.5.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c866478ebd950e9570ce2983d62e90b15fdc27163ea77f3b3f5873138b57cf9
-  data.tar.gz: c58488b78a699e4d0f1fc48c43d41db03f9df7c20f861d29e37d80375e8068a2
+  metadata.gz: af5d28dd76ae4e57514691d4ab40e023ca18a6a7e71c4691b15c564097920964
+  data.tar.gz: 68a2d511853792668bca5247da9c1910725367ff6fb65ec3f21674953b7be876
 SHA512:
-  metadata.gz: 8201481418ec67876a0298d8785ca23a7f2e366a4765ddda8e98024fa71a97a79932661d920090b033da9958c3859460865bb56b7379058e02a9d4f688dab523
-  data.tar.gz: cfee7c90c9c22149358b17cf861df4d31d757dde93cf5a30c1196f7957fe48d28bb636643bfbed99238b18215d2048d61c85067b66c8d481bc7678d3fe5ab112
+  metadata.gz: a77ff9b3db36ef774dd64b37d14b5bd57226cbfe31dece9e17c799089c94418d24bea27f2504fbd0ec84d9e3120023a11db1e4619f06e46f92f12c629398d1ff
+  data.tar.gz: 0feb113a298fb117d6ef5cbfaf1fbab3b6a7e72bb69a749c7a36bc0255147d1e0b640879acd1e233780eecb8ef96768efe35e43ea56e3c73ecd7914b63387f09

data/README.md

@@ -52,9 +52,9 @@ Listing the logical partitions and virtual I/O servers of each managed system:
 
 ```ruby
 hc.managed_systems.each do |sys|
-  puts sys
-  puts hc.lpars(sys.uuid)
-  puts hc.vioses(sys.uuid)
+  puts sys.name
+  hc.lpars(sys.uuid).each { |lpar| puts lpar.name }
+  hc.vioses(sys.uuid).each { |vios| puts vios.name }
 end
 ```
 
@@ -73,9 +73,9 @@ hc.poweroff_lpar(lpar_uuid, { "operation" => "shutdown" })
 Processing events:
 
 ```ruby
-loop
+loop do
   hc.next_events.each do |event|
-    puts event
+    puts event.type
   end
 end
 ```

data/lib/ibm_power_hmc/connection.rb

@@ -262,6 +262,171 @@ module IbmPowerHmc
       network_adapter("VirtualIOServer", vios_uuid, netadap_uuid)
     end
 
+    ##
+    # @!method sriov_elp_lpar(lpar_uuid, sriov_elp_uuid = nil)
+    # Retrieve one or all SR-IOV ethernet logical ports attached to a logical partition.
+    # @param lpar_uuid [String] UUID of the logical partition.
+    # @param sriov_elp_uuid [String] UUID of the port to match (returns all ports if omitted).
+    # @return [Array<IbmPowerHmc::SRIOVEthernetLogicalPort>, IbmPowerHmc::SRIOVEthernetLogicalPort] The list of ports.
+    def sriov_elp_lpar(lpar_uuid, sriov_elp_uuid = nil)
+      sriov_ethernet_port("LogicalPartition", lpar_uuid, sriov_elp_uuid)
+    end
+
+    ##
+    # @!method network_adapter_vios(vios_uuid, sriov_elp_uuid = nil)
+    # Retrieve one or all SR-IOV ethernet logical ports attached to a Virtual I/O Server.
+    # @param vios_uuid [String] UUID of the Virtual I/O Server.
+    # @param sriov_elp_uuid [String] UUID of the port to match (returns all ports if omitted).
+    # @return [Array<IbmPowerHmc::SRIOVEthernetLogicalPort>, IbmPowerHmc::SRIOVEthernetLogicalPort] The list of ports.
+    def sriov_elp_vios(vios_uuid, sriov_elp_uuid = nil)
+      sriov_ethernet_port("VirtualIOServer", vios_uuid, sriov_elp_uuid)
+    end
+
+    ##
+    # @!method vnic_dedicated(lpar_uuid, vnic_uuid = nil)
+    # Retrieve one or all dedicated virtual network interface controller (vNIC) attached to a logical partition.
+    # @param lpar_uuid [String] UUID of the logical partition.
+    # @param vnic_uuid [String] UUID of the vNIC to match (returns all vNICs if omitted).
+    # @return [Array<IbmPowerHmc::VirtualNICDedicated>, IbmPowerHmc::VirtualNICDedicated] The list of vNICs.
+    def vnic_dedicated(lpar_uuid, vnic_uuid = nil)
+      if vnic_uuid.nil?
+        method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/VirtualNICDedicated"
+        response = request(:get, method_url)
+        FeedParser.new(response.body).objects(:VirtualNICDedicated)
+      else
+        method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/VirtualNICDedicated/#{vnic_uuid}"
+        response = request(:get, method_url)
+        Parser.new(response.body).object(:VirtualNICDedicated)
+      end
+    end
+
+    ##
+    # @!method clusters
+    # Retrieve the list of clusters managed by the HMC.
+    # @return [Array<IbmPowerHmc::Cluster>] The list of clusters.
+    def clusters
+      method_url = "/rest/api/uom/Cluster"
+      response = request(:get, method_url)
+      FeedParser.new(response.body).objects(:Cluster)
+    end
+
+    ##
+    # @!method cluster(cl_uuid)
+    # Retrieve information about a cluster.
+    # @param cl_uuid [String] The UUID of the cluster.
+    # @return [IbmPowerHmc::Cluster] The cluster.
+    def cluster(cl_uuid)
+      method_url = "/rest/api/uom/Cluster/#{cl_uuid}"
+      response = request(:get, method_url)
+      Parser.new(response.body).object(:Cluster)
+    end
+
+    ##
+    # @!method ssps
+    # Retrieve the list of shared storage pools managed by the HMC.
+    # @return [Array<IbmPowerHmc::SharedStoragePool>] The list of shared storage pools.
+    def ssps
+      method_url = "/rest/api/uom/SharedStoragePool"
+      response = request(:get, method_url)
+      FeedParser.new(response.body).objects(:SharedStoragePool)
+    end
+
+    ##
+    # @!method ssp(ssp_uuid)
+    # Retrieve information about a shared storage pool.
+    # @param ssp_uuid [String] The UUID of the shared storage pool.
+    # @return [IbmPowerHmc::SharedStoragePool] The shared storage pool.
+    def ssp(ssp_uuid)
+      method_url = "/rest/api/uom/SharedStoragePool/#{ssp_uuid}"
+      response = request(:get, method_url)
+      Parser.new(response.body).object(:SharedStoragePool)
+    end
+
+    ##
+    # @!method tiers(group_name = nil)
+    # Retrieve the list of tiers that are part of shared storage pools managed by the HMC.
+    # @param group_name [String] The extended group attributes.
+    # @return [Array<IbmPowerHmc::Tier>] The list of tiers.
+    def tiers(group_name = nil)
+      method_url = "/rest/api/uom/Tier"
+      method_url += "?group=#{group_name}" unless group_name.nil?
+      response = request(:get, method_url)
+      FeedParser.new(response.body).objects(:Tier)
+    end
+
+    ##
+    # @!method tier(tier_uuid, ssp_uuid = nil, group_name = nil)
+    # Retrieve information about a tier.
+    # @param tier_uuid [String] The UUID of the tier.
+    # @param ssp_uuid [String] The UUID of the shared storage pool.
+    # @param group_name [String] The extended group attributes.
+    # @return [IbmPowerHmc::Tier] The tier.
+    def tier(tier_uuid, ssp_uuid = nil, group_name = nil)
+      if ssp_uuid.nil?
+        method_url = "/rest/api/uom/Tier/#{tier_uuid}"
+      else
+        method_url = "/rest/api/uom/SharedStoragePool/#{ssp_uuid}/Tier/#{tier_uuid}"
+      end
+      method_url += "?group=#{group_name}" unless group_name.nil?
+
+      response = request(:get, method_url)
+      Parser.new(response.body).object(:Tier)
+    end
+
+    ##
+    # @!method templates_summary
+    # Retrieve the list of partition template summaries.
+    # @return [Array<IbmPowerHmc::PartitionTemplateSummary>] The list of partition template summaries.
+    def templates_summary
+      method_url = "/rest/api/templates/PartitionTemplate"
+      response = request(:get, method_url)
+      FeedParser.new(response.body).objects(:PartitionTemplateSummary)
+    end
+
+    ##
+    # @!method templates
+    # Retrieve the list of partition templates.
+    # @return [Array<IbmPowerHmc::PartitionTemplate>] The list of partition templates.
+    def templates
+      method_url = "/rest/api/templates/PartitionTemplate?detail=full"
+      response = request(:get, method_url)
+      FeedParser.new(response.body).objects(:PartitionTemplate)
+    end
+
+    ##
+    # @!method template(template_uuid)
+    # Retrieve details for a particular partition template.
+    # @param template_uuid [String] UUID of the partition template.
+    # @return [IbmPowerHmc::PartitionTemplate] The partition template.
+    def template(template_uuid)
+      method_url = "/rest/api/templates/PartitionTemplate/#{template_uuid}"
+      response = request(:get, method_url)
+      Parser.new(response.body).object(:PartitionTemplate)
+    end
+
+    ##
+    # @!method capture_lpar(lpar_uuid, sys_uuid, template_name, sync = true)
+    # Capture partition configuration as template.
+    # @param lpar_uuid [String] The UUID of the logical partition.
+    # @param sys_uuid [String] The UUID of the managed system.
+    # @param template_name [String] The name to be given for the new template.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def capture_lpar(lpar_uuid, sys_uuid, template_name, sync = true)
+      # Need to include session token in payload so make sure we are logged in
+      logon if @api_session_token.nil?
+      method_url = "/rest/api/templates/PartitionTemplate/do/capture"
+      params = {
+        "TargetUuid"              => lpar_uuid,
+        "NewTemplateName"         => template_name,
+        "ManagedSystemUuid"       => sys_uuid,
+        "K_X_API_SESSION_MEMENTO" => @api_session_token
+      }
+      job = HmcJob.new(self, method_url, "Capture", "PartitionTemplate", params)
+      job.run if sync
+      job
+    end
+
     ##
     # @!method poweron_lpar(lpar_uuid, params = {}, sync = true)
     # Power on a logical partition.
@@ -394,7 +559,31 @@ module IbmPowerHmc
         # No need to sleep as the HMC already waits a bit before returning 204
         break if response.code != 204 || !wait
       end
-      FeedParser.new(response.body).objects(:Event)
+      FeedParser.new(response.body).objects(:Event).map do |e|
+        data = e.data.split("/") unless e.data.nil?
+        if !data.nil? && data.length >= 2 && data[-2].eql?("UserTask")
+          e.usertask = usertask(data.last)
+        end
+        e
+      end.compact
+    end
+
+    ##
+    # @!method usertask(uuid = true)
+    # Retrieve details of an event of type "user task".
+    # @param uuid [String] UUID of user task.
+    # @return [Hash] Hash of user task attributes.
+    def usertask(uuid)
+      method_url = "/rest/api/ui/UserTask/#{uuid}"
+      response = request(:get, method_url)
+      j = JSON.parse(response.body)
+      if j['status'].eql?("Completed")
+        case j['key']
+        when "TEMPLATE_PARTITION_SAVE", "TEMPLATE_PARTITION_SAVE_AS", "TEMPLATE_PARTITION_CAPTURE"
+          j['template_uuid'] = templates_summary.find { |t| t.name.eql?(j['labelParams'].first) }&.uuid
+        end
+      end
+      j
     end
 
     ##
@@ -518,5 +707,24 @@ module IbmPowerHmc
         Parser.new(response.body).object(:ClientNetworkAdapter)
       end
     end
+
+    ##
+    # @!method sriov_ethernet_port(vm_type, lpar_uuid, sriov_elp_uuid)
+    # Retrieve one or all SR-IOV Ethernet loical ports attached to a Logical Partition or a Virtual I/O Server.
+    # @param vm_type [String] "LogicalPartition" or "VirtualIOServer".
+    # @param lpar_uuid [String] UUID of the Logical Partition or the Virtual I/O Server.
+    # @param sriov_elp_uuid [String] UUID of the port to match (returns all ports if nil).
+    # @return [Array<IbmPowerHmc::SRIOVEthernetLogicalPort>, IbmPowerHmc::SRIOVEthernetLogicalPort] The list of ports.
+    def sriov_ethernet_port(vm_type, lpar_uuid, sriov_elp_uuid)
+      if sriov_elp_uuid.nil?
+        method_url = "/rest/api/uom/#{vm_type}/#{lpar_uuid}/SRIOVEthernetLogicalPort"
+        response = request(:get, method_url)
+        FeedParser.new(response.body).objects(:SRIOVEthernetLogicalPort)
+      else
+        method_url = "/rest/api/uom/#{vm_type}/#{lpar_uuid}/SRIOVEthernetLogicalPort/#{sriov_elp_uuid}"
+        response = request(:get, method_url)
+        Parser.new(response.body).object(:SRIOVEthernetLogicalPort)
+      end
+    end
   end
 end

data/lib/ibm_power_hmc/job.rb

@@ -26,7 +26,7 @@ module IbmPowerHmc
     ##
     # @!method start
     # Start the job asynchronously.
-    # @return [String] The ID of the job.
+    # @return [String] The URL of the job.
     def start
       headers = {
         :content_type => "application/vnd.ibm.powervm.web+xml; type=JobRequest"
@@ -47,7 +47,8 @@ module IbmPowerHmc
       end
       response = @conn.request(:put, @method_url, headers, doc.to_s)
       jobresp = Parser.new(response.body).object(:JobResponse)
-      @id = jobresp.id
+      # Save the URL of the job (JobID is not sufficient as not all jobs are in uom).
+      @href = jobresp.href.path
     end
 
     # @return [Hash] The job results returned by the HMC.
@@ -58,13 +59,12 @@ module IbmPowerHmc
     # Return the status of the job.
     # @return [String] The status of the job.
     def status
-      raise JobNotStarted unless defined?(@id)
+      raise JobNotStarted unless defined?(@href)
 
-      method_url = "/rest/api/uom/jobs/#{@id}"
       headers = {
         :content_type => "application/vnd.ibm.powervm.web+xml; type=JobRequest"
       }
-      response = @conn.request(:get, method_url, headers)
+      response = @conn.request(:get, @href, headers)
       jobresp = Parser.new(response.body).object(:JobResponse)
       @results = jobresp.results
       jobresp.status
@@ -100,17 +100,16 @@ module IbmPowerHmc
       start
       wait(timeout, poll_interval)
     ensure
-      delete if defined?(@id)
+      delete if defined?(@href)
     end
 
     ##
     # @!method delete
     # Delete the job from the HMC.
     def delete
-      raise JobNotStarted unless defined?(@id)
+      raise JobNotStarted unless defined?(@href)
 
-      method_url = "/rest/api/uom/jobs/#{@id}"
-      @conn.request(:delete, method_url)
+      @conn.request(:delete, @href)
       # Returns HTTP 204 if ok
     end
   end

data/lib/ibm_power_hmc/parser.rb

@@ -74,9 +74,6 @@ module IbmPowerHmc
     end
   end
 
-  private_constant :Parser
-  private_constant :FeedParser
-
   ##
   # HMC generic K2 non-REST object.
   # @abstract
@@ -116,8 +113,33 @@ module IbmPowerHmc
       attr.nil? ? elem.text&.strip : elem.attributes[attr]
     end
 
-    def extract_uuid_from_href(href)
-      URI(href).path.split('/').last
+    def to_s
+      str = +"#{self.class.name}:\n"
+      self.class::ATTRS.each do |varname, _|
+        value = instance_variable_get("@#{varname}")
+        value = value.nil? ? "null" : "'#{value}'"
+        str << "  #{varname}: #{value}\n"
+      end
+      str
+    end
+
+    def uuid_from_href(href, index = -1)
+      URI(href).path.split('/')[index]
+    end
+
+    def uuids_from_links(elem, index = -1)
+      xml.get_elements("#{elem}/link[@href]").map do |link|
+        uuid_from_href(link.attributes["href"], index)
+      end.compact
+    end
+
+    def collection_of(name, type)
+      objtype = Module.const_get("IbmPowerHmc::#{type}")
+      xml.get_elements("#{name}/#{type}").map do |elem|
+        objtype.new(elem)
+      end
+    rescue
+      []
     end
   end
 
@@ -145,6 +167,12 @@ module IbmPowerHmc
     attr_reader :uuid, :published, :href, :etag, :content_type
 
     def initialize(entry)
+      if entry.name != "entry"
+        # We are inlined.
+        super(entry)
+        return
+      end
+
       @uuid = entry.elements["id"]&.text
       @published = Time.xmlschema(entry.elements["published"]&.text)
       link = entry.elements["link[@rel='SELF']"]
@@ -154,6 +182,13 @@ module IbmPowerHmc
       @content_type = content.attributes["type"]
       super(content.elements.first)
     end
+
+    def to_s
+      str = super
+      str << "  uuid: '#{uuid}'\n" if defined?(@uuid)
+      str << "  published: '#{published}'\n" if defined?(@published)
+      str
+    end
   end
 
   # HMC information
@@ -161,12 +196,17 @@ module IbmPowerHmc
     ATTRS = {
       :name => "ManagementConsoleName",
       :build_level => "VersionInfo/BuildLevel",
-      :version => "BaseVersion"
+      :version => "BaseVersion",
+      :ssh_pubkey => "PublicSSHKeyValue"
     }.freeze
 
     def managed_systems_uuids
-      xml.get_elements("ManagedSystems/link").map do |link|
-        extract_uuid_from_href(link.attributes["href"])
+      uuids_from_links("ManagedSystems")
+    end
+
+    def ssh_authkeys
+      xml.get_elements("AuthorizedKeysValue/AuthorizedKey").map do |elem|
+        elem.text&.strip
       end.compact
     end
   end
@@ -185,22 +225,50 @@ module IbmPowerHmc
       :avail_cpus => "AssociatedSystemProcessorConfiguration/CurrentAvailableSystemProcessorUnits",
       :mtype => "MachineTypeModelAndSerialNumber/MachineType",
       :model => "MachineTypeModelAndSerialNumber/Model",
-      :serial => "MachineTypeModelAndSerialNumber/SerialNumber"
+      :serial => "MachineTypeModelAndSerialNumber/SerialNumber",
+      :vtpm_version => "AssociatedSystemSecurity/VirtualTrustedPlatformModuleVersion",
+      :vtpm_lpars => "AssociatedSystemSecurity/AvailableVirtualTrustedPlatformModulePartitions"
     }.freeze
 
-    def lpars_uuids
-      xml.get_elements("AssociatedLogicalPartitions/link").map do |link|
-        extract_uuid_from_href(link.attributes["href"])
+    def cpu_compat_modes
+      xml.get_elements("AssociatedSystemProcessorConfiguration/SupportedPartitionProcessorCompatibilityModes").map do |elem|
+        elem.text&.strip
       end.compact
     end
 
+    def lpars_uuids
+      uuids_from_links("AssociatedLogicalPartitions")
+    end
+
     def vioses_uuids
-      xml.get_elements("AssociatedVirtualIOServers/link").map do |link|
-        extract_uuid_from_href(link.attributes["href"])
-      end.compact
+      uuids_from_links("AssociatedVirtualIOServers")
+    end
+
+    def io_adapters
+      collection_of("AssociatedSystemIOConfiguration/IOSlots/IOSlot/RelatedIOAdapter", "IOAdapter")
+    end
+
+    def vswitches_uuids
+      uuids_from_links("AssociatedSystemIOConfiguration/AssociatedSystemVirtualNetwork/VirtualSwitches")
+    end
+
+    def networks_uuids
+      uuids_from_links("AssociatedSystemIOConfiguration/AssociatedSystemVirtualNetwork/VirtualNetworks")
     end
   end
 
+  # I/O Adapter information
+  class IOAdapter < AbstractNonRest
+    ATTRS = {
+      :id => "AdapterID",
+      :description => "Description",
+      :name => "DeviceName",
+      :type => "DeviceType",
+      :dr_name => "DynamicReconfigurationConnectorName",
+      :udid => "UniqueDeviceID"
+    }.freeze
+  end
+
   # Common class for LPAR and VIOS
   class BasePartition < AbstractRest
     ATTRS = {
@@ -220,16 +288,24 @@ module IbmPowerHmc
     }.freeze
 
     def sys_uuid
-      sys_href = singleton("AssociatedManagedSystem", "href")
-      extract_uuid_from_href(sys_href)
+      href = singleton("AssociatedManagedSystem", "href")
+      uuid_from_href(href) unless href.nil?
     end
 
     def net_adap_uuids
-      xml.get_elements("ClientNetworkAdapters/link").map do |link|
-        extract_uuid_from_href(link.attributes["href"])
-      end.compact
+      uuids_from_links("ClientNetworkAdapters")
+    end
+
+    def lhea_ports
+      collection_of("HostEthernetAdapterLogicalPorts", "HostEthernetAdapterLogicalPort")
+    end
+
+    def sriov_elp_uuids
+      uuids_from_links("SRIOVEthernetLogicalPorts")
     end
 
+    # Setters
+
     def name=(name)
       xml.elements[ATTRS[:name]].text = name
       @name = name
@@ -238,17 +314,94 @@ module IbmPowerHmc
 
   # Logical Partition information
   class LogicalPartition < BasePartition
+    def vnic_dedicated_uuids
+      uuids_from_links("DedicatedVirtualNICs")
+    end
+
+    def vscsi_client_uuids
+      uuids_from_links("VirtualSCSIClientAdapters")
+    end
+
+    def vfc_client_uuids
+      uuids_from_links("VirtualFibreChannelClientAdapters")
+    end
   end
 
   # VIOS information
   class VirtualIOServer < BasePartition
+    def pvs
+      collection_of("PhysicalVolumes", "PhysicalVolume")
+    end
+
+    def rep
+      elem = xml.elements["MediaRepositories/VirtualMediaRepository"]
+      VirtualMediaRepository.new(elem) unless elem.nil?
+    end
+
+    def vscsi_mappings
+      collection_of("VirtualSCSIMappings", "VirtualSCSIMapping")
+    end
+
+    def vfc_mappings
+      collection_of("VirtualFibreChannelMappings", "VirtualFibreChannelMapping")
+    end
+  end
+
+  # Empty parent class to match K2 schema definition
+  class VirtualSCSIStorage < AbstractNonRest; end
+
+  # Physical Volume information
+  class PhysicalVolume < VirtualSCSIStorage
+    ATTRS = {
+      :location => "LocationCode",
+      :description => "Description",
+      :is_available => "AvailableForUsage",
+      :capacity => "VolumeCapacity",
+      :name => "VolumeName",
+      :is_fc => "IsFibreChannelBacked",
+      :udid => "VolumeUniqueID"
+    }.freeze
+  end
+
+  # Logical Volume information
+  class VirtualDisk < VirtualSCSIStorage
+    ATTRS = {
+      :name => "DiskName",
+      :label => "DiskLabel",
+      :capacity => "DiskCapacity", # In GiB
+      :psize => "PartitionSize",
+      :vg => "VolumeGroup",
+      :udid => "UniqueDeviceID"
+    }.freeze
+  end
+
+  # Virtual CD-ROM information
+  class VirtualOpticalMedia < VirtualSCSIStorage
+    ATTRS = {
+      :name => "MediaName",
+      :udid => "MediaUDID",
+      :mount_opts => "MountType",
+      :size => "Size" # in GiB
+    }.freeze
+  end
+
+  # Virtual Media Repository information
+  class VirtualMediaRepository < AbstractNonRest
+    ATTRS = {
+      :name => "RepositoryName",
+      :size => "RepositorySize" # in GiB
+    }.freeze
+
+    def vopts
+      collection_of("OpticalMedia", "VirtualOpticalMedia")
+    end
   end
 
   # Virtual Switch information
   class VirtualSwitch < AbstractRest
     ATTRS = {
       :id   => "SwitchID",
-      :mode => "SwitchMode",
+      :mode => "SwitchMode", # "VEB", "VEPA"
       :name => "SwitchName"
     }.freeze
 
@@ -257,9 +410,7 @@ module IbmPowerHmc
     end
 
     def networks_uuids
-      xml.get_elements("VirtualNetworks/link").map do |link|
-        extract_uuid_from_href(link.attributes["href"])
-      end.compact
+      uuids_from_links("VirtualNetworks")
     end
   end
 
@@ -274,13 +425,11 @@ module IbmPowerHmc
 
     def vswitch_uuid
       href = singleton("AssociatedSwitch", "href")
-      extract_uuid_from_href(href)
+      uuid_from_href(href) unless href.nil?
     end
 
     def lpars_uuids
-      xml.get_elements("ConnectedPartitions/link").map do |link|
-        extract_uuid_from_href(link.attributes["href"])
-      end.compact
+      uuids_from_links("ConnectedPartitions")
     end
   end
 
@@ -299,26 +448,380 @@ module IbmPowerHmc
     ATTRS = ATTRS.merge({
       :macaddr    => "MACAddress",
       :vswitch_id => "VirtualSwitchID",
-      :vlan_id    => "PortVLANID"
+      :vlan_id    => "PortVLANID",
+      :location   => "LocationCode"
     }.freeze)
 
     def vswitch_uuid
-      href = singleton("AssociatedVirtualSwitch/link", "href")
-      extract_uuid_from_href(href)
+      uuids_from_links("AssociatedVirtualSwitch").first
     end
   end
 
   # Client Network Adapter information
   class ClientNetworkAdapter < VirtualEthernetAdapter
     def networks_uuids
-      xml.get_elements("VirtualNetworks/link").map do |link|
-        extract_uuid_from_href(link.attributes["href"])
+      uuids_from_links("VirtualNetworks")
+    end
+  end
+
+  # LP-HEA information
+  class EthernetBackingDevice < IOAdapter; end
+  class HostEthernetAdapterLogicalPort < EthernetBackingDevice
+    ATTRS = ATTRS.merge({
+      :macaddr  => "MACAddress",
+      :port_id  => "LogicalPortID",
+      :state    => "PortState",
+      :location => "HEALogicalPortPhysicalLocation"
+    }.freeze)
+  end
+
+  # Virtual NIC dedicated information
+  class VirtualNICDedicated < VirtualIOAdapter
+    ATTRS = ATTRS.merge({
+      :location     => "DynamicReconfigurationConnectorName", # overrides VirtualIOAdapter
+      :macaddr      => "Details/MACAddress",
+      :os_devname   => "Details/OSDeviceName",
+      :port_vlan_id => "Details/PortVLANID"
+    }.freeze)
+  end
+
+  # SR-IOV Configured Logical Port information
+  class SRIOVConfiguredLogicalPort < AbstractRest
+    ATTRS = {
+      :port_id      => "LogicalPortID",
+      :port_vlan_id => "PortVLANID",
+      :location     => "LocationCode",
+      :dr_name      => "DynamicReconfigurationConnectorName",
+      :devname      => "DeviceName",
+      :capacity     => "ConfiguredCapacity"
+    }.freeze
+
+    def lpars_uuids
+      uuids_from_links("AssociatedLogicalPartitions")
+    end
+  end
+
+  # SR-IOV Ethernet Logical Port information
+  class SRIOVEthernetLogicalPort < SRIOVConfiguredLogicalPort
+    ATTRS = ATTRS.merge({
+      :macaddr => "MACAddress"
+    }.freeze)
+  end
+
+  # Virtual SCSI mapping information
+  class VirtualSCSIMapping < AbstractNonRest
+    def lpar_uuid
+      href = singleton("AssociatedLogicalPartition", "href")
+      uuid_from_href(href) unless href.nil?
+    end
+
+    def client
+      elem = xml.elements["ClientAdapter"]
+      VirtualSCSIClientAdapter.new(elem) unless elem.nil?
+    end
+
+    def server
+      elem = xml.elements["ServerAdapter"]
+      VirtualSCSIServerAdapter.new(elem) unless elem.nil?
+    end
+
+    def storage
+      # Possible storage types are:
+      # LogicalUnit, PhysicalVolume, VirtualDisk, VirtualOpticalMedia
+      elem = xml.elements["Storage/*[1]"]
+      Module.const_get("IbmPowerHmc::#{elem.name}").new(elem) unless elem.nil?
+    end
+
+    def device
+      # Possible backing device types are:
+      # LogicalVolumeVirtualTargetDevice, PhysicalVolumeVirtualTargetDevice,
+      # SharedStoragePoolLogicalUnitVirtualTargetDevice, VirtualOpticalTargetDevice
+      elem = xml.elements["TargetDevice/*[1]"]
+      Module.const_get("IbmPowerHmc::#{elem.name}").new(elem) unless elem.nil?
+    end
+  end
+
+  # Virtual SCSI adapter (common class for Client and Server)
+  class VirtualSCSIAdapter < VirtualIOAdapter
+    ATTRS = ATTRS.merge({
+      :name => "AdapterName",
+      :backdev => "BackingDeviceName",
+      :remote_backdev => "RemoteBackingDeviceName",
+      :remote_lpar_id => "RemoteLogicalPartitionID",
+      :remote_slot => "RemoteSlotNumber",
+      :server_location => "ServerLocationCode",
+      :udid => "UniqueDeviceID"
+    }.freeze)
+  end
+
+  # Virtual SCSI client adapter information
+  class VirtualSCSIClientAdapter < VirtualSCSIAdapter
+    def server
+      elem = xml.elements["ServerAdapter"]
+      VirtualSCSIServerAdapter.new(elem) unless elem.nil?
+    end
+
+    def vios_uuid
+      href = singleton("ConnectingPartition", "href")
+      uuid_from_href(href) unless href.nil?
+    end
+  end
+
+  # Virtual SCSI server adapter information
+  class VirtualSCSIServerAdapter < VirtualSCSIAdapter; end
+
+  # Virtual target device information
+  class VirtualTargetDevice < AbstractNonRest
+    ATTRS = {
+      :lun => "LogicalUnitAddress",
+      :parent => "ParentName",
+      :target => "TargetName",
+      :udid => "UniqueDeviceID"
+    }.freeze
+  end
+
+  # LV backing device information
+  class LogicalVolumeVirtualTargetDevice < VirtualTargetDevice; end
+
+  # PV backing device information
+  class PhysicalVolumeVirtualTargetDevice < VirtualTargetDevice; end
+
+  # LU backing device information
+  class SharedStoragePoolLogicalUnitVirtualTargetDevice < VirtualTargetDevice
+    ATTRS = ATTRS.merge({
+      :cluster_id => "ClusterID",
+      :path => "PathName",
+      :raid_level => "RAIDLevel"
+    }.freeze)
+  end
+
+  # Virtual CD backing device information
+  class VirtualOpticalTargetDevice < VirtualTargetDevice
+    def media
+      elem = xml.elements["VirtualOpticalMedia"]
+      VirtualOpticalMedia.new(elem) unless elem.nil?
+    end
+  end
+
+  # VFC mapping information
+  class VirtualFibreChannelMapping < AbstractNonRest
+    def lpar_uuid
+      href = singleton("AssociatedLogicalPartition", "href")
+      uuid_from_href(href) unless href.nil?
+    end
+
+    def client
+      elem = xml.elements["ClientAdapter"]
+      VirtualFibreChannelClientAdapter.new(elem) unless elem.nil?
+    end
+
+    def server
+      elem = xml.elements["ServerAdapter"]
+      VirtualFibreChannelServerAdapter.new(elem) unless elem.nil?
+    end
+
+    def port
+      elem = xml.elements["Port"]
+      PhysicalFibreChannelPort.new(elem) unless elem.nil?
+    end
+  end
+
+  # VFC adapter information
+  class VirtualFibreChannelAdapter < VirtualIOAdapter
+    ATTRS = ATTRS.merge({
+      :name => "AdapterName",
+      :lpar_id => "ConnectingPartitionID",
+      :slot => "ConnectingVirtualSlotNumber",
+      :udid => "UniqueDeviceID"
+    }.freeze)
+
+    def lpar_uuid
+      href = singleton("ConnectingPartition", "href")
+      uuid_from_href(href) unless href.nil?
+    end
+  end
+
+  # VFC client information
+  class VirtualFibreChannelClientAdapter < VirtualFibreChannelAdapter
+    def nport_loggedin
+      collection_of("NportLoggedInStatus", "VirtualFibreChannelNPortLoginStatus")
+    end
+
+    def server
+      elem = xml.elements["ServerAdapter"]
+      VirtualFibreChannelServerAdapter.new(elem) unless elem.nil?
+    end
+
+    def wwpns
+      singleton("WWPNs")&.split
+    end
+
+    def os_disks
+      xml.get_elements("OperatingSystemDisks/OperatingSystemDisk/Name").map do |elem|
+        elem.text&.strip
       end.compact
     end
   end
 
+  # VFC port status
+  class VirtualFibreChannelNPortLoginStatus < AbstractNonRest
+    ATTRS = {
+      :wwpn => "WWPN",
+      :wwpn_status => "WWPNStatus",
+      :loggedin_by => "LoggedInBy",
+      :reason => "StatusReason"
+    }.freeze
+  end
+
+  # VFC server information
+  class VirtualFibreChannelServerAdapter < VirtualFibreChannelAdapter
+    ATTRS = ATTRS.merge({
+      :map_port => "MapPort"
+    }.freeze)
+
+    def port
+      elem = xml.elements["PhysicalPort"]
+      PhysicalFibreChannelPort.new(elem) unless elem.nil?
+    end
+  end
+
+  # FC port information
+  class PhysicalFibreChannelPort < AbstractNonRest
+    ATTRS = {
+      :location => "LocationCode",
+      :name => "PortName",
+      :udid => "UniqueDeviceID",
+      :wwpn => "WWPN",
+      :wwnn => "WWNN",
+      :avail_ports => "AvailablePorts",
+      :total_ports => "TotalPorts"
+    }.freeze
+
+    def pvs
+      collection_of("PhysicalVolumes", "PhysicalVolume")
+    end
+  end
+
+  # Cluster information
+  class Cluster < AbstractRest
+    ATTRS = {
+      :name => "ClusterName",
+      :id => "ClusterID",
+      :tier_capable => "ClusterCapabilities/IsTierCapable"
+    }.freeze
+
+    def repopvs
+      collection_of("RepositoryDisk", "PhysicalVolume")
+    end
+
+    def ssp_uuid
+      href = singleton("ClusterSharedStoragePool", "href")
+      uuid_from_href(href) unless href.nil?
+    end
+
+    def nodes
+      collection_of("Node", "Node")
+    end
+  end
+
+  # Cluster node information
+  class Node < AbstractNonRest
+    ATTRS = {
+      :hostname => "HostName",
+      :lpar_id => "PartitionID",
+      :state => "State",
+      :ioslevel => "VirtualIOServerLevel"
+    }.freeze
+
+    def vios_uuid
+      href = singleton("VirtualIOServer", "href")
+      uuid_from_href(href) unless href.nil?
+    end
+  end
+
+  # SSP information
+  class SharedStoragePool < AbstractRest
+    ATTRS = {
+      :id => "SharedStoragePoolID",
+      :name => "StoragePoolName",
+      :udid => "UniqueDeviceID",
+      :capacity => "Capacity",
+      :free_space => "FreeSpace",
+      :overcommit => "OverCommitSpace",
+      :total_lu_size => "TotalLogicalUnitSize",
+      :alert_threshold => "AlertThreshold"
+    }.freeze
+
+    def cluster_uuid
+      href = singleton("AssociatedCluster", "href")
+      uuid_from_href(href) unless href.nil?
+    end
+
+    def pvs
+      collection_of("PhysicalVolumes", "PhysicalVolume")
+    end
+
+    def tiers_uuids
+      uuids_from_links("AssociatedTiers")
+    end
+
+    def lus
+      collection_of("LogicalUnits", "LogicalUnit")
+    end
+  end
+
+  # SSP tier information
+  class Tier < AbstractRest
+    ATTRS = {
+      :name => "Name",
+      :udid => "UniqueDeviceID",
+      :type => "Type",
+      :capacity => "Capacity",
+      :total_lu_size => "TotalLogicalUnitSize",
+      :is_default => "IsDefault",
+      :free_space => "FreeSpace"
+    }.freeze
+
+    def ssp_uuid
+      href = singleton("AssociatedSharedStoragePool", "href")
+      uuid_from_href(href) unless href.nil?
+    end
+
+    def lus_uuids
+      uuids_from_links("AssociatedLogicalUnits")
+    end
+  end
+
+  # SSP LU information
+  class LogicalUnit < VirtualSCSIStorage
+    ATTRS = {
+      :name => "UnitName",
+      :capacity => "UnitCapacity",
+      :udid => "UniqueDeviceID",
+      :thin => "ThinDevice",
+      :type => "LogicalUnitType",
+      :in_use => "InUse"
+    }.freeze
+  end
+
+  class PartitionTemplateSummary < AbstractRest
+    ATTRS = {
+      :name => "partitionTemplateName"
+    }.freeze
+  end
+
+  class PartitionTemplate < AbstractRest
+    ATTRS = {
+      :name        => "partitionTemplateName",
+      :description => "description",
+      :os          => "logicalPartitionConfig/osVersion",
+      :memory      => "logicalPartitionConfig/memoryConfiguration/currMemory"
+    }.freeze
+  end
+
   # HMC Event
   class Event < AbstractRest
+    attr_accessor :usertask
     ATTRS = {
       :id     => "EventID",
       :type   => "EventType",

data/lib/ibm_power_hmc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IbmPowerHmc
-  VERSION = "0.5.0"
+  VERSION = "0.8.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ibm_power_hmc
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.8.1
 platform: ruby
 authors:
 - IBM Power
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-08 00:00:00.000000000 Z
+date: 2022-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.1'
 description: A Ruby gem for interacting with the IBM Hardware Management Console (HMC).
-email:
+email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -55,7 +55,7 @@ metadata:
   homepage_uri: http://github.com/IBM/ibm_power_hmc_sdk_ruby
   source_code_uri: http://github.com/IBM/ibm_power_hmc_sdk_ruby
   changelog_uri: http://github.com/IBM/ibm_power_hmc_sdk_ruby/blob/master/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -70,8 +70,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key:
+rubygems_version: 3.1.2
+signing_key: 
 specification_version: 4
 summary: IBM Power HMC Ruby gem.
 test_files: []