idrac 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03ccc12c3ebfe533e453933a630bc43624da934519341ac269babc529d47f19d
-  data.tar.gz: d143150b5233763300314b462ad01a8716725e46a884b1739e76566e38a9233a
+  metadata.gz: 0563eaa5f82230341766606c73b15cf2e850b45b1ef3859f2aaa9e49b9c65df9
+  data.tar.gz: 29ee247993cb532d71447b5fa5fff1406a91a2d553923cedd8e207eb5a0c9c4a
 SHA512:
-  metadata.gz: 1f23b2fe0d6ed9c150c60643b87ae046e4f67bca4bc249ed4a1761082c2793f11ac88998c33552951b3cebb35afae0826baff804463ed35c79a47f35d0174ed9
-  data.tar.gz: a4bada808af965d7b371be12e5758a5b2c220b66333505a7166ab9dceb048cc30907ef05c2da4a23cb821bf770fb145516998e6447898c4e91e44af486281193
+  metadata.gz: 351a3b5d3c973d7a7c4ec1767fbd73f46eea0149e713c29bea930974efae1a9c4eeda008ce964fcb307bca02d12571734cc96429fd5901fa4e4021f84bbab391
+  data.tar.gz: db4363923ae2e7581e55ff7622b75b889622f9e5aa04b8cfaf33b957c5015495cdbffb787dec8c56d28c86cd956fac4e24bd54331b7854a907cf75ad9e6008e0

data/bin/idrac

@@ -456,6 +456,145 @@ module IDRAC
       end
     end
 
+    desc "test:all", "Run tests for all major functionality areas"
+    map "test" => :test_all
+    option :quiet, type: :boolean, default: false, desc: "Minimize output, just show pass/fail"
+    option :skip_destructive, type: :boolean, default: true, desc: "Skip tests that could modify the system"
+    def test_all
+      quiet = options[:quiet]
+      skip_destructive = options[:skip_destructive]
+      
+      passed = []
+      failed = []
+      skipped = []
+      
+      tests = [
+        # Basic information
+        { name: "System Summary", method: -> (c) { c.summary } },
+        { name: "Redfish Version", method: -> (c) { c.redfish_version } },
+        
+        # Power methods
+        { name: "Power State", method: -> (c) { c.get_power_state } },
+        { name: "Power Usage", method: -> (c) { c.get_power_usage_watts } },
+        
+        # Jobs and lifecycle
+        { name: "Jobs List", method: -> (c) { c.jobs } },
+        { name: "Lifecycle Status", method: -> (c) { c.lifecycle_status } },
+        
+        # Storage
+        { name: "Storage Controller", method: -> (c) { c.controller } },
+        { name: "Physical Drives", method: -> (c) { controller = c.controller; c.drives(controller) } },
+        { name: "Virtual Disks", method: -> (c) { controller = c.controller; c.volumes(controller) } },
+        
+        # System components
+        { name: "Memory Info", method: -> (c) { c.memory } },
+        { name: "PSU Info", method: -> (c) { c.psus } },
+        { name: "Fan Info", method: -> (c) { c.fans } },
+        { name: "NIC Info", method: -> (c) { c.nics } },
+        { name: "PCI Devices", method: -> (c) { c.pci_devices } },
+        { name: "iDRAC Network", method: -> (c) { c.idrac_network } },
+        { name: "System Events", method: -> (c) { c.system_event_logs } },
+        
+        # Virtual media
+        { name: "Virtual Media Status", method: -> (c) { c.virtual_media } },
+        { name: "Boot Source", method: -> (c) { c.get_boot_source_override } },
+        
+        # Boot/BIOS
+        { name: "Boot Options", method: -> (c) { c.get_bios_boot_options } }
+      ]
+      
+      # Destructive tests - only run if explicitly enabled
+      destructive_tests = [
+        # Virtual media operations
+        { name: "Eject Virtual Media", method: -> (c) { c.eject_virtual_media } },
+        
+        # BIOS settings check (read-only but could affect future operations)
+        { name: "BIOS OS Power Control", method: -> (c) { c.set_bios_os_power_control } },
+      ]
+      
+      puts "======= iDRAC Functionality Test =======" unless quiet
+      puts "Testing #{tests.length} non-destructive operations" unless quiet
+      
+      with_idrac_client do |client|
+        begin
+          # Get firmware version first to help with diagnostics
+          firmware = client.get_firmware_version
+          puts "iDRAC Firmware: #{firmware}" unless quiet
+          
+          # Run all the standard tests
+          tests.each do |test|
+            test_name = test[:name]
+            
+            begin
+              puts "\nTesting: #{test_name}..." unless quiet
+              result = test[:method].call(client)
+              
+              if result || result.nil? # nil is fine for commands that just print
+                passed << test_name
+                puts "✅ #{test_name} - PASSED" unless quiet
+              else
+                failed << test_name
+                puts "❌ #{test_name} - FAILED" unless quiet
+              end
+            rescue => e
+              failed << test_name
+              puts "❌ #{test_name} - ERROR: #{e.message}" unless quiet
+              puts e.backtrace.join("\n") if options[:verbose]
+            end
+          end
+          
+          # Run destructive tests if enabled
+          unless skip_destructive
+            puts "\nTesting #{destructive_tests.length} potentially destructive operations" unless quiet
+            
+            destructive_tests.each do |test|
+              test_name = test[:name]
+              
+              begin
+                puts "\nTesting: #{test_name}..." unless quiet
+                result = test[:method].call(client)
+                
+                if result || result.nil?
+                  passed << test_name
+                  puts "✅ #{test_name} - PASSED" unless quiet
+                else
+                  failed << test_name
+                  puts "❌ #{test_name} - FAILED" unless quiet
+                end
+              rescue => e
+                failed << test_name
+                puts "❌ #{test_name} - ERROR: #{e.message}" unless quiet
+                puts e.backtrace.join("\n") if options[:verbose]
+              end
+            end
+          else
+            skipped = destructive_tests.map { |t| t[:name] }
+            puts "\nSkipped #{skipped.length} destructive tests" unless quiet
+          end
+        rescue => e
+          puts "Failed to initialize client: #{e.message}".red
+          puts e.backtrace.join("\n") if options[:verbose]
+          exit 1
+        end
+      end
+      
+      # Print summary
+      puts "\n======= Test Summary =======" 
+      puts "✅ PASSED: #{passed.length} tests"
+      
+      if failed.any?
+        puts "❌ FAILED: #{failed.length} tests"
+        puts failed.map { |name| "  - #{name}" }.join("\n")
+      end
+      
+      if skipped.any?
+        puts "⏭ SKIPPED: #{skipped.length} tests"
+        puts skipped.map { |name| "  - #{name}" }.join("\n") unless quiet
+      end
+      
+      exit(failed.empty? ? 0 : 1)
+    end
+
     # Storage commands
     desc "storage_controller", "Get storage controller information"
     map "storage:controller" => :storage_controller
@@ -477,6 +616,36 @@ module IDRAC
       end
     end
 
+    desc "storage_controllers", "Get all storage controllers information"
+    map "storage:controllers" => :storage_controllers
+    def storage_controllers
+      with_idrac_client do |client|
+        controllers = client.controllers
+        
+        puts "\nStorage Controllers Summary:".green.bold
+        puts "-" * 80
+        
+        controllers.each do |controller|
+          puts "Controller: #{controller[:name]}".cyan.bold
+          puts "  Model:           #{controller[:model]}"
+          puts "  Status:          #{controller[:status]}"
+          puts "  Drives:          #{controller[:drives_count]}"
+          puts "  Firmware:        #{controller[:firmware_version]}"
+          puts "  Type:            #{controller[:controller_type]}"
+          puts "  PCI Slot:        #{controller[:pci_slot]}"
+          
+          if controller[:encryption_capability]
+            puts "  Encryption:      #{controller[:encryption_capability]}"
+            puts "  Encryption Mode: #{controller[:encryption_mode] || 'Disabled'}"
+          end
+          
+          puts
+        end
+        
+        puts "Total controllers: #{controllers.size}".green
+      end
+    end
+
     desc "storage_drives", "Get physical drive information"
     map "storage:drives" => :storage_drives
     def storage_drives

data/lib/idrac/storage.rb

@@ -5,35 +5,60 @@ module IDRAC
   module StorageMethods
     # Get storage controllers information
     def controller
+      # Use the controllers method to get all controllers
+      controller_list = controllers
+      
+      puts "Controllers".green
+      controller_list.each { |c| puts "#{c[:name]} > #{c[:drives_count]}" }
+      
+      puts "Drives".green
+      controller_list.each do |c|
+        puts "Storage: #{c[:name]} > #{c[:status]} > #{c[:drives_count]}"
+      end
+      
+      # Find the controller with the most drives (usually the PERC)
+      controller_info = controller_list.max_by { |c| c[:drives_count] }
+      
+      if controller_info[:name] =~ /PERC/
+        puts "Found #{controller_info[:name]}".green
+      else
+        puts "Found #{controller_info[:name]} but continuing...".yellow
+      end
+      
+      # Return the raw controller data
+      controller_info[:raw]
+    end
+
+    # Get all storage controllers and return them as an array
+    def controllers
       response = authenticated_request(:get, '/redfish/v1/Systems/System.Embedded.1/Storage?$expand=*($levels=1)')
       
       if response.status == 200
         begin
           data = JSON.parse(response.body)
           
-          puts "Controllers".green
-          data["Members"].each { |ctrlr| puts "#{ctrlr["Name"]} > #{ctrlr["Drives@odata.count"]}" }
-          
-          puts "Drives".green
-          data["Members"].each do |m|
-            puts "Storage: #{m["Name"]} > #{m["Status"]["Health"] || "N/A"} > #{m["Drives"].size}"
-          end
-          
-          # Find the controller with the most drives (usually the PERC)
-          controller = data["Members"].sort_by { |ctrlr| ctrlr["Drives"].size }.last
-          
-          if controller["Name"] =~ /PERC/
-            puts "Found #{controller["Name"]}".green
-          else
-            puts "Found #{controller["Name"]} but continuing...".yellow
+          # Transform and return all controllers as an array of hashes with consistent keys
+          controllers = data["Members"].map do |controller|
+            {
+              name: controller["Name"],
+              model: controller["Model"],
+              drives_count: controller["Drives"].size,
+              status: controller["Status"]["Health"] || "N/A",
+              firmware_version: controller.dig("StorageControllers", 0, "FirmwareVersion"),
+              encryption_mode: controller.dig("Oem", "Dell", "DellController", "EncryptionMode"),
+              encryption_capability: controller.dig("Oem", "Dell", "DellController", "EncryptionCapability"),
+              controller_type: controller.dig("Oem", "Dell", "DellController", "ControllerType"),
+              pci_slot: controller.dig("Oem", "Dell", "DellController", "PCISlot"),
+              raw: controller
+            }
           end
           
-          return controller
+          return controllers.sort_by { |c| c[:name] }
         rescue JSON::ParserError
-          raise Error, "Failed to parse controller response: #{response.body}"
+          raise Error, "Failed to parse controllers response: #{response.body}"
         end
       else
-        raise Error, "Failed to get controller. Status code: #{response.status}"
+        raise Error, "Failed to get controllers. Status code: #{response.status}"
       end
     end
 

data/lib/idrac/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IDRAC
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idrac
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Jonathan Siegel