redfish_client 0.3.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45295e03b5e8ec0dda4fd0d7401f95516c92d48eba415337d25d3d2ef210a869
-  data.tar.gz: bfe94afbb669fdd6bb4b407b8ddacfaf17695b49f4bdd2d83645290f97f7b5b6
+  metadata.gz: 89fe47fe3e6d6e82a1c1fbce3a33e101ec9c0dc70b9e4725205c1e987c1f4b38
+  data.tar.gz: 823ea29d9a34c9a460c6a65b385714d08fa50caaeb829dfb7f1747af78389b63
 SHA512:
-  metadata.gz: c99e489c2328e9a1fb3ada71d3c62f0a3ce9d75e93bf78206e56490a4153d60a20601bc5d7fee351485ede848a6c640310f7df3b29c3c73c138ac4b466f62b3d
-  data.tar.gz: 20b278901afbfaa467ec1bd72056f6fbf7420d6ab62f9352193023a46a9e44b7712a37ebb495db1016d6b77a8ca1a7eb729c06ab56c7e8061150e894b64a22f2
+  metadata.gz: 8699fd26e3c468d864132e5790ab6037d2ac6e767a38c96ee07a12c9edd29ba77aceb1937287f9bf877db0ccf23534d790bfe3aaa3ce1d87d63eb98e4f75d25d
+  data.tar.gz: 6538ec3de254d305b25fa076fb72d72866ec8162717c3cd1205f4c957d84b310a46b23490514e8b665acc121b6556e19b202261fc8f273d925c61ef99d5639e9

data/.rubocop.yml

@@ -9,6 +9,9 @@ AllCops:
 Layout/MultilineOperationIndentation:
   EnforcedStyle: indented
 
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
 Style/MethodMissing:
   Exclude:
     - lib/redfish_client/resource.rb
@@ -22,9 +25,24 @@ Style/Documentation:
 Style/BracesAroundHashParameters:
   EnforcedStyle: context_dependent
 
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
 Metrics/AbcSize:
   Max: 20
 
 Metrics/BlockLength:
   Exclude:
     - spec/**/*.rb
+
+Metrics/ClassLength:
+  Max: 500
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false

data/.travis.yml

@@ -1,4 +1,3 @@
-sudo: false
 language: ruby
 cache: bundler
 

data/README.md

@@ -41,6 +41,46 @@ Minimal program that uses this gem would look something like this:
     root.logout
 
 
+## Handling asynchronous operations
+
+Redfish service can return a 202 status when we request an execution of a
+long-running operation (e.g. updating firmware). We are expected to poll the
+monitor for changes until the job terminates.
+
+Responses in Redfish client have a built-in support for this, so polling the
+service is rather painless:
+
+    # Start the async action
+    response = update_service.Actions["#UpdateService.SimpleUpdate"].post(
+      field: "target", payload: { ... },
+    )
+    # Wait for the termination
+    response = update_service.wait(response)
+    # Do something with response
+
+It is also possible to manually poll the response like this:
+
+    response = update_service.Actions["#UpdateService.SimpleUpdate"].post(
+      field: "target", payload: { ... },
+    )
+    until response.done?
+      # wait a bit
+      response = update_service.get(response.monitor)
+    end
+
+Response is also safe to (de)serialize, which means that the process that
+started the async operation and the process that will wait for it can be
+separate:
+
+    response = update_service.Actions["#UpdateService.SimpleUpdate"].post(
+      field: "target", payload: { ... },
+    )
+    send_response_somewhere(response.to_h)
+
+    # Somewhere else
+    response = Response.from_hash(receive_response_from_somewhere)
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then,

data/lib/redfish_client.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "redfish_client/caching_connector"
 require "redfish_client/connector"
+require "redfish_client/nil_hash"
 require "redfish_client/root"
 require "redfish_client/version"
 
@@ -13,11 +13,8 @@ module RedfishClient
   # @param verify [Boolean] verify certificates for https connections
   # @param use_cache [Boolean] cache API responses
   def self.new(url, prefix: "/redfish/v1", verify: true, use_cache: true)
-    con = if use_cache
-            CachingConnector.new(url, verify)
-          else
-            Connector.new(url, verify)
-          end
+    cache = (use_cache ? Hash : NilHash).new
+    con = Connector.new(url, verify: verify, cache: cache)
     Root.new(con, oid: prefix)
   end
 end

data/lib/redfish_client/connector.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require "base64"
 require "excon"
 require "json"
 
+require "redfish_client/nil_hash"
+require "redfish_client/response"
+
 module RedfishClient
   # Connector serves as a low-level wrapper around HTTP calls that are used
   # to retrieve data from the service API. It abstracts away implementation
@@ -12,18 +16,39 @@ module RedfishClient
   # Library users should treat this class as an implementation detail and
   # use higer-level {RedfishClient::Resource} instead.
   class Connector
+    # AuthError is raised if the credentials are invalid.
+    class AuthError < StandardError; end
+
     # Default headers, as required by Redfish spec
     # https://redfish.dmtf.org/schemas/DSP0266_1.4.0.html#request-headers
     DEFAULT_HEADERS = {
       "Accept" => "application/json",
-      "OData-Version" => "4.0"
+      "OData-Version" => "4.0",
     }.freeze
 
+    # Basic and token authentication header names
+    BASIC_AUTH_HEADER = "Authorization"
+    TOKEN_AUTH_HEADER = "X-Auth-Token"
+    LOCATION_HEADER   = "Location"
+
     # Create new connector.
     #
+    # By default, connector performs no caching. If caching is desired,
+    # Hash should be used as a cache implementation.
+    #
+    # It is also possible to pass in custom caching class. Instances of that
+    # class should respond to the following four methods:
+    #
+    #  1. `[](key)`         - Used to access cached content and should return
+    #                         `nil` if the key has no associated value.
+    #  2. `[]=(key, value)` - Cache `value` under the `key`
+    #  3. `clear`           - Clear the complete cache.
+    #  4. `delete(key)`     - Invalidate cache entry associated with `key`.
+    #
     # @param url [String] base url of the Redfish service
     # @param verify [Boolean] verify SSL certificate of the service
-    def initialize(url, verify = true)
+    # @param cache [Object] cache backend
+    def initialize(url, verify: true, cache: nil)
       @url = url
       @headers = DEFAULT_HEADERS.dup
       middlewares = Excon.defaults[:middlewares] +
@@ -31,6 +56,7 @@ module RedfishClient
       @connection = Excon.new(@url,
                               ssl_verify_peer: verify,
                               middlewares: middlewares)
+      @cache = cache || NilHash.new
     end
 
     # Add HTTP headers to the requests made by the connector.
@@ -50,44 +76,131 @@ module RedfishClient
       headers.each { |h| @headers.delete(h) }
     end
 
+    # Issue requests to the service.
+    #
+    # @param mathod [Symbol] HTTP method (:get, :post, :patch or :delete)
+    # @param path [String] path to the resource, relative to the base
+    # @param data [Hash] data to be sent over the socket
+    # @return [Response] response object
+    def request(method, path, data = nil)
+      return @cache[path] if method == :get && @cache[path]
+
+      do_request(method, path, data).tap do |r|
+        @cache[path] = r if method == :get && r.status == 200
+      end
+    end
+
     # Issue GET request to service.
     #
+    # This method will first try to return cached response if available. If
+    # cache does not contain entry for this request, data will be fetched from
+    # remote and then cached, but only if the response has an OK (200) status.
+    #
     # @param path [String] path to the resource, relative to the base url
-    # @return [Excon::Response] response object
+    # @return [Response] response object
     def get(path)
-      @connection.get(path: path, headers: @headers)
+      request(:get, path)
     end
 
     # Issue POST requests to the service.
     #
     # @param path [String] path to the resource, relative to the base
     # @param data [Hash] data to be sent over the socket, JSON encoded
-    # @return [Excon::Response] response object
+    # @return [Response] response object
     def post(path, data = nil)
-      @connection.post(prepare_request_params(path, data))
+      request(:post, path, data)
     end
 
     # Issue PATCH requests to the service.
     #
     # @param path [String] path to the resource, relative to the base
     # @param data [Hash] data to be sent over the socket
-    # @return [Excon::Response] response object
+    # @return [Response] response object
     def patch(path, data = nil)
-      @connection.patch(prepare_request_params(path, data))
+      request(:patch, path, data)
     end
 
     # Issue DELETE requests to the service.
     #
     # @param path [String] path to the resource, relative to the base
-    # @return [Excon::Response] response object
+    # @return [Response] response object
     def delete(path)
-      @connection.delete(path: path, headers: @headers)
+      request(:delete, path)
+    end
+
+    # Clear the cached responses.
+    #
+    # If path is passed as a parameter, only one cache entry gets invalidated,
+    # else complete cache gets invalidated.
+    #
+    # Next GET request will repopulate the cache.
+    #
+    # @param path [String] path to invalidate
+    def reset(path = nil)
+      path.nil? ? @cache.clear : @cache.delete(path)
+    end
+
+    # Set authentication-related variables.
+    #
+    # Last parameter controls the kind of login connector will perform. If
+    # session_path is `nil`, basic authentication will be used, otherwise
+    # connector will use session-based authentication.
+    #
+    # Note that actual login is done lazily. If you need to check for
+    # credential validity, call #{login} method.
+    #
+    # @param username [String] API username
+    # @param password [String] API password
+    # @param auth_test_path [String] API path to test credential's validity
+    # @param session_path [String, nil] API session path
+    def set_auth_info(username, password, auth_test_path, session_path = nil)
+      @username = username
+      @password = password
+      @auth_test_path = auth_test_path
+      @session_path = session_path
+    end
+
+    # Authenticate against the service.
+    #
+    # Calling this method will try to authenticate against API using
+    # credentials provided by #{set_auth_info} call.
+    # If authentication fails, # {AuthError} will be raised.
+    #
+    # @raise [AuthError] if credentials are invalid
+    def login
+      @session_path ? session_login : basic_login
+    end
+
+    # Sign out of the service.
+    def logout
+      # We bypass request here because we do not want any retries on 401
+      # when doing logout.
+      if @session_oid
+        params = prepare_request_params(:delete, @session_oid)
+        @connection.request(params)
+        @session_oid = nil
+      end
+      remove_headers([BASIC_AUTH_HEADER, TOKEN_AUTH_HEADER])
     end
 
     private
 
-    def prepare_request_params(path, data)
-      params = { path: path }
+    def do_request(method, path, data)
+      params = prepare_request_params(method, path, data)
+      r = @connection.request(params)
+      if r.status == 401
+        login
+        r = @connection.request(params)
+      end
+      Response.new(r.status, downcase_headers(r.data[:headers]), r.data[:body])
+    end
+
+    def downcase_headers(headers)
+      headers.each_with_object({}) { |(k, v), obj| obj[k.downcase] = v }
+    end
+
+    def prepare_request_params(method, path, data = nil)
+      params = { method: method, path: path }
       if data
         params[:body] = data.to_json
         params[:headers] = @headers.merge("Content-Type" => "application/json")
@@ -96,5 +209,52 @@ module RedfishClient
       end
       params
     end
+
+    def session_login
+      # We bypass request here because we do not want any retries on 401
+      # when doing login.
+      params = prepare_request_params(:post, @session_path,
+                                      "UserName" => @username,
+                                      "Password" => @password)
+      r = @connection.request(params)
+      raise_invalid_auth_error unless r.status == 201
+
+      body    = JSON.parse(r.data[:body])
+      headers = r.data[:headers]
+
+      add_headers(TOKEN_AUTH_HEADER => headers[TOKEN_AUTH_HEADER])
+      save_session_oid!(body, headers)
+    end
+
+    def save_session_oid!(body, headers)
+      @session_oid = body["@odata.id"] if body.key?("@odata.id")
+      return if @session_oid
+
+      return unless headers.key?(LOCATION_HEADER)
+
+      location = URI.parse(headers[LOCATION_HEADER])
+      @session_oid = [location.path, location.query].compact.join("?")
+    end
+
+    def basic_login
+      payload = Base64.encode64("#{@username}:#{@password}").strip
+      add_headers(BASIC_AUTH_HEADER => "Basic #{payload}")
+      return if auth_valid?
+
+      remove_headers([BASIC_AUTH_HEADER])
+      raise_invalid_auth_error
+    end
+
+    def raise_invalid_auth_error
+      raise AuthError, "Invalid credentials"
+    end
+
+    def auth_valid?
+      # We bypass request here because we do not want any retries on 401
+      # when checking authentication headers.
+      reset(@auth_test_path) # Do not want to see cached response
+      params = prepare_request_params(:get, @auth_test_path)
+      @connection.request(params).status == 200
+    end
   end
 end

data/lib/redfish_client/event_listener.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+module RedfishClient
+  # EventListener class can be used to stream events from Redfish service. It
+  # is a thin wrapper around SSE listener that does the dirty work of
+  # splitting each event into its EventRecords and reporting them as separate
+  # events.
+  class EventListener
+    # Create new EventListener instance.
+    #
+    # @param sse_client [ServerSentEvents::Client] SSE client
+    def initialize(sse_client)
+      @sse_client = sse_client
+    end
+
+    # Stream events from redfish service.
+    #
+    # Events that this method yields are actually EventRecords, extracted from
+    # the actual Redfish Event.
+    def listen
+      @sse_client.listen do |event|
+        split_event_into_records(event).each { |r| yield(r) }
+      end
+    end
+
+    private
+
+    def split_event_into_records(event)
+      JSON.parse(event.data).fetch("Events", [])
+    end
+  end
+end

data/lib/redfish_client/nil_hash.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RedfishClient
+  # NilHash imitates the built-in Hash class without storing anything
+  # permanently.
+  #
+  # Main use of this class is as a non-caching connector backend.
+  class NilHash
+    # Access hash member.
+    #
+    # Since this implementation does not store any data, return value is
+    # always nil.
+    #
+    # @param _key not used
+    # @return [nil]
+    def [](_key)
+      nil
+    end
+
+    # Set hash member.
+    #
+    # This is just a pass-through method, since it always simply returns the
+    # value without actually storing it.
+    #
+    # @param _key not used
+    # @param value [Object] any value
+    # @return [Object] value
+    def []=(_key, value)
+      value
+    end
+
+    # Clear the contents of the cache.
+    #
+    # Since hash is not storing anything, this is a no-op.
+    def clear; end
+
+    # Delete entry from hash.
+    #
+    # Since hash is not storing anything, this is a no-op.
+    #
+    # @param _key not used
+    def delete(_key) end
+  end
+end

data/lib/redfish_client/resource.rb

@@ -17,8 +17,8 @@ module RedfishClient
   #
   # In order to reduce the amount of requests being sent to the service,
   # resource can also utilise caching connector. If we would like to get
-  # fresh values from the service, {#reset} call will flush the cache,
-  # causing next access to retrieve fresh data.
+  # fresh values from the service, {#refresh} call will flush the cache and
+  # retrieve fresh data from the remote.
   class Resource
     # NoODataId error is raised when operation would need OpenData id of the
     # resource to accomplish the task a hand.
@@ -28,9 +28,20 @@ module RedfishClient
     # resource.
     class NoResource < StandardError; end
 
+    # Timeout error is raised if the async request is not handled in due time.
+    class Timeout < StandardError; end
+
     # Headers, returned from the service when resource has been constructed.
+    #
+    # @return [Hash] resource headers
     attr_reader :headers
 
+    # Raw data that has been used to construct resource by either fetching it
+    # from the remote API or by being passed-in as a parameter to constructor.
+    #
+    # @return [Hash] resource raw data
+    attr_reader :raw
+
     # Create new resource.
     #
     # Resource can be created either by passing in OpenData identifier or
@@ -41,16 +52,36 @@ module RedfishClient
     # @param connector [RedfishClient::Connector] connector that will be used
     #   to fetch the resources
     # @param oid [String] OpenData id of the resource
-    # @param content [Hash] content to populate resource with
+    # @param raw [Hash] raw content to populate resource with
     # @raise [NoResource] resource cannot be retrieved from the service
-    def initialize(connector, oid: nil, content: nil)
+    def initialize(connector, oid: nil, raw: nil)
       @connector = connector
-
       if oid
         initialize_from_service(oid)
       else
-        @content = content
+        @raw = raw
+      end
+    end
+
+    # Wait for the potentially async operation to terminate
+    #
+    # Note that this can be safely called on response from non-async
+    # operations where the function will return immediately and without making
+    # any additional requests to the service.
+    #
+    # @param response [RedfishClient::Response] response
+    # @param retries [Integer] number of retries
+    # @param delay [Integer] number of seconds between retries
+    # @return [RedfishClient::Response] final response
+    # @raise [Timeout] if the operation did not terminate in time
+    def wait(response, retries: 10, delay: 1)
+      retries.times do |_i|
+        return response if response.done?
+
+        sleep(delay)
+        response = get(path: response.monitor)
       end
+      raise Timeout, "Async operation did not terminate in allotted time"
     end
 
     # Access resource content.
@@ -61,7 +92,7 @@ module RedfishClient
     # @param attr [String] key for accessing data
     # @return associated value or `nil` if attr is missing
     def [](attr)
-      build_resource(@content[attr])
+      build_resource(raw[attr])
     end
 
     # Safely access nested resource content.
@@ -82,7 +113,7 @@ module RedfishClient
     # @param name [String, Symbol] key name to test
     # @return [Boolean] inclusion test result
     def key?(name)
-      @content.key?(name.to_s)
+      raw.key?(name.to_s)
     end
 
     # Convenience access for resource data.
@@ -96,25 +127,52 @@ module RedfishClient
       key?(symbol.to_s) || super
     end
 
-    # Clear the cached sub-resources.
+    # Pretty-print the wrapped content.
     #
-    # This method is a no-op if connector in use does not support caching.
-    def reset
-      @connector.reset if @connector.respond_to?(:reset)
+    # @return [String] JSON-serialized raw data
+    def to_s
+      JSON.pretty_generate(raw)
     end
 
-    # Access raw JSON data that resource wraps.
+    # Issue a requests to the selected endpoint.
+    #
+    # By default, request will be sent to the path, stored in `@odata.id`
+    # field. Source field can be changed by specifying the `field` parameter
+    # when calling this function. Specifying the `path` argument will bypass
+    # the field lookup altogether and issue a request directly to the selected
+    # path.
     #
-    # @return [Hash] wrapped data
-    def raw
-      @content
+    # If the resource has no lookup field, {NoODataId} error will be raised,
+    # since posting to non-networked resources makes no sense and probably
+    # indicates bug in library consumer.
+    #
+    # @param method [Symbol] HTTP method (:get, :post, :patch or :delete)
+    # @param field [String, Symbol] path lookup field
+    # @param path [String] path to post to
+    # @return [RedfishClient::Response] response
+    # @raise  [NoODataId] resource has no OpenData id
+    def request(method, field, path, payload = nil)
+      @connector.request(method, get_path(field, path), payload)
     end
 
-    # Pretty-print the wrapped content.
+    # Issue a GET requests to the selected endpoint.
     #
-    # @return [String] JSON-serialized raw data
-    def to_s
-      JSON.pretty_generate(@content)
+    # By default, GET request will be sent to the path, stored in `@odata.id`
+    # field. Source field can be changed by specifying the `field` parameter
+    # when calling this function. Specifying the `path` argument will bypass
+    # the field lookup altogether and issue a GET request directly to the
+    # selected path.
+    #
+    # If the resource has no lookup field, {NoODataId} error will be raised,
+    # since posting to non-networked resources makes no sense and probably
+    # indicates bug in library consumer.
+    #
+    # @param field [String, Symbol] path lookup field
+    # @param path [String] path to post to
+    # @return [RedfishClient::Response] response
+    # @raise  [NoODataId] resource has no OpenData id
+    def get(field: "@odata.id", path: nil)
+      request(:get, field, path)
     end
 
     # Issue a POST requests to the selected endpoint.
@@ -135,10 +193,10 @@ module RedfishClient
     # @param field [String, Symbol] path lookup field
     # @param path [String] path to post to
     # @param payload [Hash<String, >] data to send
-    # @return [Excon::Response] response
+    # @return [RedfishClient::Response] response
     # @raise  [NoODataId] resource has no OpenData id
     def post(field: "@odata.id", path: nil, payload: nil)
-      @connector.post(get_path(field, path), payload)
+      request(:post, field, path, payload)
     end
 
     # Issue a PATCH requests to the selected endpoint.
@@ -149,10 +207,10 @@ module RedfishClient
     # @param field [String, Symbol] path lookup field
     # @param path [String] path to patch
     # @param payload [Hash<String, >] data to send
-    # @return [Excon::Response] response
+    # @return [RedfishClient::Response] response
     # @raise  [NoODataId] resource has no OpenData id
     def patch(field: "@odata.id", path: nil, payload: nil)
-      @connector.patch(get_path(field, path), payload)
+      request(:patch, field, path, payload)
     end
 
     # Issue a DELETE requests to the endpoint of the resource.
@@ -161,26 +219,52 @@ module RedfishClient
     # raised, since deleting non-networked resources makes no sense and
     # probably indicates bug in library consumer.
     #
-    # @return [Excon::Response] response
+    # @return [RedfishClient::Response] response
     # @raise  [NoODataId] resource has no OpenData id
-    def delete
-      @connector.delete(get_path("@odata.id", nil))
+    def delete(field: "@odata.id", path: nil, payload: nil)
+      request(:delete, field, path, payload)
+    end
+
+    # Refresh resource content from the API
+    #
+    # Caling this method will ensure that the resource data is in sync with
+    # the Redfis API, invalidating any caches as necessary.
+    def refresh
+      return unless self["@odata.id"]
+
+      # TODO(@tadeboro): raise more sensible exception if resource cannot be
+      # refreshed.
+      @connector.reset(self["@odata.id"])
+      initialize_from_service(self["@odata.id"])
     end
 
     private
 
     def initialize_from_service(oid)
-      resp = @connector.get(oid)
-      raise NoResource unless resp.status == 200
+      url, fragment = oid.split("#", 2)
+      resp = wait(get(path: url))
+      raise NoResource unless [200, 201].include?(resp.status)
+
+      @raw = get_fragment(JSON.parse(resp.body), fragment)
+      @raw["@odata.id"] = oid
+      @headers = resp.headers
+    end
+
+    def get_fragment(data, fragment)
+      # data, /my/0/part -> data["my"][0]["part"]
+      parse_fragment_string(fragment).reduce(data) do |acc, c|
+        acc[acc.is_a?(Array) ? c.to_i : c]
+      end
+    end
 
-      @content = JSON.parse(resp.data[:body])
-      @content["@odata.id"] = oid
-      @headers = resp.data[:headers]
+    def parse_fragment_string(fragment)
+      # /my/0/part -> ["my", "0", "part"]
+      fragment ? fragment.split("/").reject { |i| i == "" } : []
     end
 
     def get_path(field, path)
       raise NoODataId if path.nil? && !key?(field)
-      path || @content[field]
+      path || raw[field]
     end
 
     def build_resource(data)
@@ -197,7 +281,7 @@ module RedfishClient
       if data.key?("@odata.id")
         Resource.new(@connector, oid: data["@odata.id"])
       else
-        Resource.new(@connector, content: data)
+        Resource.new(@connector, raw: data)
       end
     rescue NoResource
       nil

data/lib/redfish_client/response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module RedfishClient
+  # Response struct.
+  #
+  # This struct is returned from the methods that interact with the remote API.
+  class Response
+    attr_reader :status
+    attr_reader :headers
+    attr_reader :body
+
+    def initialize(status, headers, body)
+      @status = status
+      @headers = headers
+      @body = body
+    end
+
+    def done?
+      status != 202
+    end
+
+    def monitor
+      return nil if done?
+
+      uri = URI.parse(headers["location"])
+      [uri.path, uri.query].compact.join("?")
+    end
+
+    def to_h
+      { "status" => status, "headers" => headers, "body" => body }
+    end
+
+    def to_s
+      "Response[status=#{status}, headers=#{headers}, body='#{body}']"
+    end
+
+    def self.from_hash(data)
+      new(*data.values_at("status", "headers", "body"))
+    end
+  end
+end

data/lib/redfish_client/root.rb

@@ -1,48 +1,14 @@
 # frozen_string_literal: true
 
-require "base64"
-require "json"
+require "server_sent_events"
+
+require "redfish_client/event_listener"
 require "redfish_client/resource"
 
 module RedfishClient
   # Root resource represents toplevel entry point into Redfish service data.
   # Its main purpose is to provide authentication support for the API.
   class Root < Resource
-    # AuthError is raised if the user session cannot be created.
-    class AuthError < StandardError; end
-
-    # Basic and token authentication headers.
-    BASIC_AUTH_HEADER = "Authorization"
-    TOKEN_AUTH_HEADER = "X-Auth-Token"
-
-    # Authenticate against the service.
-    #
-    # Calling this method will try to create new session on the service using
-    # provided credentials. If the session creation fails, basic
-    # authentication will be attempted. If basic authentication fails,
-    # {AuthError} will be raised.
-    #
-    # @param username [String] username
-    # @param password [String] password
-    # @raise [AuthError] if user session could not be created
-    def login(username, password)
-      # Since session auth is more secure, we try it first and use basic auth
-      # only if session auth is not available.
-      if session_login_available?
-        session_login(username, password)
-      else
-        basic_login(username, password)
-      end
-    end
-
-    # Sign out of the service.
-    #
-    # If the session could not be deleted, {AuthError} will be raised.
-    def logout
-      session_logout
-      basic_logout
-    end
-
     # Find Redfish service object by OData ID field.
     #
     # @param oid [String] Odata id of the resource
@@ -62,47 +28,50 @@ module RedfishClient
       Resource.new(@connector, oid: oid)
     end
 
-    private
+    # Return event listener.
+    #
+    # If the service does not support SSE, this function will return nil.
+    #
+    # @return [EventListener, nil] event listener
+    def event_listener
+      address = dig("EventService", "ServerSentEventUri")
+      return nil if address.nil?
 
-    def session_login_available?
-      !@content.dig("Links", "Sessions").nil?
+      EventListener.new(ServerSentEvents.create_client(address))
     end
 
-    def session_login(username, password)
-      r = @connector.post(
-        @content["Links"]["Sessions"]["@odata.id"],
-        "UserName" => username, "Password" => password
+    # Authenticate against the service.
+    #
+    # Calling this method will select the appropriate method of authentication
+    # and try to login using provided credentials.
+    #
+    # @param username [String] username
+    # @param password [String] password
+    # @raise [RedfishClient::AuthenticatedConnector::AuthError] if user
+    #   session could not be authenticated
+    def login(username, password)
+      @connector.set_auth_info(
+        username, password, auth_test_path, session_path
       )
-      raise AuthError, "Invalid credentials" unless r.status == 201
-
-      session_logout
-
-      payload = r.data[:headers][TOKEN_AUTH_HEADER]
-      @connector.add_headers(TOKEN_AUTH_HEADER => payload)
-      @session = Resource.new(@connector, content: JSON.parse(r.data[:body]))
+      @connector.login
     end
 
-    def session_logout
-      return unless @session
-      r = @session.delete
-      raise AuthError unless r.status == 204
-      @session = nil
-      @connector.remove_headers([TOKEN_AUTH_HEADER])
+    # Sign out of the service.
+    def logout
+      @connector.logout
     end
 
-    def auth_test_path
-      @content.values.map { |v| v["@odata.id"] }.compact.first
-    end
+    private
 
-    def basic_login(username, password)
-      payload = Base64.encode64("#{username}:#{password}").strip
-      @connector.add_headers(BASIC_AUTH_HEADER => "Basic #{payload}")
-      r = @connector.get(auth_test_path)
-      raise AuthError, "Invalid credentials" unless r.status == 200
+    def session_path
+      # We access raw values here on purpose, since calling dig on resource
+      # instance would try to download the sessions collection, which would
+      # fail since we are not yet logged in.
+      raw.dig("Links", "Sessions", "@odata.id")
     end
 
-    def basic_logout
-      @connector.remove_headers([BASIC_AUTH_HEADER])
+    def auth_test_path
+      raw.values.find { |v| v["@odata.id"] }["@odata.id"]
     end
   end
 end

data/lib/redfish_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RedfishClient
-  VERSION = "0.3.0"
+  VERSION = "0.5.2"
 end

data/redfish_client.gemspec

@@ -29,12 +29,13 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = "~> 2.1"
 
-  spec.add_runtime_dependency "excon", "~> 0.60"
+  spec.add_runtime_dependency "excon", "~> 0.71"
+  spec.add_runtime_dependency "server_sent_events", "~> 0.1"
 
-  spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", ">= 11.0"
   spec.add_development_dependency "rspec", ">= 3.7"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "webmock", "~> 3.4"
   spec.add_development_dependency "yard"
   spec.add_development_dependency "rubocop", "~> 0.54.0"
   spec.add_development_dependency "pry"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redfish_client
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Tadej Borovšak
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-12 00:00:00.000000000 Z
+date: 2020-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: excon
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.60'
+        version: '0.71'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.60'
+        version: '0.71'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: server_sent_events
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
-  type: :development
+        version: '0.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -142,9 +156,11 @@ files:
 - bin/console
 - bin/setup
 - lib/redfish_client.rb
-- lib/redfish_client/caching_connector.rb
 - lib/redfish_client/connector.rb
+- lib/redfish_client/event_listener.rb
+- lib/redfish_client/nil_hash.rb
 - lib/redfish_client/resource.rb
+- lib/redfish_client/response.rb
 - lib/redfish_client/root.rb
 - lib/redfish_client/version.rb
 - redfish_client.gemspec

data/lib/redfish_client/caching_connector.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "redfish_client/connector"
-
-module RedfishClient
-  # Variant of {RedfishClient::Connector} that caches GET responses.
-  class CachingConnector < Connector
-    # Create new caching connector.
-    #
-    # @param url [String] base url of the Redfish service
-    # @param verify [Boolean] verify SSL certificate of the service
-    def initialize(url, verify = true)
-      super
-      @cache = {}
-    end
-
-    # Issue GET request to service.
-    #
-    # Request is only issued if there is no cache entry for the existing path.
-    #
-    # @param path [String] path to the resource, relative to the base url
-    # @return [Excon::Response] response object
-    def get(path)
-      @cache[path] ||= super
-    end
-
-    # Clear the cached responses.
-    #
-    # Next GET request will repopulate the cache.
-    def reset(path: nil)
-      if path.nil?
-        @cache = {}
-      else
-        @cache.delete(path)
-      end
-    end
-  end
-end