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"

Instance Method Summary collapse

Constructor Details

#initialize(url, verify: true, cache: nil) ⇒ 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

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

    cache backend



50
51
52
53
54
55
56
57
58
59
 
# File 'lib/redfish_client/connector.rb', line 50

def initialize(url, verify: true, cache: nil)
  @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
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



64
65
66
 
# File 'lib/redfish_client/connector.rb', line 64

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:



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

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:



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

def get(path)
  return @cache[path] if @cache[path]

  request(:get, path).tap { |r| @cache[path] = r if r.status == 200 }
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:



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

def 
  @session_path ?  : 
end

#logout ⇒ Object

Sign out of the service.



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

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) ⇒ Response

Issue PATCH 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

Returns:



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

def patch(path, data = nil)
  request(:patch, path, data)
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



74
75
76
 
# File 'lib/redfish_client/connector.rb', line 74

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:



84
85
86
87
88
89
90
91
92
 
# File 'lib/redfish_client/connector.rb', line 84

def request(method, path, data = nil)
  params = prepare_request_params(method, path, data)
  r = @connection.request(params)
  if r.status == 401
    
    r = @connection.request(params)
  end
  Response.new(r.status, downcase_headers(r.data[:headers]), r.data[:body])
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



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

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



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

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