ibm_power_hmc 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 397feab84db9812185ab1125cd6778b52a1848519d6bae5950d69cb31e9b4845
-  data.tar.gz: 27dd4d94cd61a19c66d0d6e438c17987ea5926af78b7677b5044a11a50acdb18
+  metadata.gz: 214dfa7f9a89d236f1f9bc4ee927b619596a0fabe59c2f596359637e891601ab
+  data.tar.gz: 2affd160febc3952014ab522bb9b0f89b0ebef6d785720d2d8d2a875cd1df918
 SHA512:
-  metadata.gz: 1171816de48bed97b1837ab39d3bd639772928ebee98fb8f287c85006196bdf068320599b921a239d10d5ce74e98629cde754eca14b12c6cf6be85477e7a7fb3
-  data.tar.gz: 10f7397e58acab288715283de98480caf915fb628021b2f8c5261b13b2c7b273cdec5e1d7a52b35560acbe5cae6dfed5c9e68516673d97ff5f91a9fb44daa370
+  metadata.gz: 3e6e6ae8b4c7d84eea70e3328ea44834a5b95ecd98fbe6a31c045e575951b6c17751ca7d6517d3ad58647b5c8b7e1321470c368c48018c31a450a28ba40463e5
+  data.tar.gz: f9139f2ea1a83d0abedc3c73832450e20fa4fcf7c56cc65c50ec5b14750bb5bb2eb17d7948ffc22d5887984d0f412ae8213a237892350e55f0cd55a49af80f30

data/.rubocop.yml

@@ -0,0 +1,4 @@
+inherit_gem:
+  manageiq-style: ".rubocop_base.yml"
+inherit_from:
+- ".rubocop_local.yml"

data/.rubocop_local.yml

@@ -0,0 +1,7 @@
+AllCops:
+  Exclude:
+  - '*.gemspec'
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: key
+Style/ConditionalAssignment:
+  EnforcedStyle: assign_inside_condition

data/lib/ibm_power_hmc/connection.rb

@@ -2,8 +2,22 @@
 
 # Module for IBM HMC Rest API Client
 module IbmPowerHmc
-  # HMC REST Client connection
+  require_relative 'pcm.rb'
+
+  class Error < StandardError; end
+
+  ##
+  # HMC REST Client connection.
   class Connection
+    ##
+    # @!method initialize(host:, username: "hscroot", password:, port: 12_443, validate_ssl: true)
+    # Create a new HMC connection.
+    #
+    # @param host [String] Hostname of the HMC.
+    # @param username [String] User name.
+    # @param password [String] Password.
+    # @param port [Integer] TCP port number.
+    # @param validate_ssl [Boolean] Verify SSL certificates.
     def initialize(host:, username: "hscroot", password:, port: 12_443, validate_ssl: true)
       # Damien: use URI::HTTPS
       @hostname = "#{host}:#{port}"
@@ -13,10 +27,14 @@ module IbmPowerHmc
       @api_session_token = nil
     end
 
+    ##
+    # @!method logon
+    # Establish a trusted session with the Web Services APIs.
+    # @return [String] The X-API-Session token.
     def logon
       method_url = "/rest/api/web/Logon"
       headers = {
-        content_type: "application/vnd.ibm.powervm.web+xml; type=LogonRequest"
+        :content_type => "application/vnd.ibm.powervm.web+xml; type=LogonRequest"
       }
       doc = REXML::Document.new("")
       doc.add_element("LogonRequest", {
@@ -26,41 +44,84 @@ module IbmPowerHmc
       doc.root.add_element("UserID").text = @username
       doc.root.add_element("Password").text = @password
 
-      # Damien: begin/rescue
       @api_session_token = ""
       response = request(:put, method_url, headers, doc.to_s)
       doc = REXML::Document.new(response.body)
-      @api_session_token = doc.root.elements["X-API-Session"].text
+      elem = doc.elements["LogonResponse/X-API-Session"]
+      raise Error, "LogonResponse/X-API-Session not found" if elem.nil?
+
+      @api_session_token = elem.text
     end
 
+    ##
+    # @!method logoff
+    # Close the session.
     def logoff
+      # Don't want to trigger automatic logon here!
+      return if @api_session_token.nil?
+
       method_url = "/rest/api/web/Logon"
-      request(:delete, method_url)
+      begin
+        request(:delete, method_url)
+      rescue
+        # Ignore exceptions as this is best effort attempt to log off.
+      end
       @api_session_token = nil
     end
 
+    def parse_feed(doc, myclass)
+      objs = []
+      doc.each_element("feed/entry") do |entry|
+        objs << myclass.new(entry)
+      end
+      objs
+    end
+    private :parse_feed
+
+    ##
+    # @!method management_console
+    # Retrieve information about the management console.
+    # @return [IbmPowerHmc::ManagementConsole] The management console.
     def management_console
       method_url = "/rest/api/uom/ManagementConsole"
       response = request(:get, method_url)
       doc = REXML::Document.new(response.body)
-      entry = doc.root.elements["entry"]
-      ManagementConsole.new(entry)
+      # This request returns a feed with a single entry.
+      parse_feed(doc, ManagementConsole).first
     end
 
+    ##
+    # @!method managed_systems
+    # Retrieve the list of systems managed by the HMC.
+    # @return [Array<IbmPowerHmc::ManagedSystem>] The list of managed systems.
     def managed_systems
       method_url = "/rest/api/uom/ManagedSystem"
       response = request(:get, method_url)
       doc = REXML::Document.new(response.body)
-      systems = []
-      return systems if doc.root.nil?
+      parse_feed(doc, ManagedSystem)
+    end
 
-      doc.root.each_element("entry") do |entry|
-        system = ManagedSystem.new(entry)
-        systems += [system]
-      end
-      systems
+    ##
+    # @!method managed_system(lpar_uuid, sys_uuid = nil, group_name = nil)
+    # Retrieve information about a managed system.
+    # @param sys_uuid [String] The UUID of the managed system.
+    # @param group_name [String] The extended group attributes.
+    # @return [IbmPowerHmc::ManagedSystem] The logical partition.
+    def managed_system(sys_uuid, group_name = nil)
+      method_url = "/rest/api/uom/ManagedSystem/#{sys_uuid}"
+      method_url += "?group=#{group_name}" unless group_name.nil?
+
+      response = request(:get, method_url)
+      doc = REXML::Document.new(response.body)
+      entry = doc.elements["entry"]
+      ManagedSystem.new(entry)
     end
 
+    ##
+    # @!method lpars(sys_uuid = nil)
+    # Retrieve the list of logical partitions managed by the HMC.
+    # @param sys_uuid [String] The UUID of the managed system.
+    # @return [Array<IbmPowerHmc::LogicalPartition>] The list of logical partitions.
     def lpars(sys_uuid = nil)
       if sys_uuid.nil?
         method_url = "/rest/api/uom/LogicalPartition"
@@ -69,16 +130,16 @@ module IbmPowerHmc
       end
       response = request(:get, method_url)
       doc = REXML::Document.new(response.body)
-      lpars = []
-      return lpars if doc.root.nil?
-
-      doc.root.each_element("entry") do |entry|
-        lpar = LogicalPartition.new(entry)
-        lpars += [lpar]
-      end
-      lpars
+      parse_feed(doc, LogicalPartition)
     end
 
+    ##
+    # @!method lpar(lpar_uuid, sys_uuid = nil, group_name = nil)
+    # Retrieve information about a logical partition.
+    # @param lpar_uuid [String] The UUID of the logical partition.
+    # @param sys_uuid [String] The UUID of the managed system.
+    # @param group_name [String] The extended group attributes.
+    # @return [IbmPowerHmc::LogicalPartition] The logical partition.
     def lpar(lpar_uuid, sys_uuid = nil, group_name = nil)
       if sys_uuid.nil?
         method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}"
@@ -93,6 +154,11 @@ module IbmPowerHmc
       LogicalPartition.new(entry)
     end
 
+    ##
+    # @!method lpar_quick_property(lpar_uuid, property_name)
+    # Retrieve a quick property of a logical partition.
+    # @param lpar_uuid [String] The UUID of the logical partition.
+    # @return [String] The quick property value.
     def lpar_quick_property(lpar_uuid, property_name)
       method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/quick/#{property_name}"
 
@@ -100,141 +166,223 @@ module IbmPowerHmc
       response.body[1..-2]
     end
 
+    ##
+    # @!method vioses(sys_uuid = nil)
+    # Retrieve the list of virtual I/O servers managed by the HMC.
+    # @param sys_uuid [String] The UUID of the managed system.
+    # @return [Array<IbmPowerHmc::VirtualIOServer>] The list of virtual I/O servers.
     def vioses(sys_uuid = nil)
       if sys_uuid.nil?
         method_url = "/rest/api/uom/VirtualIOServer"
       else
         method_url = "/rest/api/uom/ManagedSystem/#{sys_uuid}/VirtualIOServer"
       end
-      begin
-        response = request(:get, method_url)
-      rescue StandardError
-        return []
-      end
+      response = request(:get, method_url)
       doc = REXML::Document.new(response.body)
-      vioses = []
-      return vioses if doc.root.nil?
-
-      doc.root.each_element("entry") do |entry|
-        vios = VirtualIOServer.new(entry)
-        vioses += [vios]
-      end
-      vioses
+      parse_feed(doc, VirtualIOServer)
     end
 
-    # Damien: share the same method for VIOS and LPAR?
-    def lpar_profiles(lpar_uuid)
-      method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/LogicalPartitionProfile"
-      begin
-        response = request(:get, method_url)
-      rescue StandardError
-        return []
+    ##
+    # @!method vios(vios_uuid, sys_uuid = nil, group_name = nil)
+    # Retrieve information about a virtual I/O server.
+    # @param vios_uuid [String] The UUID of the virtual I/O server.
+    # @param sys_uuid [String] The UUID of the managed system.
+    # @param group_name [String] The extended group attributes.
+    # @return [IbmPowerHmc::VirtualIOServer] The virtual I/O server.
+    def vios(vios_uuid, sys_uuid = nil, group_name = nil)
+      if sys_uuid.nil?
+        method_url = "/rest/api/uom/VirtualIOServer/#{vios_uuid}"
+      else
+        method_url = "/rest/api/uom/ManagedSystem/#{sys_uuid}/VirtualIOServer/#{vios_uuid}"
       end
-      doc = REXML::Document.new(response.body)
-      profiles = []
-      return profiles if doc.root.nil?
+      method_url += "?group=#{group_name}" unless group_name.nil?
 
-      doc.root.each_element("entry") do |entry|
-        profile = LogicalPartitionProfile.new(lpar_uuid, entry)
-        profiles += [profile]
-      end
-      profiles
+      response = request(:get, method_url)
+      doc = REXML::Document.new(response.body)
+      entry = doc.elements["entry"]
+      VirtualIOServer.new(entry)
     end
 
-    def poweron_lpar(lpar_uuid, params = {})
+    ##
+    # @!method poweron_lpar(lpar_uuid, params = {}, sync = true)
+    # Power on a logical partition.
+    # @param lpar_uuid [String] The UUID of the logical partition.
+    # @param params [Hash] Job parameters.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def poweron_lpar(lpar_uuid, params = {}, sync = true)
       method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/do/PowerOn"
 
       job = HmcJob.new(self, method_url, "PowerOn", "LogicalPartition", params)
-      job.start
-      job.wait
-      job.delete
+      job.run if sync
+      job
     end
 
-    def poweroff_lpar(lpar_uuid, params = {})
+    ##
+    # @!method poweroff_lpar(lpar_uuid, params = {}, sync = true)
+    # Power off a logical partition.
+    # @param lpar_uuid [String] The UUID of the logical partition.
+    # @param params [Hash] Job parameters.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def poweroff_lpar(lpar_uuid, params = {}, sync = true)
       method_url = "/rest/api/uom/LogicalPartition/#{lpar_uuid}/do/PowerOff"
 
       job = HmcJob.new(self, method_url, "PowerOff", "LogicalPartition", params)
-      job.start
-      job.wait
-      job.delete
+      job.run if sync
+      job
     end
 
-    # Damien: share with poweron_lpar?
-    def poweron_vios(vios_uuid, params = {})
+    ##
+    # @!method poweron_vios(vios_uuid, params = {}, sync = true)
+    # Power on a virtual I/O server.
+    # @param vios_uuid [String] The UUID of the virtual I/O server.
+    # @param params [Hash] Job parameters.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def poweron_vios(vios_uuid, params = {}, sync = true)
       method_url = "/rest/api/uom/VirtualIOServer/#{vios_uuid}/do/PowerOn"
 
       job = HmcJob.new(self, method_url, "PowerOn", "VirtualIOServer", params)
-      job.start
-      job.wait
-      job.delete
+      job.run if sync
+      job
     end
 
-    # Damien: share with poweroff_lpar?
-    def poweroff_vios(vios_uuid, params = {})
+    ##
+    # @!method poweroff_vios(vios_uuid, params = {}, sync = true)
+    # Power off a virtual I/O server.
+    # @param vios_uuid [String] The UUID of the virtual I/O server.
+    # @param params [Hash] Job parameters.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def poweroff_vios(vios_uuid, params = {}, sync = true)
       method_url = "/rest/api/uom/VirtualIOServer/#{vios_uuid}/do/PowerOff"
 
       job = HmcJob.new(self, method_url, "PowerOff", "VirtualIOServer", params)
-      job.start
-      job.wait
-      job.delete
+      job.run if sync
+      job
     end
 
-    def poweron_managed_system(sys_uuid, params = {})
+    ##
+    # @!method poweron_managed_system(sys_uuid, params = {}, sync = true)
+    # Power on a managed system.
+    # @param sys_uuid [String] The UUID of the managed system.
+    # @param params [Hash] Job parameters.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def poweron_managed_system(sys_uuid, params = {}, sync = true)
       method_url = "/rest/api/uom/ManagedSystem/#{sys_uuid}/do/PowerOn"
 
       job = HmcJob.new(self, method_url, "PowerOn", "ManagedSystem", params)
-      job.start
-      job.wait
-      job.delete
+      job.run if sync
+      job
     end
 
-    def poweroff_managed_system(sys_uuid, params = {})
+    ##
+    # @!method poweroff_managed_system(sys_uuid, params = {}, sync = true)
+    # Power off a managed system.
+    # @param sys_uuid [String] The UUID of the managed system.
+    # @param params [Hash] Job parameters.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def poweroff_managed_system(sys_uuid, params = {}, sync = true)
       method_url = "/rest/api/uom/ManagedSystem/#{sys_uuid}/do/PowerOff"
 
       job = HmcJob.new(self, method_url, "PowerOff", "ManagedSystem", params)
-      job.start
-      job.wait
-      job.delete
+      job.run if sync
+      job
     end
 
-    # Blocks until new events occur.
-    def next_events
+    ##
+    # @!method cli_run(hmc_uuid, cmd, sync = true)
+    # Run a CLI command on the HMC as a job.
+    # @param hmc_uuid [String] The UUID of the management console.
+    # @param cmd [String] The command to run.
+    # @param sync [Boolean] Start the job and wait for its completion.
+    # @return [IbmPowerHmc::HmcJob] The HMC job.
+    def cli_run(hmc_uuid, cmd, sync = true)
+      method_url = "/rest/api/uom/ManagementConsole/#{hmc_uuid}/do/CLIRunner"
+
+      params = {
+        "cmd" => cmd,
+        "acknowledgeThisAPIMayGoAwayInTheFuture" => "true",
+      }
+      job = HmcJob.new(self, method_url, "CLIRunner", "ManagementConsole", params)
+      job.run if sync
+      job
+    end
+
+    ##
+    # @!method next_events(wait = true)
+    # Retrieve a list of events that occured since last call.
+    # @param wait [Boolean] If no event is available, block until new events occur.
+    # @return [Array<IbmPowerHmc::Event>] The list of events.
+    def next_events(wait = true)
       method_url = "/rest/api/uom/Event"
 
-      events = []
+      response = nil
       loop do
         response = request(:get, method_url)
-        next if response.code == 204
+        # No need to sleep as the HMC already waits a bit before returning 204
+        break if response.code != 204 || !wait
+      end
+      doc = REXML::Document.new(response.body)
+      parse_feed(doc, Event)
+    end
 
-        doc = REXML::Document.new(response.body)
-        doc.root.each_element("entry") do |entry|
-          event = Event.new(entry)
-          events += [event]
+    class HttpError < Error
+      attr_reader :status, :uri, :reason, :message
+
+      ##
+      # @!method initialize(err)
+      # Create a new HttpError exception.
+      # @param err [RestClient::Exception] The REST client exception.
+      def initialize(err)
+        super
+        @status = err.http_code
+
+        # Try to parse body as an HttpErrorResponse
+        doc = REXML::Document.new(err.response.body)
+        entry = doc.elements["entry"]
+        unless entry.nil?
+          resp = HttpErrorResponse.new(entry)
+          @uri = resp.uri
+          @reason = resp.reason
+          @message = resp.message
         end
-        break
       end
-      events
     end
 
+    ##
+    # @!method request(method, url, headers = {}, payload = nil)
+    # Perform a REST API request.
+    # @param method [String] The HTTP method.
+    # @param url [String] The method URL.
+    # @param headers [Hash] HTTP headers.
+    # @param payload [String] HTTP request payload.
+    # @return [RestClient::Response] The response from the HMC.
     def request(method, url, headers = {}, payload = nil)
       logon if @api_session_token.nil?
-
-      headers = headers.merge({ "X-API-Session" => @api_session_token })
-      # Damien: use URI module and prepare in initialize?
-      response = RestClient::Request.execute(
-        method: method,
-        url: "https://" + @hostname + url,
-        verify_ssl: @verify_ssl,
-        payload: payload,
-        headers: headers
-      )
-      if response.code == 403
-        # Damien: if token expires, reauth?
-        @api_session_token = nil
-        logon
-        # Damien: retry TBD
+      reauth = false
+      begin
+        headers = headers.merge({"X-API-Session" => @api_session_token})
+        RestClient::Request.execute(
+          :method => method,
+          :url => "https://" + @hostname + url,
+          :verify_ssl => @verify_ssl,
+          :payload => payload,
+          :headers => headers
+        )
+      rescue RestClient::Exception => e
+        # Do not retry on failed logon attempts
+        if e.http_code == 401 && @api_session_token != "" && !reauth
+          # Try to reauth
+          reauth = true
+          logon
+          retry
+        end
+        raise HttpError.new(e), "REST request failed"
       end
-      response
     end
   end
 end

data/lib/ibm_power_hmc/job.rb

@@ -1,20 +1,35 @@
 # frozen_string_literal: true
 
-# Module for IBM HMC Rest API Client
 module IbmPowerHmc
-  # HMC Job for long running operations
+  ##
+  # HMC Job for long running operations.
   class HmcJob
-    def initialize(hc, method_url, operation, group, params)
-      @hc = hc
+    class JobNotStarted < StandardError; end
+
+    ##
+    # @!method initialize(conn, method_url, operation, group, params = {})
+    # Construct a new HMC Job.
+    #
+    # @param conn [IbmPowerHmc::Connection] The connection to the HMC.
+    # @param method_url [String] The method URL.
+    # @param operation [String] The name of the requested operation.
+    # @param group [String] The name of the group.
+    # @param params [Hash] The job name/value parameters.
+    def initialize(conn, method_url, operation, group, params = {})
+      @conn = conn
       @method_url = method_url
       @operation = operation
       @group = group
       @params = params
     end
 
+    ##
+    # @!method status
+    # Start the job asynchronously.
+    # @return [String] The ID of the job.
     def start
       headers = {
-        content_type: "application/vnd.ibm.powervm.web+xml; type=JobRequest"
+        :content_type => "application/vnd.ibm.powervm.web+xml; type=JobRequest"
       }
       doc = REXML::Document.new("")
       doc.add_element("JobRequest:JobRequest", {
@@ -22,49 +37,95 @@ module IbmPowerHmc
                         "xmlns" => "http://www.ibm.com/xmlns/systems/power/firmware/web/mc/2012_10/",
                         "schemaVersion" => "V1_1_0"
                       })
-      op = doc.root.add_element("RequestedOperation", { "schemaVersion" => "V1_1_0" })
+      op = doc.root.add_element("RequestedOperation", {"schemaVersion" => "V1_1_0"})
       op.add_element("OperationName").text = @operation
       op.add_element("GroupName").text = @group
       # Damien: ProgressType?
-      jobparams = doc.root.add_element("JobParameters", { "schemaVersion" => "V1_1_0" })
+      jobparams = doc.root.add_element("JobParameters", {"schemaVersion" => "V1_1_0"})
       @params.each do |key, value|
-        jobparam = jobparams.add_element("JobParameter", { "schemaVersion" => "V1_1_0" })
+        jobparam = jobparams.add_element("JobParameter", {"schemaVersion" => "V1_1_0"})
         jobparam.add_element("ParameterName").text = key
         jobparam.add_element("ParameterValue").text = value
       end
-      response = @hc.request(:put, @method_url, headers, doc.to_s)
+      response = @conn.request(:put, @method_url, headers, doc.to_s)
       doc = REXML::Document.new(response.body)
       info = doc.root.elements["content/JobResponse:JobResponse"]
       @id = info.elements["JobID"].text
     end
 
+    # @return [Hash] The job results returned by the HMC.
+    attr_reader :results
+
+    ##
+    # @!method status
+    # Return the status of the job.
+    # @return [String] The status of the job.
     def status
-      # Damien: check id is defined
+      raise JobNotStarted unless defined?(@id)
+
       method_url = "/rest/api/uom/jobs/#{@id}"
       headers = {
-        content_type: "application/vnd.ibm.powervm.web+xml; type=JobRequest"
+        :content_type => "application/vnd.ibm.powervm.web+xml; type=JobRequest"
       }
-      response = @hc.request(:get, method_url, headers)
+      response = @conn.request(:get, method_url, headers)
       doc = REXML::Document.new(response.body)
       info = doc.root.elements["content/JobResponse:JobResponse"]
       status = info.elements["Status"].text
-      # Damien: also retrieve "ResponseException/Message"
+      # Damien: also retrieve "ResponseException/Message"?
+
+      # Gather Job results returned by the HMC.
+      @results = {}
+      info.each_element("Results/JobParameter") do |result|
+        name = result.elements["ParameterName"].text.strip
+        value = result.elements["ParameterValue"].text.strip
+        @results[name] = value
+      end
+
       status
     end
 
-    def wait(timeout = 120, poll_interval = 30)
-      endtime = Time.now + timeout
-      while Time.now < endtime do
+    ##
+    # @!method wait(timeout = 120, poll_interval = 0)
+    # Wait for the job to complete.
+    # @param timeout [Integer] The maximum time in seconds to wait for the job to complete.
+    # @param poll_interval [Integer] The interval in seconds between status queries (0 means auto).
+    # @return [String] The status of the job.
+    def wait(timeout = 120, poll_interval = 0)
+      endtime = Time.now.utc + timeout
+      auto = poll_interval == 0
+      poll_interval = 1 if auto
+      while Time.now.utc < endtime
         status = self.status
-        break if status != "RUNNING" # Damien: and != "STARTING"?
+        return status if status != "RUNNING" && status != "NOT_STARTED"
+
+        poll_interval *= 2 if auto && poll_interval < 30
         sleep(poll_interval)
       end
+      "TIMEDOUT"
     end
 
+    ##
+    # @!method run(timeout = 120, poll_interval = 0)
+    # Run the job synchronously.
+    # @param timeout [Integer] The maximum time in seconds to wait for the job to complete.
+    # @param poll_interval [Integer] The interval in seconds between status queries (0 means auto).
+    # @return [String] The status of the job.
+    def run(timeout = 120, poll_interval = 0)
+      start
+      status = wait(timeout, poll_interval)
+      status
+    ensure
+      delete if defined?(@id)
+    end
+
+    ##
+    # @!method delete
+    # Delete the job from the HMC.
     def delete
-      # Damien: check id is defined
+      raise JobNotStarted unless defined?(@id)
+
       method_url = "/rest/api/uom/jobs/#{@id}"
-      @hc.request(:delete, method_url)
+      @conn.request(:delete, method_url)
       # Returns HTTP 204 if ok
     end
   end

data/lib/ibm_power_hmc/objects.rb

@@ -16,7 +16,7 @@ module IbmPowerHmc
       value = doc.elements[xpath]
       value = value.text unless value.nil?
       value = value.strip unless value.nil?
-      self.class.__send__(:attr_reader, "#{varname}")
+      self.class.__send__(:attr_reader, varname)
       instance_variable_set("@#{varname}", value)
     end
 
@@ -25,10 +25,6 @@ module IbmPowerHmc
         get_value(doc, key, value)
       end
     end
-
-    def to_s
-      "uuid=#{@uuid}"
-    end
   end
 
   # HMC information
@@ -44,10 +40,6 @@ module IbmPowerHmc
       info = doc.elements["content/ManagementConsole:ManagementConsole"]
       get_values(info, XMLMAP)
     end
-
-    def to_s
-      "hmc name=#{@name} version=#{@version} build_level=#{@build_level}"
-    end
   end
 
   # Managed System information
@@ -60,7 +52,10 @@ module IbmPowerHmc
       "AssociatedSystemMemoryConfiguration/InstalledSystemMemory" => "memory",
       "AssociatedSystemMemoryConfiguration/CurrentAvailableSystemMemory" => "avail_mem",
       "AssociatedSystemProcessorConfiguration/InstalledSystemProcessorUnits" => "cpus",
-      "AssociatedSystemProcessorConfiguration/CurrentAvailableSystemProcessorUnits" => "avail_cpus"
+      "AssociatedSystemProcessorConfiguration/CurrentAvailableSystemProcessorUnits" => "avail_cpus",
+      "MachineTypeModelAndSerialNumber/MachineType" => "mtype",
+      "MachineTypeModelAndSerialNumber/Model" => "model",
+      "MachineTypeModelAndSerialNumber/SerialNumber" => "serial",
     }.freeze
 
     def initialize(doc)
@@ -68,10 +63,6 @@ module IbmPowerHmc
       info = doc.elements["content/ManagedSystem:ManagedSystem"]
       get_values(info, XMLMAP)
     end
-
-    def to_s
-      "sys name=#{@name} state=#{@state} ip=#{@ipaddr} mem=#{@memory}MB avail=#{@avail_mem}MB CPUs=#{@cpus} avail=#{@avail_cpus}"
-    end
   end
 
   # Logical Partition information
@@ -96,10 +87,6 @@ module IbmPowerHmc
       @sys_uuid = URI(sys_href).path.split('/').last
       get_values(info, XMLMAP)
     end
-
-    def to_s
-      "lpar name=#{@name} id=#{@id} state=#{@state} type=#{@type} memory=#{@memory}MB dedicated cpus=#{@dedicated}"
-    end
   end
 
   # VIOS information
@@ -122,21 +109,12 @@ module IbmPowerHmc
       @sys_uuid = URI(sys_href).path.split('/').last
       get_values(info, XMLMAP)
     end
-
-    def to_s
-      "vios name=#{@name} id=#{@id} state=#{@state} type=#{@type} memory=#{@memory}MB dedicated cpus=#{@dedicated}"
-    end
-  end
-
-  # LPAR profile
-  class LogicalPartitionProfile < HmcObject
-    attr_reader :lpar_uuid
-
-    # Damien: TBD
   end
 
   # HMC Event
   class Event < HmcObject
+    attr_reader :published
+
     XMLMAP = {
       "EventID" => "id",
       "EventType" => "type",
@@ -146,12 +124,25 @@ module IbmPowerHmc
 
     def initialize(doc)
       super(doc)
+      @published = doc.elements["published"].text
       info = doc.elements["content/Event:Event"]
       get_values(info, XMLMAP)
     end
+  end
+
+  # Error response from HMC
+  class HttpErrorResponse < HmcObject
+    XMLMAP = {
+      "HTTPStatus" => "status",
+      "RequestURI" => "uri",
+      "ReasonCode" => "reason",
+      "Message" => "message",
+    }.freeze
 
-    def to_s
-      "event id=#{@id} type=#{@type} data=#{@data} detail=#{@detail}"
+    def initialize(doc)
+      super(doc)
+      info = doc.elements["content/HttpErrorResponse:HttpErrorResponse"]
+      get_values(info, XMLMAP)
     end
   end
 end

data/lib/ibm_power_hmc/pcm.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'uri'
+
+module IbmPowerHmc
+  class Connection
+    ##
+    # @!method managed_system_metrics(sys_uuid:, start_ts: nil, end_ts: nil, no_samples: nil)
+    # Retrieve metrics for a managed system.
+    # @param sys_uuid [String] The managed system UUID.
+    # @param start_ts [String] Start timestamp.
+    # @param end_ts [String] End timestamp.
+    # @param no_samples [Integer] Number of samples.
+    # @return [Array<Hash>] The processed metrics for the managed system.
+    def managed_system_metrics(sys_uuid:, start_ts: nil, end_ts: nil, no_samples: nil)
+      method_url = "/rest/api/pcm/ManagedSystem/#{sys_uuid}/ProcessedMetrics"
+      query = []
+      query << "StartTS=#{start_ts}" unless start_ts.nil?
+      query << "EndTS=#{end_ts}" unless end_ts.nil?
+      query << "NoOfSamples=#{no_samples}" unless no_samples.nil?
+      method_url += "?" + query.compact.join('&') unless query.empty?
+
+      response = request(:get, method_url)
+      doc = REXML::Document.new(response.body)
+      metrics = []
+      doc.each_element("feed/entry") do |entry|
+        category = entry.elements["category"]
+        next if category.nil?
+
+        term = category.attributes["term"]
+        next if term.nil? || term != "ManagedSystem"
+
+        link = entry.elements["link"]
+        next if link.nil?
+
+        href = link.attributes["href"]
+        next if href.nil?
+
+        # Validate URI
+        begin
+          href = URI(href)
+        rescue
+          next
+        end
+        # Remove https://hostname:port prefix.
+        href.scheme = href.host = href.port = nil
+
+        response = request(:get, href.to_s)
+        metrics << JSON.parse(response.body)
+      end
+      metrics
+    end
+  end
+end

data/lib/ibm_power_hmc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ibm_power_hmc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - IBM Power
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-06 00:00:00.000000000 Z
+date: 2021-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -25,12 +25,14 @@ 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: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
+- ".rubocop_local.yml"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -44,6 +46,7 @@ files:
 - lib/ibm_power_hmc/connection.rb
 - lib/ibm_power_hmc/job.rb
 - lib/ibm_power_hmc/objects.rb
+- lib/ibm_power_hmc/pcm.rb
 - lib/ibm_power_hmc/version.rb
 homepage: http://github.com/IBM/ibm_power_hmc_sdk_ruby
 licenses:
@@ -53,7 +56,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
@@ -68,8 +71,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.0.3
+signing_key:
 specification_version: 4
 summary: IBM Power HMC Ruby gem.
 test_files: []