supermicro 0.1.0

data/lib/supermicro/tasks.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative 'spinner'
+
+module Supermicro
+  module Tasks
+    include SpinnerHelper
+    
+    def poll_task(task_location, timeout: 30, show_progress: true)
+      debug "Polling task: #{task_location}", 2
+      
+      start_time = Time.now
+      last_percent = 0
+      task_name = task_location.split('/').last
+      
+      # Use spinner if not in verbose mode
+      if show_progress && (!respond_to?(:verbosity) || verbosity == 0)
+        spinner = Spinner.new("Processing task #{task_name}", type: :dots, color: :cyan)
+        spinner.start
+      else
+        spinner = nil
+      end
+      
+      begin
+        while (Time.now - start_time) < timeout
+          task_response = authenticated_request(:get, task_location)
+          
+          # TaskMonitor returns 202 while running, then eventually returns the actual task
+          if task_response.status == 202
+            # Try to parse the 202 response for any status info
+            begin
+              if task_response.body && !task_response.body.empty?
+                monitor_data = JSON.parse(task_response.body)
+                if monitor_data['TaskState']
+                  # We got task info even with 202
+                  task_info = monitor_data
+                  # Process it below
+                else
+                  spinner&.update("Waiting for task to start...")
+                  debug "  Task pending (202 status)...", 3
+                  sleep 1
+                  next
+                end
+              else
+                spinner&.update("Task initializing...")
+                debug "  Task still initializing...", 3
+                sleep 1
+                next
+              end
+            rescue JSON::ParserError
+              spinner&.update("Task running...")
+              debug "  Task running (202)...", 3
+              sleep 1
+              next
+            end
+          elsif task_response.status == 200
+            begin
+              task_info = JSON.parse(task_response.body)
+            rescue JSON::ParserError => e
+              debug "Could not parse task response: #{e.message}", 2, :yellow
+              sleep 1
+              next
+            end
+          else
+            debug "Unexpected task response: #{task_response.status}", 2, :yellow
+            sleep 1
+            next
+          end
+          
+          # Process task_info if we have it
+          if defined?(task_info) && task_info && task_info['TaskState']
+            percent = task_info['PercentComplete'] || 0
+            if percent > 0 && percent != last_percent
+              spinner&.update("Task progress: #{percent}%")
+              debug "  Task progress: #{percent}%", 2
+              last_percent = percent
+            end
+            
+            case task_info['TaskState']
+            when 'Completed'
+              spinner&.stop("Task completed successfully", success: true)
+              debug "✓ Task completed successfully", 2, :green
+              return { success: true, task: task_info }
+            when 'Exception', 'Killed', 'Cancelled'
+              spinner&.stop("Task failed: #{task_info['TaskState']}", success: false)
+              debug "✗ Task failed: #{task_info['TaskState']}", 1, :red
+              if task_info['Messages']
+                task_info['Messages'].each do |msg|
+                  debug "  #{msg['Message']}", 1, :red
+                end
+              end
+              return { success: false, task: task_info }
+            when 'Running', 'Starting', 'Pending', 'New'
+              # Still running
+              state_msg = task_info['TaskState'] == 'Running' ? "Running" : "Starting"
+              spinner&.update("Task #{state_msg.downcase}...")
+              debug "  Task state: #{task_info['TaskState']}", 3
+            else
+              spinner&.update("Task state: #{task_info['TaskState']}")
+              debug "  Unknown task state: #{task_info['TaskState']}", 2, :yellow
+            end
+          end
+          
+          sleep 1
+        end
+        
+        spinner&.stop("Task timed out after #{timeout} seconds", success: false)
+        debug "Task polling timed out after #{timeout} seconds", 1, :yellow
+        { success: false, error: 'timeout' }
+      ensure
+        spinner&.stop if spinner
+      end
+    end
+    
+    def wait_for_task_completion(response, timeout: 30)
+      return { success: true } unless response.status == 202
+      
+      # Get task location from response
+      task_location = response.headers['Location'] || response.headers['location']
+      
+      if !task_location && response.body && !response.body.empty?
+        begin
+          task_data = JSON.parse(response.body)
+          task_location = task_data['@odata.id'] || task_data['TaskMonitor']
+        rescue JSON::ParserError
+          # No task info in body
+        end
+      end
+      
+      if task_location
+        debug "Task started: #{task_location}", 2
+        poll_task(task_location, timeout: timeout)
+      else
+        debug "No task location found, assuming synchronous completion", 2
+        { success: true }
+      end
+    end
+  end
+end

data/lib/supermicro/utility.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'colorize'
+
+module Supermicro
+  module Utility
+    def sel_log
+      response = authenticated_request(:get, "/redfish/v1/Managers/1/LogServices/SEL/Entries?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          entries = data["Members"]&.map do |entry|
+            {
+              "id" => entry["Id"],
+              "name" => entry["Name"],
+              "created" => entry["Created"],
+              "severity" => entry["Severity"],
+              "message" => entry["Message"],
+              "message_id" => entry["MessageId"],
+              "sensor_type" => entry["SensorType"],
+              "sensor_number" => entry["SensorNumber"]
+            }
+          end || []
+          
+          return entries.sort_by { |e| e["created"] || "" }.reverse
+        rescue JSON::ParserError
+          raise Error, "Failed to parse SEL log response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get SEL log. Status code: #{response.status}"
+      end
+    end
+
+    def clear_sel_log
+      puts "Clearing System Event Log...".yellow
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Managers/1/LogServices/SEL/Actions/LogService.ClearLog",
+        body: {}.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "SEL cleared successfully.".green
+        return true
+      else
+        raise Error, "Failed to clear SEL: #{response.status} - #{response.body}"
+      end
+    end
+
+    def sel_summary(limit: 10)
+      puts "\n=== System Event Log ===".green
+      
+      entries = sel_log
+      
+      if entries.empty?
+        puts "No log entries found.".yellow
+        return entries
+      end
+      
+      puts "Total entries: #{entries.length}".cyan
+      puts "\nMost recent #{limit} entries:".cyan
+      
+      entries.first(limit).each do |entry|
+        severity_color = case entry["severity"]
+                        when "Critical" then :red
+                        when "Warning" then :yellow
+                        when "OK" then :green
+                        else :white
+                        end
+        
+        puts "\n[#{entry['created']}] #{entry['severity']}".send(severity_color)
+        puts "  #{entry['message']}"
+        puts "  ID: #{entry['id']} | MessageID: #{entry['message_id']}" if entry['message_id']
+      end
+      
+      entries
+    end
+
+    def accounts
+      response = authenticated_request(:get, "/redfish/v1/AccountService/Accounts?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          accounts = data["Members"]&.map do |account|
+            {
+              "id" => account["Id"],
+              "username" => account["UserName"],
+              "enabled" => account["Enabled"],
+              "locked" => account["Locked"],
+              "role_id" => account["RoleId"],
+              "description" => account["Description"]
+            }
+          end || []
+          
+          return accounts
+        rescue JSON::ParserError
+          raise Error, "Failed to parse accounts response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get accounts. Status code: #{response.status}"
+      end
+    end
+
+    def create_account(username:, password:, role: "Administrator")
+      puts "Creating account #{username} with role #{role}...".yellow
+      
+      body = {
+        "UserName" => username,
+        "Password" => password,
+        "RoleId" => role,
+        "Enabled" => true
+      }
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/AccountService/Accounts",
+        body: body.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "Account created successfully.".green
+        return true
+      else
+        raise Error, "Failed to create account: #{response.status} - #{response.body}"
+      end
+    end
+
+    def delete_account(username)
+      accounts_list = accounts
+      account = accounts_list.find { |a| a["username"] == username }
+      
+      unless account
+        raise Error, "Account #{username} not found"
+      end
+      
+      puts "Deleting account #{username}...".yellow
+      
+      response = authenticated_request(
+        :delete,
+        "/redfish/v1/AccountService/Accounts/#{account["id"]}"
+      )
+      
+      if response.status.between?(200, 299)
+        puts "Account deleted successfully.".green
+        return true
+      else
+        raise Error, "Failed to delete account: #{response.status} - #{response.body}"
+      end
+    end
+
+    def update_account_password(username:, new_password:)
+      accounts_list = accounts
+      account = accounts_list.find { |a| a["username"] == username }
+      
+      unless account
+        raise Error, "Account #{username} not found"
+      end
+      
+      puts "Updating password for account #{username}...".yellow
+      
+      body = {
+        "Password" => new_password
+      }
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/AccountService/Accounts/#{account["id"]}",
+        body: body.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "Password updated successfully.".green
+        return true
+      else
+        raise Error, "Failed to update password: #{response.status} - #{response.body}"
+      end
+    end
+
+    def sessions
+      response = authenticated_request(:get, "/redfish/v1/SessionService/Sessions?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          sessions = data["Members"]&.map do |session|
+            {
+              "id" => session["Id"],
+              "username" => session["UserName"],
+              "created_time" => session["CreatedTime"],
+              "client_ip" => session.dig("Oem", "Supermicro", "ClientIP") || session["ClientOriginIPAddress"]
+            }
+          end || []
+          
+          return sessions
+        rescue JSON::ParserError
+          raise Error, "Failed to parse sessions response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get sessions. Status code: #{response.status}"
+      end
+    end
+
+    def service_info
+      response = authenticated_request(:get, "/redfish/v1")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          {
+            "service_version" => data["RedfishVersion"],
+            "uuid" => data["UUID"],
+            "product" => data["Product"],
+            "vendor" => data["Vendor"],
+            "oem" => data["Oem"]
+          }
+        rescue JSON::ParserError
+          raise Error, "Failed to parse service info response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get service info. Status code: #{response.status}"
+      end
+    end
+  end
+end

data/lib/supermicro/version.rb

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