ibm_power_hmc 0.18.0 → 0.19.0

data/lib/ibm_power_hmc/{parser.rb → schema/uom.rb}

@@ -1,220 +1,6 @@
 # frozen_string_literal: true
 
-require 'time'
-require 'uri'
-
 module IbmPowerHmc
-  ##
-  # Generic parser for HMC K2 XML responses.
-  class Parser
-    def initialize(body)
-      @doc = REXML::Document.new(body)
-    end
-
-    ##
-    # @!method entry
-    # Return the first K2 entry element in the response.
-    # @return [REXML::Element, nil] The first entry element.
-    def entry
-      @doc.elements["entry"]
-    end
-
-    ##
-    # @!method object(filter_type = nil)
-    # Parse the first K2 entry element into an object.
-    # @param filter_type [String] Entry type must match the specified type.
-    # @return [IbmPowerHmc::AbstractRest, nil] The parsed object.
-    def object(filter_type = nil)
-      self.class.to_obj(entry, filter_type)
-    end
-
-    def self.to_obj(entry, filter_type = nil)
-      return if entry.nil?
-
-      content = entry.elements["content[@type]"]
-      return if content.nil?
-
-      type = content.attributes["type"].split("=")[1] || filter_type.to_s
-      return unless filter_type.nil? || filter_type.to_s == type
-
-      Module.const_get("IbmPowerHmc::#{type}").new(entry)
-    end
-  end
-
-  ##
-  # Parser for HMC K2 feeds.
-  # A feed encapsulates a list of entries like this:
-  # <feed>
-  #   <entry>
-  #     <!-- entry #1 -->
-  #   </entry>
-  #   <entry>
-  #     <!-- entry #2 -->
-  #   </entry>
-  #   ...
-  # </feed>
-  class FeedParser < Parser
-    def entries
-      objs = []
-      @doc.each_element("feed/entry") do |entry|
-        objs << yield(entry)
-      end
-      objs
-    end
-
-    ##
-    # @!method objects(filter_type = nil)
-    # Parse feed entries into objects.
-    # @param filter_type [String] Filter entries based on content type.
-    # @return [Array<IbmPowerHmc::AbstractRest>] The list of objects.
-    def objects(filter_type = nil)
-      entries do |entry|
-        self.class.to_obj(entry, filter_type)
-      end.compact
-    end
-  end
-
-  ##
-  # HMC generic K2 non-REST object.
-  # @abstract
-  # @attr_reader [REXML::Document] xml The XML document representing this object.
-  class AbstractNonRest
-    ATTRS = {}.freeze
-    attr_reader :xml
-
-    def initialize(xml)
-      @xml = xml
-      self.class::ATTRS.each { |varname, xpath| define_attr(varname, xpath) }
-    end
-
-    ##
-    # @!method define_attr(varname, xpath)
-    # Define an instance variable using the text of an XML element as value.
-    # @param varname [String] The name of the instance variable.
-    # @param xpath [String] The XPath of the XML element containing the text.
-    def define_attr(varname, xpath)
-      value = singleton(xpath)
-      self.class.__send__(:attr_reader, varname)
-      self.class.__send__(:define_method, "#{varname}=") do |v|
-        if v.nil?
-          xml.elements.delete(xpath)
-        else
-          create_element(xpath) if xml.elements[xpath].nil?
-          xml.elements[xpath].text = v
-        end
-        instance_variable_set("@#{varname}", v)
-      end
-      instance_variable_set("@#{varname}", value)
-    end
-    private :define_attr
-
-    ##
-    # @!method create_element(xpath)
-    # Create a new XML element.
-    # @param xpath [String] The XPath of the XML element to create.
-    def create_element(xpath)
-      cur = xml
-      xpath.split("/").each do |el|
-        p = cur.elements[el]
-        if p.nil?
-          cur = cur.add_element(el)
-        else
-          cur = p
-        end
-      end
-    end
-
-    ##
-    # @!method singleton(xpath, attr = nil)
-    # Get the text (or the value of a specified attribute) of an XML element.
-    # @param xpath [String] The XPath of the XML element.
-    # @param attr [String] The name of the attribute.
-    # @return [String, nil] The text or attribute value of the XML element or nil.
-    # @example lpar.singleton("PartitionProcessorConfiguration/*/MaximumVirtualProcessors").to_i
-    def singleton(xpath, attr = nil)
-      elem = xml.elements[xpath]
-      return if elem.nil?
-
-      attr.nil? ? elem.text&.strip : elem.attributes[attr]
-    end
-
-    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)
-      xml.get_elements([name, type].compact.join("/")).map do |elem|
-        Module.const_get("IbmPowerHmc::#{elem.name}").new(elem)
-      rescue NameError
-        nil
-      end.compact
-    end
-  end
-
-  ##
-  # HMC generic K2 REST object.
-  # Encapsulate data for a single REST object.
-  # The XML looks like this:
-  # <entry>
-  #   <id>uuid</id>
-  #   <published>timestamp</published>
-  #   <link rel="SELF" href="https://..."/>
-  #   <etag:etag>ETag</etag:etag>
-  #   <content type="type">
-  #     <!-- actual content here -->
-  #   </content>
-  # </entry>
-  #
-  # @abstract
-  # @attr_reader [String] uuid The UUID of the object contained in the entry.
-  # @attr_reader [Time] published The time at which the entry was published.
-  # @attr_reader [URI::HTTPS] href The URL of the object itself.
-  # @attr_reader [String] etag The entity tag of the entry.
-  # @attr_reader [String] content_type The content type of the object contained in the entry.
-  class AbstractRest < AbstractNonRest
-    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']"]
-      @href = URI(link.attributes["href"]) unless link.nil?
-      @etag = entry.elements["etag:etag"]&.text&.strip
-      content = entry.elements["content"]
-      @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
   class ManagementConsole < AbstractRest
     ATTRS = {
@@ -240,7 +26,7 @@ module IbmPowerHmc
     }.freeze
 
     def time
-      Time.at(0, singleton("ManagementConsoleTime").to_i, :millisecond).utc
+      timestamp("ManagementConsoleTime")
     end
 
     def managed_systems_uuids
@@ -283,7 +69,7 @@ module IbmPowerHmc
     end
 
     def time
-      Time.at(0, singleton("SystemTime").to_i, :millisecond).utc
+      timestamp("SystemTime")
     end
 
     def capabilities
@@ -352,6 +138,7 @@ module IbmPowerHmc
       :procs => "PartitionProcessorConfiguration/CurrentDedicatedProcessorConfiguration/CurrentProcessors",
       :proc_units => "PartitionProcessorConfiguration/CurrentSharedProcessorConfiguration/CurrentProcessingUnits",
       :vprocs => "PartitionProcessorConfiguration/CurrentSharedProcessorConfiguration/AllocatedVirtualProcessors",
+      :cpu_compat_mode => "CurrentProcessorCompatibilityMode",
       :description => "Description"
     }.freeze
 
@@ -1008,110 +795,6 @@ module IbmPowerHmc
     end
   end
 
-  class PartitionTemplateSummary < AbstractRest
-    ATTRS = {
-      :name => "partitionTemplateName"
-    }.freeze
-  end
-
-  class PartitionTemplate < AbstractRest
-    ATTRS = {
-      :name         => "partitionTemplateName",
-      :description  => "description",
-      :lpar_name    => "logicalPartitionConfig/partitionName",
-      :lpar_type    => "logicalPartitionConfig/partitionType",
-      :lpar_id      => "logicalPartitionConfig/partitionId",
-      :os           => "logicalPartitionConfig/osVersion",
-      :memory       => "logicalPartitionConfig/memoryConfiguration/currMemory",
-      :dedicated    => "logicalPartitionConfig/processorConfiguration/hasDedicatedProcessors",
-      :sharing_mode => "logicalPartitionConfig/processorConfiguration/sharingMode",
-      :vprocs       => "logicalPartitionConfig/processorConfiguration/sharedProcessorConfiguration/desiredVirtualProcessors",
-      :proc_units   => "logicalPartitionConfig/processorConfiguration/sharedProcessorConfiguration/desiredProcessingUnits",
-      :procs        => "logicalPartitionConfig/processorConfiguration/dedicatedProcessorConfiguration/desiredProcessors"
-    }.freeze
-
-    def vscsi
-      REXML::XPath.match(xml, 'logicalPartitionConfig/virtualSCSIClientAdapters/VirtualSCSIClientAdapter').map do |adap|
-        {
-          :vios     => adap.elements['connectingPartitionName']&.text,
-          :physvol  => adap.elements['associatedPhysicalVolume/PhysicalVolume/name']&.text,
-        }
-      end
-    end
-
-    def vscsi=(list = [])
-      adaps = REXML::Element.new('virtualSCSIClientAdapters')
-      adaps.add_attribute('schemaVersion', 'V1_5_0')
-      list.each do |vscsi|
-        adaps.add_element('VirtualSCSIClientAdapter', {'schemaVersion' => 'V1_5_0'}).tap do |v|
-          v.add_element('associatedLogicalUnits', {'schemaVersion' => 'V1_5_0'})
-          v.add_element('associatedPhysicalVolume', {'schemaVersion' => 'V1_5_0'}).tap do |e|
-            e.add_element('PhysicalVolume', {'schemaVersion' => 'V1_5_0'}).add_element('name').text = vscsi[:physvol] if vscsi[:physvol]
-          end
-          v.add_element('connectingPartitionName').text = vscsi[:vios]
-          v.add_element('AssociatedTargetDevices', {'schemaVersion' => 'V1_5_0'})
-          v.add_element('associatedVirtualOpticalMedia', {'schemaVersion' => 'V1_5_0'})
-        end
-      end
-      if xml.elements['logicalPartitionConfig/virtualSCSIClientAdapters']
-        xml.elements['logicalPartitionConfig/virtualSCSIClientAdapters'] = adaps
-      else
-        xml.elements['logicalPartitionConfig'].add_element(adaps)
-      end
-    end
-
-    def vfc
-      REXML::XPath.match(xml, 'logicalPartitionConfig/virtualFibreChannelClientAdapters/VirtualFibreChannelClientAdapter').map do |adap|
-        {
-          :vios => adap.elements['connectingPartitionName']&.text,
-          :port => adap.elements['portName']&.text
-        }
-      end
-    end
-
-    def vfc=(list = [])
-      adaps = REXML::Element.new('virtualFibreChannelClientAdapters')
-      adaps.add_attribute('schemaVersion', 'V1_5_0')
-      list.each do |vfc|
-        adaps.add_element('VirtualFibreChannelClientAdapter', {'schemaVersion' => 'V1_5_0'}).tap do |v|
-          v.add_element('connectingPartitionName').text = vfc[:vios]
-          v.add_element('portName').text                = vfc[:port]
-        end
-      end
-      if xml.elements['logicalPartitionConfig/virtualFibreChannelClientAdapters']
-        xml.elements['logicalPartitionConfig/virtualFibreChannelClientAdapters'] = adaps
-      else
-        xml.elements['logicalPartitionConfig'].add_element(adaps)
-      end
-    end
-
-    def vlans
-      REXML::XPath.match(xml, 'logicalPartitionConfig/clientNetworkAdapters/ClientNetworkAdapter/clientVirtualNetworks/ClientVirtualNetwork').map do |vlan|
-        {
-          :name    => vlan.elements['name']&.text,
-          :vlan_id => vlan.elements['vlanId']&.text,
-          :switch  => vlan.elements['associatedSwitchName']&.text
-        }
-      end
-    end
-
-    def vlans=(list = [])
-      adaps = REXML::Element.new('clientNetworkAdapters')
-      adaps.add_attribute('schemaVersion', 'V1_5_0')
-      list.each do |vlan|
-        adaps.add_element('ClientNetworkAdapter',  {'schemaVersion' => 'V1_5_0'})
-             .add_element('clientVirtualNetworks', {'schemaVersion' => 'V1_5_0'})
-             .add_element('ClientVirtualNetwork',  {'schemaVersion' => 'V1_5_0'})
-             .tap do |v|
-          v.add_element('name').text                 = vlan[:name]
-          v.add_element('vlanId').text               = vlan[:vlan_id]
-          v.add_element('associatedSwitchName').text = vlan[:switch]
-        end
-      end
-      xml.elements['logicalPartitionConfig/clientNetworkAdapters'] = adaps
-    end
-  end
-
   # HMC Event
   class Event < AbstractRest
     attr_accessor :usertask
@@ -1124,16 +807,6 @@ module IbmPowerHmc
     }.freeze
   end
 
-  # Error response from HMC
-  class HttpErrorResponse < AbstractRest
-    ATTRS = {
-      :status  => "HTTPStatus",
-      :uri     => "RequestURI",
-      :reason  => "ReasonCode",
-      :message => "Message"
-    }.freeze
-  end
-
   # Job Response
   class JobResponse < AbstractRest
     ATTRS = {
@@ -1154,32 +827,4 @@ module IbmPowerHmc
       results
     end
   end
-
-  # Performance and Capacity Monitoring preferences
-  class ManagementConsolePcmPreference < AbstractRest
-    ATTRS = {
-      :max_ltm                     => "MaximumManagedSystemsForLongTermMonitor",
-      :max_compute_ltm             => "MaximumManagedSystemsForComputeLTM",
-      :max_aggregation             => "MaximumManagedSystemsForAggregation",
-      :max_stm                     => "MaximumManagedSystemsForShortTermMonitor",
-      :max_em                      => "MaximumManagedSystemsForEnergyMonitor",
-      :aggregated_storage_duration => "AggregatedMetricsStorageDuration"
-    }.freeze
-
-    def managed_system_preferences
-      collection_of(nil, "ManagedSystemPcmPreference")
-    end
-  end
-
-  class ManagedSystemPcmPreference < AbstractNonRest
-    ATTRS = {
-      :id                 => "Metadata/Atom/AtomID",
-      :name               => "SystemName",
-      :long_term_monitor  => "LongTermMonitorEnabled",
-      :aggregation        => "AggregationEnabled",
-      :short_term_monitor => "ShortTermMonitorEnabled",
-      :compute_ltm        => "ComputeLTMEnabled",
-      :energy_monitor     => "EnergyMonitorEnabled"
-    }.freeze
-  end
 end

data/lib/ibm_power_hmc/version.rb

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

data/lib/ibm_power_hmc.rb

@@ -7,8 +7,15 @@ require "ibm_power_hmc/version"
 
 # Module for IBM HMC Rest API Client
 module IbmPowerHmc
-  require_relative "./ibm_power_hmc/parser"
-  require_relative "./ibm_power_hmc/job"
-  require_relative "./ibm_power_hmc/connection"
-  require_relative "./ibm_power_hmc/pcm"
+  require_relative "./ibm_power_hmc/apis/connection"
+  require_relative "./ibm_power_hmc/apis/job"
+  require_relative "./ibm_power_hmc/apis/pcm"
+  require_relative "./ibm_power_hmc/apis/sem"
+  require_relative "./ibm_power_hmc/apis/templates"
+  require_relative "./ibm_power_hmc/apis/uom"
+  require_relative "./ibm_power_hmc/schema/parser"
+  require_relative "./ibm_power_hmc/schema/pcm"
+  require_relative "./ibm_power_hmc/schema/sem"
+  require_relative "./ibm_power_hmc/schema/templates"
+  require_relative "./ibm_power_hmc/schema/uom"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ibm_power_hmc
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - IBM Power
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-17 00:00:00.000000000 Z
+date: 2022-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -56,10 +56,17 @@ files:
 - bin/setup
 - ibm_power_hmc.gemspec
 - lib/ibm_power_hmc.rb
-- lib/ibm_power_hmc/connection.rb
-- lib/ibm_power_hmc/job.rb
-- lib/ibm_power_hmc/parser.rb
-- lib/ibm_power_hmc/pcm.rb
+- lib/ibm_power_hmc/apis/connection.rb
+- lib/ibm_power_hmc/apis/job.rb
+- lib/ibm_power_hmc/apis/pcm.rb
+- lib/ibm_power_hmc/apis/sem.rb
+- lib/ibm_power_hmc/apis/templates.rb
+- lib/ibm_power_hmc/apis/uom.rb
+- lib/ibm_power_hmc/schema/parser.rb
+- lib/ibm_power_hmc/schema/pcm.rb
+- lib/ibm_power_hmc/schema/sem.rb
+- lib/ibm_power_hmc/schema/templates.rb
+- lib/ibm_power_hmc/schema/uom.rb
 - lib/ibm_power_hmc/version.rb
 homepage: http://github.com/IBM/ibm_power_hmc_sdk_ruby
 licenses: