Class: RedfishClient::Connector

Inherits:
Object
  • Object
show all
Defined in:
lib/redfish_client/connector.rb

Overview

Connector serves as a low-level wrapper around HTTP calls that are used to retrieve data from the service API. It abstracts away implementation details such as sending the proper headers in request, which do not change between resource fetches.

Library users should treat this class as an implementation detail and use higer-level Resource instead.

Defined Under Namespace

Classes: AuthError

Constant Summary collapse

DEFAULT_HEADERS =

Default headers, as required by Redfish spec https://redfish.dmtf.org/schemas/DSP0266_1.4.0.html#request-headers

{
  "Accept" => "application/json",
  "OData-Version" => "4.0",
}.freeze
BASIC_AUTH_HEADER =

Basic and token authentication header names

"Authorization"
TOKEN_AUTH_HEADER = 
"X-Auth-Token"
LOCATION_HEADER = 
"Location"

Instance Method Summary collapse

Constructor Details

#initialize(url, verify: true, cache: nil, use_session: true) ⇒ Connector

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.

Parameters:

  • url (String) —

    base url of the Redfish service

  • verify (Boolean) (defaults to: true) —

    verify SSL certificate of the service

  • use_session (Boolean) (defaults to: true) —

    Use a session for authentication

  • cache (Object) (defaults to: nil) —

    cache backend



53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/redfish_client/connector.rb', line 53

def initialize(url, verify: true, cache: nil, use_session: true)
  @url = url
  @headers = DEFAULT_HEADERS.dup
  middlewares = Excon.defaults[:middlewares] +
    [Excon::Middleware::RedirectFollower]
  @connection = Excon.new(@url,
                          ssl_verify_peer: verify,
                          middlewares: middlewares)
  @cache = cache || NilHash.new
  @use_session = use_session
end

Instance Method Details

#add_headers(headers) ⇒ Object

Add HTTP headers to the requests made by the connector.

Parameters:

  • headers (Hash<String, String>) —

    headers to be added



68
69
70
 
# File 'lib/redfish_client/connector.rb', line 68

def add_headers(headers)
  @headers.merge!(headers)
end

#delete(path) ⇒ Response

Issue DELETE requests to the service.

Parameters:

  • path (String) —

    path to the resource, relative to the base

Returns:



131
132
133
 
# File 'lib/redfish_client/connector.rb', line 131

def delete(path)
  request(:delete, path)
end

#get(path) ⇒ Response

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.

Parameters:

  • path (String) —

    path to the resource, relative to the base url

Returns:



104
105
106
 
# File 'lib/redfish_client/connector.rb', line 104

def get(path)
  request(:get, path)
end

#login ⇒ Object

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.

Raises:



174
175
176
 
# File 'lib/redfish_client/connector.rb', line 174

def 
  @session_path ?  : 
end

#logout ⇒ Object

Sign out of the service.



179
180
181
182
183
184
185
186
187
188
 
# File 'lib/redfish_client/connector.rb', line 179

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

#patch(path, data = nil, **options) ⇒ Response

Issue PATCH requests to the service with optional ETag support.

Parameters:

  • path (String) —

    path to the resource, relative to the base

  • data (Hash) (defaults to: nil) —

    data to be sent over the socket

  • options (Hash) —

    optional parameters including :etag

Returns:



123
124
125
 
# File 'lib/redfish_client/connector.rb', line 123

def patch(path, data = nil, **options)
  etag_handler(path, data, options[:etag])
end

#post(path, data = nil) ⇒ Response

Issue POST requests to the service.

Parameters:

  • path (String) —

    path to the resource, relative to the base

  • data (Hash) (defaults to: nil) —

    data to be sent over the socket, JSON encoded

Returns:



113
114
115
 
# File 'lib/redfish_client/connector.rb', line 113

def post(path, data = nil)
  request(:post, path, data)
end

#remove_headers(headers) ⇒ Object

Remove HTTP headers from requests made by the connector.

Headers that are not currently set are silently ignored and no error is raised.

Parameters:

  • headers (List<String>) —

    headers to remove



78
79
80
 
# File 'lib/redfish_client/connector.rb', line 78

def remove_headers(headers)
  headers.each { |h| @headers.delete(h) }
end

#request(method, path, data = nil) ⇒ Response

Issue requests to the service.

Parameters:

  • mathod (Symbol) —

    HTTP method (:get, :post, :patch or :delete)

  • path (String) —

    path to the resource, relative to the base

  • data (Hash) (defaults to: nil) —

    data to be sent over the socket

Returns:



88
89
90
91
92
93
94
 
# File 'lib/redfish_client/connector.rb', line 88

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

#reset(path = nil) ⇒ Object

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.

Parameters:

  • path (String) (defaults to: nil) —

    path to invalidate



143
144
145
 
# File 'lib/redfish_client/connector.rb', line 143

def reset(path = nil)
  path.nil? ? @cache.clear : @cache.delete(path)
end

#set_auth_info(username, password, auth_test_path, session_path = nil) ⇒ Object

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.

Parameters:

  • username (String) —

    API username

  • password (String) —

    API password

  • auth_test_path (String) —

    API path to test credential's validity

  • session_path (String, nil) (defaults to: nil) —

    API session path



160
161
162
163
164
165
 
# File 'lib/redfish_client/connector.rb', line 160

def set_auth_info(username, password, auth_test_path, session_path = nil)
  @username = username
  @password = password
  @auth_test_path = auth_test_path
  @session_path = @use_session ? session_path : nil
end