Class: IDRAC::Session

Inherits:
Object
  • Object
show all
Includes:
Debuggable
Defined in:
lib/idrac/session.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Debuggable

#debug

Constructor Details

#initialize(client) ⇒ Session

Returns a new instance of Session.



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/idrac/session.rb', line 17

def initialize(client)
  @client = client
  @host = client.host
  @username = client.username
  @password = client.password
  @port = client.port
  @use_ssl = client.use_ssl
  @verify_ssl = client.verify_ssl
  @x_auth_token = nil
  @session_location = nil
  @direct_mode = client.direct_mode
  @sessions_maxed = false
  @auto_delete_sessions = client.auto_delete_sessions
  @verbosity = client.respond_to?(:verbosity) ? client.verbosity : 0
end

Instance Attribute Details

#auto_delete_sessions ⇒ Object (readonly)

Returns the value of attribute auto_delete_sessions.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def auto_delete_sessions
  @auto_delete_sessions
end

#direct_mode ⇒ Object (readonly)

Returns the value of attribute direct_mode.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def direct_mode
  @direct_mode
end

#host ⇒ Object (readonly)

Returns the value of attribute host.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def host
  @host
end

#password ⇒ Object (readonly)

Returns the value of attribute password.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def password
  @password
end

#port ⇒ Object (readonly)

Returns the value of attribute port.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def port
  @port
end

#session_location ⇒ Object (readonly)

Returns the value of attribute session_location.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def session_location
  @session_location
end

#use_ssl ⇒ Object (readonly)

Returns the value of attribute use_ssl.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def use_ssl
  @use_ssl
end

#username ⇒ Object (readonly)

Returns the value of attribute username.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def username
  @username
end

#verbosity ⇒ Object

Returns the value of attribute verbosity.



13
14
15
 
# File 'lib/idrac/session.rb', line 13

def verbosity
  @verbosity
end

#verify_ssl ⇒ Object (readonly)

Returns the value of attribute verify_ssl.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def verify_ssl
  @verify_ssl
end

#x_auth_token ⇒ Object (readonly)

Returns the value of attribute x_auth_token.



11
12
13
 
# File 'lib/idrac/session.rb', line 11

def x_auth_token
  @x_auth_token
end

Instance Method Details

#connection ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/idrac/session.rb', line 33

def connection
  @connection ||= Faraday.new(url: base_url, ssl: { 
    verify: verify_ssl
    # Keep SSL settings minimal for cross-version compatibility
  }) do |faraday|
    faraday.request :multipart
    faraday.request :url_encoded
    faraday.adapter Faraday.default_adapter
    # Add request/response logging
    if @verbosity > 0
      faraday.response :logger, Logger.new(STDOUT), bodies: @verbosity >= 2 do |logger|
        logger.filter(/(Authorization: Basic )([^,\n]+)/, '\1[FILTERED]')
        logger.filter(/(Password"=>"?)([^,"]+)/, '\1[FILTERED]')
      end
    end
  end
end

#create ⇒ Object

Create a Redfish session



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/idrac/session.rb', line 177

def create
  # Skip if we're in direct mode
  if @direct_mode
    debug "Skipping Redfish session creation (direct mode)", 1, :light_yellow
    return false
  end
  
  # Determine the correct session endpoint based on Redfish version
  session_endpoint = determine_session_endpoint
  
  payload = { "UserName" => username, "Password" => password }
  
  debug "Attempting to create Redfish session at #{base_url}#{session_endpoint}", 1
  debug "SSL verification: #{verify_ssl ? 'Enabled' : 'Disabled'}", 1
  print_connection_debug_info if @verbosity >= 2
  
  # Try creation methods in sequence
  return true if create_session_with_content_type(session_endpoint, payload)
  return true if create_session_with_basic_auth(session_endpoint, payload)
  return true if handle_max_sessions_and_retry(session_endpoint, payload)
  return true if create_session_with_form_urlencoded(session_endpoint, payload)
  
  # If all attempts fail, switch to direct mode
  @direct_mode = true
  false
end

#delete ⇒ Object

Delete the Redfish session



205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
 
# File 'lib/idrac/session.rb', line 205

def delete
  return false unless @x_auth_token || @session_location
  
  begin
    debug "Deleting Redfish session...", 1
    
    if @session_location
      # Use the X-Auth-Token for authentication
      headers = { 'X-Auth-Token' => @x_auth_token }
      
      begin
        response = connection.delete(@session_location) do |req|
          req.headers.merge!(headers)
        end
        
        if response.status == 200 || response.status == 204
          debug "Redfish session deleted successfully", 1, :green
          @x_auth_token = nil
          @session_location = nil
          return true
        end
      rescue => session_e
        debug "Error during session deletion via location: #{session_e.message}", 1, :yellow
        # Continue to try basic auth method
      end
    end
    
    # If deleting via session location fails or there's no session location,
    # try to delete by using the basic auth method
    if @x_auth_token
      # Try to determine session ID from the X-Auth-Token or session_location
      session_id = nil
      
      # Extract session ID from location if available
      if @session_location
        if @session_location =~ /\/([^\/]+)$/
          session_id = $1
        end
      end
      
      # If we have an extracted session ID
      if session_id
        debug "Trying to delete session by ID #{session_id}", 1
        
        begin
          endpoint = determine_session_endpoint
          delete_url = "#{endpoint}/#{session_id}"
          
          delete_response = request_with_basic_auth(:delete, delete_url, nil)
          
          if delete_response.status == 200 || delete_response.status == 204
            debug "Successfully deleted session via ID", 1, :green
            @x_auth_token = nil
            @session_location = nil
            return true
          end
        rescue => id_e
          debug "Error during session deletion via ID: #{id_e.message}", 1, :yellow
        end
      end
      
      # Last resort: clear the token variable even if we couldn't properly delete it
      debug "Clearing session token internally", 1, :yellow
      @x_auth_token = nil
      @session_location = nil
    end
    
    return false
  rescue => e
    debug "Error during Redfish session deletion: #{e.message}", 1, :red
    # Clear token variable anyway
    @x_auth_token = nil
    @session_location = nil
    return false
  end
end

#delete_all_sessions_with_basic_auth ⇒ Object

Delete all sessions using Basic Authentication



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/idrac/session.rb', line 80

def delete_all_sessions_with_basic_auth
  debug "Attempting to delete all sessions using Basic Authentication...", 1
  
  # First, get the list of sessions
  sessions_url = determine_session_endpoint
  
  begin
    # Get the list of sessions
    response = request_with_basic_auth(:get, sessions_url, nil, 'application/json')
    
    if response.status != 200
      debug "Failed to get sessions list: #{response.status} - #{response.body}", 1, :red
      # If we received HTML error, assume we can't get sessions and try direct session deletion
      if response.headers['content-type']&.include?('text/html') || response.body.to_s.include?('DOCTYPE html')
        debug "Received HTML error response, trying direct session deletion", 1, :light_yellow
        return try_delete_latest_sessions
      end
      return false
    end
    
    # Parse the response to get session IDs
    begin
      sessions_data = JSON.parse(response.body)
      
      if sessions_data['Members'] && sessions_data['Members'].any?
        debug "Found #{sessions_data['Members'].count} active sessions", 1, :light_yellow
        
        # Delete each session
        success = true
        sessions_data['Members'].each do |session|
          session_url = session['@odata.id']
          
          # Skip if no URL
          next unless session_url
          
          # Delete the session
          delete_response = request_with_basic_auth(:delete, session_url, nil, 'application/json')
          
          if delete_response.status == 200 || delete_response.status == 204
            debug "Successfully deleted session: #{session_url}", 1, :green
          else
            debug "Failed to delete session #{session_url}: #{delete_response.status}", 1, :red
            success = false
          end
          
          # Small delay between deletions
          sleep(1)
        end
        
        return success
      else
        debug "No active sessions found", 1, :light_yellow
        return true
      end
    rescue JSON::ParserError => e
      debug "Error parsing sessions response: #{e.message}", 1, :red
      debug "Trying direct session deletion", 1, :light_yellow
      return try_delete_latest_sessions
    end
  rescue => e
    debug "Error during session deletion with Basic Auth: #{e.message}", 1, :red
    debug "Trying direct session deletion", 1, :light_yellow
    return try_delete_latest_sessions
  end
end

#force_clear_sessions ⇒ Object

Force clear all sessions by directly using Basic Auth



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/idrac/session.rb', line 52

def force_clear_sessions
  debug "Attempting to force clear all sessions...", 1
  
  max_retries = 3
  retry_count = 0
  
  while retry_count < max_retries
    if delete_all_sessions_with_basic_auth
      debug "Successfully cleared sessions using Basic Auth", 1, :green
      return true
    else
      retry_count += 1
      if retry_count < max_retries
        # Exponential backoff
        sleep_time = 2 ** retry_count
        debug "Retrying session clear after #{sleep_time} seconds (attempt #{retry_count+1}/#{max_retries})", 1, :light_yellow
        sleep(sleep_time)
      else
        debug "Failed to clear sessions after #{max_retries} attempts", 1, :red
        return false
      end
    end
  end
  
  false
end

#try_delete_latest_sessions ⇒ Object

Try to delete sessions by direct URL when we can’t list sessions



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/idrac/session.rb', line 147

def try_delete_latest_sessions
  # Try to delete sessions by direct URL when we can't list sessions
  debug "Attempting to delete recent sessions directly...", 1
  base_url = determine_session_endpoint
  success = false
  
  # Try session IDs 1-10 (common for iDRAC)
  (1..10).each do |id|
    session_url = "#{base_url}/#{id}"
    begin
      delete_response = request_with_basic_auth(:delete, session_url, nil, 'application/json')
      
      if delete_response.status == 200 || delete_response.status == 204
        debug "Successfully deleted session: #{session_url}", 1, :green
        success = true
      else
        debug "Failed to delete session #{session_url}: #{delete_response.status}", 1, :red
      end
    rescue => e
      debug "Error deleting session #{session_url}: #{e.message}", 1, :red
    end
    
    # Small delay between deletions
    sleep(0.5)
  end
  
  return success
end