supermicro 0.1.7 → 0.1.9

data/lib/supermicro/jobs.rb

@@ -6,28 +6,49 @@ require 'colorize'
 module Supermicro
   module Jobs
     def jobs
-      response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks?$expand=*($levels=1)")
+      tasks = jobs_detail
+      
+      # Return summary format consistent with iDRAC
+      {
+        completed_count: tasks.count { |t| t["state"] == "Completed" },
+        incomplete_count: tasks.count { |t| t["state"] != "Completed" },
+        total_count: tasks.count
+      }
+    end
+    
+    def jobs_detail
+      response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks")
       
       if response.status == 200
         begin
           data = JSON.parse(response.body)
+          members = data["Members"] || []
           
-          tasks = data["Members"]&.map do |task|
-            {
-              "id" => task["Id"],
-              "name" => task["Name"],
-              "state" => task["TaskState"],
-              "status" => task["TaskStatus"],
-              "percent_complete" => task["PercentComplete"] || task.dig("Oem", "Supermicro", "PercentComplete"),
-              "start_time" => task["StartTime"],
-              "end_time" => task["EndTime"],
-              "messages" => task["Messages"]
-            }
-          end || []
+          # Supermicro doesn't support expand, so fetch each task individually
+          tasks = members.map do |member|
+            task_id = member["@odata.id"].split('/').last
+            task_response = authenticated_request(:get, member["@odata.id"])
+            
+            if task_response.status == 200
+              task = JSON.parse(task_response.body)
+              {
+                "id" => task["Id"],
+                "name" => task["Name"],
+                "state" => task["TaskState"],
+                "status" => task["TaskStatus"],
+                "percent_complete" => task["PercentComplete"],
+                "start_time" => task["StartTime"],
+                "end_time" => task["EndTime"],
+                "messages" => task["Messages"]
+              }
+            else
+              nil
+            end
+          end.compact
           
           return tasks
         rescue JSON::ParserError
-          raise Error, "Failed to parse tasks response: #{response.body}"
+          raise Error, "Failed to parse tasks response"
         end
       else
         []
@@ -116,42 +137,49 @@ module Supermicro
       end
     end
 
-    def clear_completed_jobs
-      all_jobs = jobs
-      completed = all_jobs.select { |j| j["state"] == "Completed" }
+    def clear_jobs!
+      # Note: Supermicro doesn't actually delete tasks - DELETE just marks them as "Killed"
+      # The BMC maintains a rolling buffer of tasks (typically ~28-30) with oldest being overwritten
+      # This method will "kill" any running tasks but won't remove them from the list
       
-      if completed.empty?
-        puts "No completed jobs to clear.".yellow
+      response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks")
+      return true unless response.status == 200
+      
+      data = JSON.parse(response.body)
+      members = data["Members"] || []
+      
+      if members.empty?
+        puts "No jobs to clear.".yellow
         return true
       end
       
-      puts "Clearing #{completed.length} completed jobs...".yellow
-      
-      success = true
-      completed.each do |job|
-        begin
-          response = authenticated_request(
-            :delete,
-            "/redfish/v1/TaskService/Tasks/#{job["id"]}"
-          )
-          
-          if response.status.between?(200, 299)
-            puts "  Cleared: #{job["name"]} (#{job["id"]})".green
-          else
-            puts "  Failed to clear: #{job["name"]} (#{job["id"]})".red
-            success = false
+      # Only try to kill tasks that are actually running
+      running_count = 0
+      members.each do |member|
+        task_id = member["@odata.id"].split('/').last
+        task_response = authenticated_request(:get, member["@odata.id"])
+        
+        if task_response.status == 200
+          task = JSON.parse(task_response.body)
+          if ["Running", "Starting", "New", "Pending"].include?(task["TaskState"])
+            running_count += 1
+            puts "Killing task #{task_id}: #{task['Name']} (#{task['TaskState']})".yellow
+            authenticated_request(:delete, member["@odata.id"])
           end
-        rescue => e
-          puts "  Error clearing #{job["id"]}: #{e.message}".red
-          success = false
         end
       end
       
-      success
+      if running_count > 0
+        puts "Killed #{running_count} running tasks.".green
+      else
+        puts "No running tasks to kill (#{members.length} completed/killed tasks remain in history).".yellow
+      end
+      
+      true
     end
 
     def jobs_summary
-      all_jobs = jobs
+      all_jobs = jobs_detail
       
       puts "\n=== Jobs Summary ===".green
       

data/lib/supermicro/network.rb

@@ -11,21 +11,25 @@ module Supermicro
       if response.status == 200
         data = JSON.parse(response.body)
         {
-          "ipv4_address" => data.dig("IPv4Addresses", 0, "Address"),
-          "subnet_mask" => data.dig("IPv4Addresses", 0, "SubnetMask"),
+          "ipv4" => data.dig("IPv4Addresses", 0, "Address"),
+          "mask" => data.dig("IPv4Addresses", 0, "SubnetMask"),
           "gateway" => data.dig("IPv4Addresses", 0, "Gateway"),
           "mode" => data.dig("IPv4Addresses", 0, "AddressOrigin"), # DHCP or Static
-          "mac_address" => data["MACAddress"],
+          "mac" => data["MACAddress"],
           "hostname" => data["HostName"],
           "fqdn" => data["FQDN"],
-          "dns_servers" => data["NameServers"] || []
+          "dns_servers" => data["NameServers"] || [],
+          "name" => data["Id"] || "BMC",
+          "speed_mbps" => data["SpeedMbps"] || 1000,
+          "status" => data.dig("Status", "Health") || "OK",
+          "kind" => "ethernet"
         }
       else
         raise Error, "Failed to get BMC network config. Status: #{response.status}"
       end
     end
     
-    def set_bmc_network(ip_address: nil, subnet_mask: nil, gateway: nil, 
+    def set_bmc_network(ipv4: nil, mask: nil, gateway: nil, 
                         dns_primary: nil, dns_secondary: nil, hostname: nil, 
                         dhcp: false, wait: true)
       
@@ -41,15 +45,15 @@ module Supermicro
         body = {}
         
         # Configure static IP if provided
-        if ip_address && subnet_mask
+        if ipv4 && mask
           # Must explicitly disable DHCP when setting static IP
           body["DHCPv4"] = { "DHCPEnabled" => false }
           body["IPv4StaticAddresses"] = [{
-            "Address" => ip_address,
-            "SubnetMask" => subnet_mask,
+            "Address" => ipv4,
+            "SubnetMask" => mask,
             "Gateway" => gateway
           }]
-          puts "  IP: #{ip_address}/#{subnet_mask}".cyan
+          puts "  IP: #{ipv4}/#{mask}".cyan
           puts "  Gateway: #{gateway}".cyan if gateway
         end
         

data/lib/supermicro/storage.rb

@@ -6,17 +6,37 @@ require 'colorize'
 module Supermicro
   module Storage
     def storage_controllers
-      response = authenticated_request(:get, "/redfish/v1/Systems/1/Storage?$expand=*($levels=1)")
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Storage")
       
       if response.status == 200
         begin
           data = JSON.parse(response.body)
           
-          controllers = data["Members"].map do |controller|
-            {
+          controllers = data["Members"].map do |member|
+            # If member is just a reference, fetch the full data
+            if member["@odata.id"] && !member["Id"]
+              controller_path = member["@odata.id"]
+              controller_response = authenticated_request(:get, controller_path)
+              
+              if controller_response.status == 200
+                controller = JSON.parse(controller_response.body)
+              else
+                next nil
+              end
+            else
+              controller = member
+            end
+            
+            controller_data = {
               "id" => controller["Id"],
               "name" => controller["Name"],
+              # Extract model from first StorageController entry
+              "model" => controller.dig("StorageControllers", 0, "Model") || controller["Name"],
+              "firmware_version" => controller.dig("StorageControllers", 0, "FirmwareVersion"),
               "status" => controller.dig("Status", "Health") || "N/A",
+              "drives_count" => controller["Drives"]&.size || 0,
+              "@odata.id" => controller["@odata.id"],
+              # Include full storage controller info for reference
               "storage_controllers" => controller["StorageControllers"]&.map { |sc|
                 {
                   "name" => sc["Name"],
@@ -28,7 +48,16 @@ module Supermicro
                 }
               }
             }
-          end
+            
+            # Fetch drives for this controller
+            if controller["Drives"] && !controller["Drives"].empty?
+              controller_data["drives"] = fetch_controller_drives(controller["Id"], controller["Drives"])
+            else
+              controller_data["drives"] = []
+            end
+            
+            controller_data
+          end.compact
           
           return controllers
         rescue JSON::ParserError
@@ -38,94 +67,158 @@ module Supermicro
         raise Error, "Failed to get storage controllers. Status code: #{response.status}"
       end
     end
+    
+    private
+    
+    def fetch_controller_drives(controller_id, drive_refs)
+      drives = []
+      
+      drive_refs.each do |drive_ref|
+        drive_path = drive_ref["@odata.id"]
+        drive_response = authenticated_request(:get, drive_path)
+        
+        if drive_response.status == 200
+          drive_data = JSON.parse(drive_response.body)
+          
+          drives << {
+            "id" => drive_data["Id"],
+            "name" => drive_data["Name"],
+            "serial" => drive_data["SerialNumber"],
+            "manufacturer" => drive_data["Manufacturer"],
+            "model" => drive_data["Model"],
+            "revision" => drive_data["Revision"],
+            "capacity_bytes" => drive_data["CapacityBytes"],
+            "speed_gbps" => drive_data["CapableSpeedGbs"] || drive_data["NegotiatedSpeedGbs"],
+            "rotation_speed_rpm" => drive_data["RotationSpeedRPM"],
+            "media_type" => drive_data["MediaType"],
+            "protocol" => drive_data["Protocol"],
+            "health" => drive_data.dig("Status", "Health") || "N/A",
+            "temperature_celsius" => drive_data.dig("Oem", "Supermicro", "Temperature"),
+            "failure_predicted" => drive_data["FailurePredicted"],
+            "life_left_percent" => drive_data["PredictedMediaLifeLeftPercent"]
+          }
+        end
+      end
+      
+      drives
+    end
+    
+    public
 
-    def drives
-      all_drives = []
+    def drives(controller_id)
+      # Following natural Redfish pattern - drives are scoped to a controller
+      raise ArgumentError, "Controller ID is required" unless controller_id
       
-      controllers = storage_controllers
+      drives = []
       
-      controllers.each do |controller|
-        controller_id = controller["id"]
-        
-        response = authenticated_request(:get, "/redfish/v1/Systems/1/Storage/#{controller_id}")
-        
-        if response.status == 200
-          begin
-            data = JSON.parse(response.body)
-            
-            if data["Drives"]
-              data["Drives"].each do |drive_ref|
-                drive_path = drive_ref["@odata.id"]
-                drive_response = authenticated_request(:get, drive_path)
+      # Extract just the controller ID if given full path
+      controller_name = controller_id.split('/').last
+      
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Storage/#{controller_name}")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          if data["Drives"]
+            data["Drives"].each do |drive_ref|
+              drive_path = drive_ref["@odata.id"]
+              drive_response = authenticated_request(:get, drive_path)
+              
+              if drive_response.status == 200
+                drive_data = JSON.parse(drive_response.body)
                 
-                if drive_response.status == 200
-                  drive_data = JSON.parse(drive_response.body)
-                  
-                  all_drives << {
-                    "id" => drive_data["Id"],
-                    "name" => drive_data["Name"],
-                    "manufacturer" => drive_data["Manufacturer"],
-                    "model" => drive_data["Model"],
-                    "serial" => drive_data["SerialNumber"],
-                    "capacity_bytes" => drive_data["CapacityBytes"],
-                    "capacity_gb" => (drive_data["CapacityBytes"].to_f / 1_000_000_000).round(2),
-                    "protocol" => drive_data["Protocol"],
-                    "media_type" => drive_data["MediaType"],
-                    "status" => drive_data.dig("Status", "Health") || "N/A",
-                    "controller" => controller_id,
-                    "firmware_version" => drive_data["Revision"],
-                    "rotation_speed_rpm" => drive_data["RotationSpeedRPM"],
-                    "predicted_media_life_left_percent" => drive_data["PredictedMediaLifeLeftPercent"]
-                  }
-                end
+                drives << {
+                  "id" => drive_data["Id"],
+                  "name" => drive_data["Name"],
+                  "serial" => drive_data["SerialNumber"],
+                  "manufacturer" => drive_data["Manufacturer"],
+                  "model" => drive_data["Model"],
+                  "revision" => drive_data["Revision"],
+                  "capacity_bytes" => drive_data["CapacityBytes"],
+                  "capacity_gb" => (drive_data["CapacityBytes"].to_f / (1000**3)).round(2),
+                  "speed_gbps" => drive_data["CapableSpeedGbs"] || drive_data["NegotiatedSpeedGbs"],
+                  "rotation_speed_rpm" => drive_data["RotationSpeedRPM"],
+                  "media_type" => drive_data["MediaType"],
+                  "protocol" => drive_data["Protocol"],
+                  "status" => drive_data.dig("Status", "Health") || "N/A",
+                  "health" => drive_data.dig("Status", "Health") || "N/A",
+                  "temperature_celsius" => drive_data.dig("Oem", "Supermicro", "Temperature"),
+                  "failure_predicted" => drive_data["FailurePredicted"],
+                  "life_left_percent" => drive_data["PredictedMediaLifeLeftPercent"],
+                  "certified" => drive_data.dig("Oem", "Supermicro", "Certified"),
+                  "@odata.id" => drive_data["@odata.id"]
+                }
               end
             end
-          rescue JSON::ParserError
-            debug "Failed to parse storage data for controller #{controller_id}", 1, :yellow
           end
+        rescue JSON::ParserError
+          debug "Failed to parse storage data for controller #{controller_name}", 1, :yellow
         end
+      else
+        raise Error, "Failed to get drives for controller #{controller_name}. Status: #{response.status}"
       end
       
-      return all_drives
+      return drives
     end
 
-    def volumes
-      all_volumes = []
+    def volumes(controller_id)
+      # Following natural Redfish pattern - volumes are scoped to a controller
+      raise ArgumentError, "Controller ID is required" unless controller_id
       
-      controllers = storage_controllers
+      volumes = []
       
-      controllers.each do |controller|
-        controller_id = controller["id"]
-        
-        response = authenticated_request(:get, "/redfish/v1/Systems/1/Storage/#{controller_id}/Volumes?$expand=*($levels=1)")
-        
-        if response.status == 200
-          begin
-            data = JSON.parse(response.body)
-            
-            if data["Members"]
-              data["Members"].each do |volume|
-                all_volumes << {
-                  "id" => volume["Id"],
-                  "name" => volume["Name"],
-                  "capacity_bytes" => volume["CapacityBytes"],
-                  "capacity_gb" => (volume["CapacityBytes"].to_f / 1_000_000_000).round(2),
-                  "volume_type" => volume["VolumeType"],
-                  "raid_type" => volume["RAIDType"],
-                  "status" => volume.dig("Status", "Health") || "N/A",
-                  "controller" => controller_id,
-                  "encrypted" => volume["Encrypted"],
-                  "optimum_io_size_bytes" => volume["OptimumIOSizeBytes"]
-                }
+      # Extract just the controller ID if given full path
+      controller_name = controller_id.split('/').last
+      
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Storage/#{controller_name}/Volumes")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          if data["Members"]
+            data["Members"].each do |volume_ref|
+              # Check if it's a reference or the actual volume data
+              if volume_ref["@odata.id"]
+                # It's a reference, fetch the volume
+                volume_path = volume_ref["@odata.id"]
+                volume_response = authenticated_request(:get, volume_path)
+                
+                if volume_response.status == 200
+                  volume = JSON.parse(volume_response.body)
+                else
+                  next
+                end
+              else
+                # It's the actual volume data
+                volume = volume_ref
               end
+              
+              volumes << {
+                "id" => volume["Id"],
+                "name" => volume["Name"],
+                "capacity_bytes" => volume["CapacityBytes"],
+                "capacity_gb" => (volume["CapacityBytes"].to_f / (1000**3)).round(2),
+                "volume_type" => volume["VolumeType"],
+                "raid_type" => volume["RAIDType"],
+                "status" => volume.dig("Status", "Health") || "N/A",
+                "health" => volume.dig("Status", "Health") || "N/A",
+                "encrypted" => volume["Encrypted"],
+                "optimum_io_size_bytes" => volume["OptimumIOSizeBytes"],
+                "@odata.id" => volume["@odata.id"]
+              }
             end
-          rescue JSON::ParserError
-            debug "Failed to parse volumes data for controller #{controller_id}", 1, :yellow
           end
+        rescue JSON::ParserError
+          debug "Failed to parse volumes data for controller #{controller_name}", 1, :yellow
         end
+      else
+        # Some controllers may not have volumes endpoint
+        debug "No volumes endpoint for controller #{controller_name} (Status: #{response.status})", 2, :yellow
       end
       
-      return all_volumes
+      return volumes
     end
 
     def storage_summary
@@ -144,7 +237,13 @@ module Supermicro
         end
       end
       
-      all_drives = drives
+      # Get all drives from all controllers
+      all_drives = []
+      controllers.each do |controller|
+        controller_drives = drives(controller["@odata.id"] || "/redfish/v1/Systems/1/Storage/#{controller['id']}")
+        all_drives.concat(controller_drives) if controller_drives
+      end
+      
       puts "\nPhysical Drives:".cyan
       all_drives.each do |drive|
         puts "  #{drive['name']} (#{drive['id']})".yellow
@@ -158,7 +257,13 @@ module Supermicro
         end
       end
       
-      all_volumes = volumes
+      # Get all volumes from all controllers
+      all_volumes = []
+      controllers.each do |controller|
+        controller_volumes = volumes(controller["@odata.id"] || "/redfish/v1/Systems/1/Storage/#{controller['id']}")
+        all_volumes.concat(controller_volumes) if controller_volumes
+      end
+      
       if all_volumes.any?
         puts "\nVolumes:".cyan
         all_volumes.each do |volume|