ibm_power_hmc 0.9.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49b7980e12490365221b3fcc8dcb6a867078dc62f44cd1f0646c75d5d1c7c8cc
-  data.tar.gz: a2f7776c0039c188685e84b72c1a5217cda5252cea0d7d4e142ac734ad32305a
+  metadata.gz: e162db8e4002c4b1fbee71faceaa8c4a859f5e7e92e33e4cbbdb59862da9cde6
+  data.tar.gz: 97bc18d7e606bddd79f6ed83b9f2f5b562f5121c433d613085e7da5e695f71df
 SHA512:
-  metadata.gz: f3bf7576a9eda74a292c74c088c8ed3e88fdde40d94472980600d561563e5998415da26815bfd4d78bf3faade900b22a5a142c67a42e600e7b9c530d8a67e7f8
-  data.tar.gz: ec3563218f5a20515179073d391a5bb54bc32f361c63eab190193462b3560185354bc2cc9ff73cb78023ece6ca4550d9584abcfabc0a1a2fac2998a63ff8b820
+  metadata.gz: 3a36c85b010b6e67bd91e67fa380c4edb6cc27a34aee732237b5c95eaee2f6a983ee1c461bc6ab5830d4952743360f848a1228f85121f9ac8cf150b194440dac
+  data.tar.gz: 741c9dedab5f6bd5fd7af0038e8bdab555c6b71274f3cecded7aaf4cabb21371b744e3fd355140e61bc9c7a36128a473a81fffd6983662d2def0c0e22ac1fcc5

data/lib/ibm_power_hmc/connection.rb

@@ -157,19 +157,21 @@ module IbmPowerHmc
     # @param new_name [String] The new name of the logical partition.
     def rename_lpar(lpar_uuid, new_name)
       method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}"
-      modify_object(method_url) { |lpar| lpar.name = new_name }
+      modify_object_attributes(method_url, {:name => new_name})
     end
 
     ##
-    # @!method vioses(sys_uuid = nil, search = {})
+    # @!method vioses(sys_uuid = nil, search = {}, permissive = true)
     # Retrieve the list of virtual I/O servers managed by the HMC.
     # @param sys_uuid [String] The UUID of the managed system.
     # @param search [Hash] The optional property name and value to match.
+    # @param permissive [Boolean] Skip virtual I/O servers that have error conditions.
     # @return [Array<IbmPowerHmc::VirtualIOServer>] The list of virtual I/O servers.
-    def vioses(sys_uuid = nil, search = {})
+    def vioses(sys_uuid = nil, search = {}, permissive = true)
       if sys_uuid.nil?
         method_url = "/rest/api/uom/VirtualIOServer"
         search.each { |key, value| method_url += "/search/(#{key}==#{value})" }
+        method_url += "?ignoreError=true" if permissive
       else
         method_url = "/rest/api/uom/ManagedSystem/#{sys_uuid}/VirtualIOServer"
       end
@@ -386,21 +388,23 @@ module IbmPowerHmc
     end
 
     ##
-    # @!method templates_summary
+    # @!method templates_summary(draft = false)
     # Retrieve the list of partition template summaries.
+    # @param draft [Boolean] Retrieve draft templates as well
     # @return [Array<IbmPowerHmc::PartitionTemplateSummary>] The list of partition template summaries.
-    def templates_summary
-      method_url = "/rest/api/templates/PartitionTemplate"
+    def templates_summary(draft = false)
+      method_url = "/rest/api/templates/PartitionTemplate#{'?draft=false' unless draft}"
       response = request(:get, method_url)
       FeedParser.new(response.body).objects(:PartitionTemplateSummary)
     end
 
     ##
-    # @!method templates
+    # @!method templates(draft = false)
     # Retrieve the list of partition templates.
+    # @param draft [Boolean] Retrieve draft templates as well
     # @return [Array<IbmPowerHmc::PartitionTemplate>] The list of partition templates.
-    def templates
-      method_url = "/rest/api/templates/PartitionTemplate?detail=full"
+    def templates(draft = false)
+      method_url = "/rest/api/templates/PartitionTemplate?detail=full#{'&draft=false' unless draft}"
       response = request(:get, method_url)
       FeedParser.new(response.body).objects(:PartitionTemplate)
     end
@@ -439,6 +443,109 @@ module IbmPowerHmc
       job
     end
 
+    ##
+    # @!method template_check(template_uuid, target_sys_uuid, sync = true)
+    # Start Template Check job (first of three steps to deploy an LPAR from a Template).
+    # @param template_uuid [String] The UUID of the Template to deploy an LPAR from.
+    # @param target_sys_uuid [String] The UUID of the Managed System to deploy the LPAR on.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def template_check(template_uuid, target_sys_uuid, 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/#{template_uuid}/do/check"
+      params = {
+        "TargetUuid"              => target_sys_uuid,
+        "K_X_API_SESSION_MEMENTO" => @api_session_token
+      }
+      job = HmcJob.new(self, method_url, "Check", "PartitionTemplate", params)
+      job.run if sync
+      job
+    end
+
+    ##
+    # @!method template_transform(draft_template_uuid, target_sys_uuid, sync = true)
+    # Start Template Transform job (second of three steps to deploy an LPAR from a Template).
+    # @param draft_template_uuid [String] The UUID of the Draft Template created by the Template Check job.
+    # @param target_sys_uuid [String] The UUID of the Managed System to deploy the LPAR on.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def template_transform(draft_template_uuid, target_sys_uuid, 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/#{draft_template_uuid}/do/transform"
+      params = {
+        "TargetUuid"              => target_sys_uuid,
+        "K_X_API_SESSION_MEMENTO" => @api_session_token
+      }
+      job = HmcJob.new(self, method_url, "Transform", "PartitionTemplate", params)
+      job.run if sync
+      job
+    end
+
+    ##
+    # @!method template_deploy(draft_template_uuid, target_sys_uuid, sync = true)
+    # Start Template Deploy job (last of three steps to deploy an LPAR from a Template).
+    # @param draft_template_uuid [String] The UUID of the Draft Template created by the Template Check job.
+    # @param target_sys_uuid [String] The UUID of the Managed System to deploy the LPAR on.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def template_deploy(draft_template_uuid, target_sys_uuid, 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/#{draft_template_uuid}/do/deploy"
+      params = {
+        "TargetUuid"              => target_sys_uuid,
+        "TemplateUuid"            => draft_template_uuid,
+        "K_X_API_SESSION_MEMENTO" => @api_session_token
+      }
+      job = HmcJob.new(self, method_url, "Deploy", "PartitionTemplate", params)
+      job.run if sync
+      job
+    end
+
+    ##
+    # @!method template_provision(template_uuid, target_sys_uuid, changes)
+    # Deploy Logical Partition from a Template (performs Check, Transform and Deploy steps in a single method).
+    # @param template_uuid [String] The UUID of the Template to deploy an LPAR from.
+    # @param target_sys_uuid [String] The UUID of the Managed System to deploy the LPAR on.
+    # @param changes [Hash] Modifications to apply to the Template before deploying Logical Partition.
+    # @return [String] The UUID of the deployed Logical Partition.
+    def template_provision(template_uuid, target_sys_uuid, changes)
+      draft_uuid = template_check(template_uuid, target_sys_uuid).results["TEMPLATE_UUID"]
+      template_transform(draft_uuid, target_sys_uuid)
+      template_modify(draft_uuid, changes)
+      template_deploy(draft_uuid, target_sys_uuid).results["PartitionUuid"]
+    end
+
+    ##
+    # @!method template(template_uuid, changes)
+    # modify_object_attributes wrapper for templates.
+    # @param template_uuid [String] UUID of the partition template to modify.
+    # @param changes [Hash] Hash of changes to make.
+    # @return [IbmPowerHmc::PartitionTemplate] The partition template.
+    def template_modify(template_uuid, changes)
+      method_url = "/rest/api/templates/PartitionTemplate/#{template_uuid}"
+      modify_object_attributes(method_url, changes)
+    end
+
+    ##
+    # @!method template_copy(template_uuid, new_name)
+    # Copy existing template to a new one.
+    # @param template_uuid [String] UUID of the partition template to copy.
+    # @param new_name [String] Name of the new template.
+    # @return [IbmPowerHmc::PartitionTemplate] The new partition template.
+    def template_copy(template_uuid, new_name)
+      method_url = "/rest/api/templates/PartitionTemplate"
+      headers = {
+        :content_type => "application/vnd.ibm.powervm.templates+xml;type=PartitionTemplate"
+      }
+      original = template(template_uuid)
+      original.name = new_name
+      response = request(:put, method_url, headers, original.xml.to_s)
+      Parser.new(response.body).object(:PartitionTemplate)
+    end
+
     ##
     # @!method poweron_lpar(lpar_uuid, params = {}, sync = true)
     # Power on a logical partition.
@@ -622,13 +729,15 @@ module IbmPowerHmc
         @status = err.http_code
         @message = err.message
 
-        # Try to parse body as an HttpErrorResponse
+        # Try to parse body as an HttpErrorResponse.
         unless err.response.nil?
-          resp = Parser.new(err.response.body).object(:HttpErrorResponse) rescue nil
-          unless resp.nil?
+          begin
+            resp = Parser.new(err.response.body).object(:HttpErrorResponse)
             @uri = resp.uri
             @reason = resp.reason
             @message = resp.message
+          rescue
+            # not an XML body
           end
         end
       end
@@ -661,9 +770,9 @@ module IbmPowerHmc
           :headers => headers
         )
       rescue RestClient::Exception => e
-        # Do not retry on failed logon attempts
+        # Do not retry on failed logon attempts.
         if e.http_code == 401 && @api_session_token != "" && !reauth
-          # Try to reauth
+          # Try to reauth.
           reauth = true
           logon
           retry
@@ -695,12 +804,26 @@ module IbmPowerHmc
           break
         rescue HttpError => e
           attempts -= 1
-          # Will get 412 ("Precondition Failed") if ETag mismatches
+          # Will get 412 ("Precondition Failed") if ETag mismatches.
           raise if e.status != 412 || attempts == 0
         end
       end
     end
 
+    # @!method modify_object_attributes(method_url, changes, headers = {}, attempts = 5)
+    # Modify an object at a specified URI.
+    # @param method_url [String] The URL of the object to modify.
+    # @param changes [Hash] Hash of changes to make. Key is the attribute modify/create (as defined in the AbstractNonRest subclass). A value of nil removes the attribute.
+    # @param headers [Hash] HTTP headers.
+    # @param attempts [Integer] Maximum number of retries.
+    def modify_object_attributes(method_url, changes, headers = {}, attempts = 5)
+      modify_object(method_url, headers, attempts) do |obj|
+        changes.each do |key, value|
+          obj.send("#{key}=", value)
+        end
+      end
+    end
+
     ##
     # @!method network_adapter(vm_type, lpar_uuid, netadap_uuid)
     # Retrieve one or all virtual ethernet network adapters attached to a Logical Partition or a Virtual I/O Server.

data/lib/ibm_power_hmc/job.rb

@@ -6,6 +6,17 @@ module IbmPowerHmc
   class HmcJob
     class JobNotStarted < StandardError; end
 
+    class JobFailed < StandardError
+      def initialize(job)
+        super
+        @job = job
+      end
+
+      def to_s
+        "id=\"#{@job.id}\" operation=\"#{@job.group}/#{@job.operation}\" status=\"#{@job.status}\" message=\"#{@job.message}\" exception_text=\"#{@job.results['ExceptionText']}\""
+      end
+    end
+
     ##
     # @!method initialize(conn, method_url, operation, group, params = {})
     # Construct a new HMC Job.
@@ -52,7 +63,7 @@ module IbmPowerHmc
     end
 
     # @return [Hash] The job results returned by the HMC.
-    attr_reader :results
+    attr_reader :results, :last_status
 
     ##
     # @!method status
@@ -65,9 +76,9 @@ module IbmPowerHmc
         :content_type => "application/vnd.ibm.powervm.web+xml; type=JobRequest"
       }
       response = @conn.request(:get, @href, headers)
-      jobresp = Parser.new(response.body).object(:JobResponse)
-      @results = jobresp.results
-      jobresp.status
+      @last_status = Parser.new(response.body).object(:JobResponse)
+      @results = @last_status.results
+      @last_status.status
     end
 
     ##
@@ -99,6 +110,7 @@ module IbmPowerHmc
     def run(timeout = 120, poll_interval = 0)
       start
       wait(timeout, poll_interval)
+      raise JobFailed.new(@last_status), "Job failed" unless @last_status.status.eql?("COMPLETED_OK")
     ensure
       delete if defined?(@href)
     end

data/lib/ibm_power_hmc/parser.rb

@@ -34,7 +34,7 @@ module IbmPowerHmc
       content = entry.elements["content[@type]"]
       return if content.nil?
 
-      type = content.attributes["type"].split("=").last
+      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)
@@ -95,10 +95,35 @@ module IbmPowerHmc
     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.
@@ -135,7 +160,7 @@ module IbmPowerHmc
 
     def collection_of(name, type)
       objtype = Module.const_get("IbmPowerHmc::#{type}")
-      xml.get_elements("#{name}/#{type}").map do |elem|
+      xml.get_elements([name, type].compact.join("/")).map do |elem|
         objtype.new(elem)
       end
     rescue
@@ -198,9 +223,15 @@ module IbmPowerHmc
       :build_level => "VersionInfo/BuildLevel",
       :version => "BaseVersion",
       :ssh_pubkey => "PublicSSHKeyValue",
-      :uvmid => "UVMID"
+      :uvmid => "UVMID",
+      :tz => "CurrentTimezone",
+      :uptime => "ManagementConsoleUpTime"
     }.freeze
 
+    def time
+      Time.at(0, singleton("ManagementConsoleTime").to_i, :millisecond).utc
+    end
+
     def managed_systems_uuids
       uuids_from_links("ManagedSystems")
     end
@@ -327,13 +358,6 @@ module IbmPowerHmc
     def sriov_elp_uuids
       uuids_from_links("SRIOVEthernetLogicalPorts")
     end
-
-    # Setters
-
-    def name=(name)
-      xml.elements[ATTRS[:name]].text = name
-      @name = name
-    end
   end
 
   # Logical Partition information
@@ -401,7 +425,7 @@ module IbmPowerHmc
       :location => "LocationCode",
       :description => "Description",
       :is_available => "AvailableForUsage",
-      :capacity => "VolumeCapacity",
+      :capacity => "VolumeCapacity", # in MiB
       :name => "VolumeName",
       :is_fc => "IsFibreChannelBacked",
       :udid => "VolumeUniqueID"
@@ -413,7 +437,7 @@ module IbmPowerHmc
     ATTRS = {
       :name => "DiskName",
       :label => "DiskLabel",
-      :capacity => "DiskCapacity", # In GiB
+      :capacity => "DiskCapacity", # in GiB
       :psize => "PartitionSize",
       :vg => "VolumeGroup",
       :udid => "UniqueDeviceID"
@@ -882,6 +906,8 @@ module IbmPowerHmc
     ATTRS = {
       :name         => "partitionTemplateName",
       :description  => "description",
+      :lpar_name    => "logicalPartitionConfig/partitionName",
+      :lpar_id      => "logicalPartitionConfig/partitionId",
       :os           => "logicalPartitionConfig/osVersion",
       :memory       => "logicalPartitionConfig/memoryConfiguration/currMemory",
       :dedicated    => "logicalPartitionConfig/processorConfiguration/hasDedicatedProcessors",
@@ -890,6 +916,87 @@ module IbmPowerHmc
       :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
@@ -917,9 +1024,11 @@ module IbmPowerHmc
   # Job Response
   class JobResponse < AbstractRest
     ATTRS = {
-      :id      => "JobID",
-      :status  => "Status",
-      :message => "ResponseException/Message"
+      :id        => "JobID",
+      :status    => "Status",
+      :operation => "JobRequestInstance/RequestedOperation/OperationName",
+      :group     => "JobRequestInstance/RequestedOperation/GroupName",
+      :message   => "ResponseException/Message"
     }.freeze
 
     def results
@@ -932,4 +1041,32 @@ 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/pcm.rb

@@ -5,11 +5,24 @@ require 'uri'
 
 module IbmPowerHmc
   class Connection
+    ##
+    # @!method pcm_preferences
+    # Retrieve global Performance and Capacity Monitor preferences for the HMC.
+    # @return [Array<IbmPowerHmc::ManagementConsolePcmPreference>] The PCM preferences for the HMC.
     def pcm_preferences
       method_url = "/rest/api/pcm/preferences"
 
       response = request(:get, method_url)
-      REXML::Document.new(response.body)
+      FeedParser.new(response.body).objects(:ManagementConsolePcmPreference)
+    end
+
+    ##
+    # @!method managed_system_pcm_preferences(sys_uuid)
+    # Return Performance and Capacity Monitor preferences for a Managed System.
+    # @param sys_uuid [String] The managed system UUID.
+    # @return [IbmPowerHmc::ManagedSystemPcmPreference] The PCM preferences for the Managed System.
+    def managed_system_pcm_preferences(sys_uuid)
+      pcm_preferences.first.managed_system_preferences.find { |p| p.id.eql?(sys_uuid) }
     end
 
     ##

data/lib/ibm_power_hmc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ibm_power_hmc
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.12.0
 platform: ruby
 authors:
 - IBM Power
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-08 00:00:00.000000000 Z
+date: 2022-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -84,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: IBM Power HMC Ruby gem.