ibm_power_hmc 0.10.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebd50ae53571c98987372d364410261fa5a5440cf23e009c9cf8219eb2e052de
-  data.tar.gz: 7514545bd7a9be7e958597b7fdebc161f9ea253b20550165a798765930b09eec
+  metadata.gz: 3e96072a9ae18c79163e6f52a904e3b4f696f9b5d56729fc92d234a385929269
+  data.tar.gz: 69738a546bff4977e35c4732894a0b1916ec8e0dd49601c7e41d95e793f83ae8
 SHA512:
-  metadata.gz: 41c1fd98ca6750bad69416b3c29986c432c77d8168d72ae485a90a6199b53716dd214c70f74b4c5971e03845d359f847c15a3958a616debd097effcfc0a5567b
-  data.tar.gz: 44f761a7d986716fe2338bceee413785add2fbfdece042022fec02edadcf60d02ea9deb49bad75d0752ea05b64fbe37b36a554d15f7a6e52bb09c62966ab3e9b
+  metadata.gz: cbe96ad163dc152b885638579ca712a47e07716d98485cd3585de86d8b01e8ba961211cc27a0d0d8b0e4273f610b94eab46e114fc98f1049b480ab73a266f0fa
+  data.tar.gz: 94dafbe96f39811e3b1e70eae35fcc22442c05bbe0eae3fbca3e1e5577c35dffeb575bef5ecc87babdd08939904882391f811b5ddd980983ce30679e7f6c7f18

data/lib/ibm_power_hmc/connection.rb

@@ -157,22 +157,61 @@ 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 lpar_migrate_validate(lpar_uuid, target_sys_name, sync = true)
+    # Validate if a logical partition can be migrated to another managed system.
+    # @raise [IbmPowerHmc::JobFailed] if validation fails
+    # @param lpar_uuid [String] The UUID of the logical partition to migrate.
+    # @param target_sys_name [String] The managed system to migrate partition to.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    def lpar_migrate_validate(lpar_uuid, target_sys_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/uom/LogicalPartition/#{lpar_uuid}/do/MigrateValidate"
+      params = {
+        "TargetManagedSystemName" => target_sys_name
+      }
+      HmcJob.new(self, method_url, "MigrateValidate", "LogicalPartition", params).tap do |job|
+        job.run if sync
+      end
+    end
+
+    ##
+    # @!method lpar_migrate(lpar_uuid, target_sys_name, sync = true)
+    # Migrate a logical partition to another managed system.
+    # @param lpar_uuid [String] The UUID of the logical partition to migrate.
+    # @param target_sys_name [String] The managed system to migrate partition to.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    def lpar_migrate(lpar_uuid, target_sys_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/uom/LogicalPartition/#{lpar_uuid}/do/Migrate"
+      params = {
+        "TargetManagedSystemName" => target_sys_name
+      }
+      HmcJob.new(self, method_url, "Migrate", "LogicalPartition", params).tap do |job|
+        job.run if sync
+      end
+    end
+
+    ##
+    # @!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})" }
       else
         method_url = "/rest/api/uom/ManagedSystem/#{sys_uuid}/VirtualIOServer"
       end
+      method_url += "?ignoreError=true" if permissive
       response = request(:get, method_url)
       FeedParser.new(response.body).objects(:VirtualIOServer)
     end
@@ -312,6 +351,42 @@ module IbmPowerHmc
       end
     end
 
+    ##
+    # @!method vscsi_client_adapter(lpar_uuid, adap_uuid = nil)
+    # Retrieve one or all virtual SCSI storage client adapters attached to a logical partition.
+    # @param lpar_uuid [String] UUID of the logical partition.
+    # @param adap_uuid [String] UUID of the adapter to match (returns all adapters if omitted).
+    # @return [Array<IbmPowerHmc::VirtualSCSIClientAdapter>, IbmPowerHmc::VirtualSCSIClientAdapter] The list of storage adapters.
+    def vscsi_client_adapter(lpar_uuid, adap_uuid = nil)
+      if adap_uuid.nil?
+        method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/VirtualSCSIClientAdapter"
+        response = request(:get, method_url)
+        FeedParser.new(response.body).objects(:VirtualSCSIClientAdapter)
+      else
+        method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/VirtualSCSIClientAdapter/#{adap_uuid}"
+        response = request(:get, method_url)
+        Parser.new(response.body).object(:VirtualSCSIClientAdapter)
+      end
+    end
+
+    ##
+    # @!method vfc_client_adapter(lpar_uuid, adap_uuid = nil)
+    # Retrieve one or all virtual Fibre Channel storage client adapters attached to a logical partition.
+    # @param lpar_uuid [String] UUID of the logical partition.
+    # @param adap_uuid [String] UUID of the adapter to match (returns all adapters if omitted).
+    # @return [Array<IbmPowerHmc::VirtualFibreChannelClientAdapter>, IbmPowerHmc::VirtualFibreChannelClientAdapter] The list of storage adapters.
+    def vfc_client_adapter(lpar_uuid, adap_uuid = nil)
+      if adap_uuid.nil?
+        method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/VirtualFibreChannelClientAdapter"
+        response = request(:get, method_url)
+        FeedParser.new(response.body).objects(:VirtualFibreChannelClientAdapter)
+      else
+        method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/VirtualFibreChannelClientAdapter/#{adap_uuid}"
+        response = request(:get, method_url)
+        Parser.new(response.body).object(:VirtualFibreChannelClientAdapter)
+      end
+    end
+
     ##
     # @!method clusters
     # Retrieve the list of clusters managed by the HMC.
@@ -386,21 +461,41 @@ module IbmPowerHmc
     end
 
     ##
-    # @!method templates_summary
+    # @!method shared_processor_pool(sys_uuid, pool_uuid = nil)
+    # Retrieve information about Shared Processor Pools.
+    # @param sys_uuid [String] The UUID of the managed system.
+    # @param pool_uuid [String] The UUID of the shared storage pool (return all pools if omitted)
+    # @return [Array<IbmPowerHmc::SharedProcessorPool>, IbmPowerHmc::SharedProcessorPool] The list of shared processor pools.
+    def shared_processor_pool(sys_uuid, pool_uuid = nil)
+      if pool_uuid.nil?
+        method_url = "/rest/api/uom/ManagedSystem/#{sys_uuid}/SharedProcessorPool"
+        response = request(:get, method_url)
+        FeedParser.new(response.body).objects(:SharedProcessorPool)
+      else
+        method_url = "/rest/api/uom/ManagedSystem/#{sys_uuid}/SharedProcessorPool/#{pool_uuid}"
+        response = request(:get, method_url)
+        Parser.new(response.body).object(:SharedProcessorPool)
+      end
+    end
+
+    ##
+    # @!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 +534,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 +820,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 +861,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 +895,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

@@ -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.
@@ -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"
@@ -872,6 +896,22 @@ module IbmPowerHmc
     }.freeze
   end
 
+  # Shared Processor Pool
+  class SharedProcessorPool < AbstractRest
+    ATTRS = {
+      :name => "PoolName",
+      :available => "AvailableProcUnits",
+      :max => "MaximumProcessingUnits",
+      :reserved => "CurrentReservedProcessingUnits",
+      :pending_reserved => "PendingReservedProcessingUnits",
+      :pool_id => "PoolID"
+    }.freeze
+
+    def lpar_uuids
+      uuids_from_links("AssignedPartitions")
+    end
+  end
+
   class PartitionTemplateSummary < AbstractRest
     ATTRS = {
       :name => "partitionTemplateName"
@@ -882,6 +922,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 +932,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 +1040,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
@@ -933,6 +1058,7 @@ module IbmPowerHmc
     end
   end
 
+  # Performance and Capacity Monitoring preferences
   class ManagementConsolePcmPreference < AbstractRest
     ATTRS = {
       :max_ltm                     => "MaximumManagedSystemsForLongTermMonitor",

data/lib/ibm_power_hmc/pcm.rb

@@ -17,7 +17,7 @@ module IbmPowerHmc
     end
 
     ##
-    # @!method managed_system_pcm_preferences
+    # @!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.

data/lib/ibm_power_hmc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ibm_power_hmc
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.13.0
 platform: ruby
 authors:
 - IBM Power
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-20 00:00:00.000000000 Z
+date: 2022-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.3'
 description: A Ruby gem for interacting with the IBM Hardware Management Console (HMC).
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -69,7 +69,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
@@ -84,8 +84,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: IBM Power HMC Ruby gem.
 test_files: []