supermicro 0.1.0

data/lib/supermicro/storage.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'colorize'
+
+module Supermicro
+  module Storage
+    def storage_controllers
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Storage?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          controllers = data["Members"].map do |controller|
+            {
+              "id" => controller["Id"],
+              "name" => controller["Name"],
+              "status" => controller.dig("Status", "Health") || "N/A",
+              "storage_controllers" => controller["StorageControllers"]&.map { |sc|
+                {
+                  "name" => sc["Name"],
+                  "manufacturer" => sc["Manufacturer"],
+                  "model" => sc["Model"],
+                  "firmware_version" => sc["FirmwareVersion"],
+                  "speed_gbps" => sc["SpeedGbps"],
+                  "supported_protocols" => sc["SupportedControllerProtocols"]
+                }
+              }
+            }
+          end
+          
+          return controllers
+        rescue JSON::ParserError
+          raise Error, "Failed to parse storage controllers response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get storage controllers. Status code: #{response.status}"
+      end
+    end
+
+    def drives
+      all_drives = []
+      
+      controllers = storage_controllers
+      
+      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)
+                
+                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
+              end
+            end
+          rescue JSON::ParserError
+            debug "Failed to parse storage data for controller #{controller_id}", 1, :yellow
+          end
+        end
+      end
+      
+      return all_drives
+    end
+
+    def volumes
+      all_volumes = []
+      
+      controllers = storage_controllers
+      
+      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"]
+                }
+              end
+            end
+          rescue JSON::ParserError
+            debug "Failed to parse volumes data for controller #{controller_id}", 1, :yellow
+          end
+        end
+      end
+      
+      return all_volumes
+    end
+
+    def storage_summary
+      puts "\n=== Storage Summary ===".green
+      
+      controllers = storage_controllers
+      puts "\nStorage Controllers:".cyan
+      controllers.each do |controller|
+        puts "  #{controller['name']} (#{controller['id']})".yellow
+        if controller["storage_controllers"]
+          controller["storage_controllers"].each do |sc|
+            puts "    - #{sc['manufacturer']} #{sc['model']}".light_cyan
+            puts "      Firmware: #{sc['firmware_version']}" if sc['firmware_version']
+            puts "      Speed: #{sc['speed_gbps']} Gbps" if sc['speed_gbps']
+          end
+        end
+      end
+      
+      all_drives = drives
+      puts "\nPhysical Drives:".cyan
+      all_drives.each do |drive|
+        puts "  #{drive['name']} (#{drive['id']})".yellow
+        puts "    - #{drive['manufacturer']} #{drive['model']}".light_cyan
+        puts "      Capacity: #{drive['capacity_gb']} GB"
+        puts "      Type: #{drive['media_type']} / #{drive['protocol']}"
+        puts "      Status: #{drive['status']}"
+        puts "      Serial: #{drive['serial']}"
+        if drive['predicted_media_life_left_percent']
+          puts "      Life Remaining: #{drive['predicted_media_life_left_percent']}%"
+        end
+      end
+      
+      all_volumes = volumes
+      if all_volumes.any?
+        puts "\nVolumes:".cyan
+        all_volumes.each do |volume|
+          puts "  #{volume['name']} (#{volume['id']})".yellow
+          puts "    - Capacity: #{volume['capacity_gb']} GB"
+          puts "      Type: #{volume['volume_type']} / #{volume['raid_type']}"
+          puts "      Status: #{volume['status']}"
+          puts "      Encrypted: #{volume['encrypted']}"
+        end
+      end
+      
+      {
+        "controllers" => controllers,
+        "drives" => all_drives,
+        "volumes" => all_volumes
+      }
+    end
+  end
+end

data/lib/supermicro/system.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'colorize'
+
+module Supermicro
+  module System
+    def memory
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Memory")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          memory = data["Members"].map do |m|
+            next if m["CapacityMiB"].nil? || m["CapacityMiB"] == 0
+            
+            dimm_name = m["DeviceLocator"] || m["Name"]
+            bank_match = /([A-Z])(\d+)/.match(dimm_name)
+            
+            if bank_match
+              bank, index = bank_match.captures
+            else
+              bank = dimm_name
+              index = 0
+            end
+            
+            {
+              "model" => m["Manufacturer"],
+              "name" => dimm_name,
+              "capacity_bytes" => m["CapacityMiB"].to_i * 1024 * 1024,
+              "health" => m.dig("Status", "Health") || "N/A",
+              "speed_mhz" => m["OperatingSpeedMhz"],
+              "part_number" => m["PartNumber"],
+              "serial" => m["SerialNumber"],
+              "bank" => bank,
+              "index" => index.to_i,
+              "memory_type" => m["MemoryDeviceType"]
+            }
+          end.compact
+          
+          return memory.sort_by { |m| [m["bank"] || "Z", m["index"] || 999] }
+        rescue JSON::ParserError
+          raise Error, "Failed to parse memory response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get memory. Status code: #{response.status}"
+      end
+    end
+
+    def psus
+      response = authenticated_request(:get, "/redfish/v1/Chassis/1/Power")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          psus = data["PowerSupplies"].map do |psu|
+            health = psu.dig("Status", "Health") || "Unknown"
+            watts = psu["PowerInputWatts"] || psu["LastPowerOutputWatts"] || 0
+            
+            {
+              "name" => psu["Name"],
+              "voltage" => psu["LineInputVoltage"],
+              "voltage_human" => psu["LineInputVoltageType"],
+              "watts" => watts,
+              "part" => psu["PartNumber"],
+              "model" => psu["Model"],
+              "serial" => psu["SerialNumber"],
+              "status" => health,
+              "manufacturer" => psu["Manufacturer"]
+            }
+          end
+          
+          return psus
+        rescue JSON::ParserError
+          raise Error, "Failed to parse PSU response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get PSUs. Status code: #{response.status}"
+      end
+    end
+
+    def fans
+      tries = 0
+      max_tries = 3
+      
+      while tries < max_tries
+        begin
+          response = authenticated_request(:get, "/redfish/v1/Chassis/1/Thermal?$expand=*($levels=1)")
+          
+          if response.status == 200
+            data = JSON.parse(response.body)
+            
+            fans = data["Fans"].map do |fan|
+              health = fan.dig("Status", "Health") || "Unknown"
+              rpm = fan["Reading"] || fan["CurrentReading"] || 0
+              
+              {
+                "name" => fan["Name"],
+                "rpm" => rpm,
+                "status" => health,
+                "min_rpm" => fan["MinReadingRange"],
+                "max_rpm" => fan["MaxReadingRange"]
+              }
+            end
+            
+            return fans
+          elsif response.status.between?(400, 499)
+            power_response = authenticated_request(:get, "/redfish/v1/Systems/1?$select=PowerState")
+            if power_response.status == 200 && JSON.parse(power_response.body)["PowerState"] == "Off"
+              puts "WARN: System is off. Fans are not available.".yellow
+              return []
+            else
+              raise Error, "Failed to get fans: #{response.status}"
+            end
+          else
+            raise Error, "Failed to get fans: #{response.status}"
+          end
+        rescue => e
+          tries += 1
+          if tries >= max_tries
+            raise Error, "Failed to get fans after #{max_tries} attempts: #{e.message}"
+          end
+          sleep 2
+        end
+      end
+    end
+
+    def cpus
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Processors")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          cpus = data["Members"].map do |member|
+            # Fetch each processor individually
+            cpu_path = member["@odata.id"]
+            cpu_response = authenticated_request(:get, cpu_path)
+            
+            if cpu_response.status == 200
+              cpu = JSON.parse(cpu_response.body)
+              
+              next unless cpu["ProcessorType"] == "CPU"
+              
+              {
+                "socket" => cpu["Socket"] || cpu["Id"],
+                "model" => cpu["Model"],
+                "manufacturer" => cpu["Manufacturer"],
+                "cores" => cpu["TotalCores"],
+                "threads" => cpu["TotalThreads"],
+                "speed_mhz" => cpu["MaxSpeedMHz"],
+                "health" => cpu.dig("Status", "Health") || "N/A"
+              }
+            else
+              nil
+            end
+          end.compact
+          
+          return cpus
+        rescue JSON::ParserError => e
+          raise Error, "Failed to parse CPU response: #{e.message}"
+        end
+      else
+        raise Error, "Failed to get CPUs. Status code: #{response.status}"
+      end
+    end
+
+    def nics
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/EthernetInterfaces?$expand=*($levels=1)")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          nics = data["Members"].map do |nic|
+            {
+              "id" => nic["Id"],
+              "name" => nic["Name"],
+              "mac" => nic["MACAddress"],
+              "speed_mbps" => nic["SpeedMbps"],
+              "status" => nic.dig("Status", "Health") || "N/A",
+              "link_status" => nic["LinkStatus"],
+              "ipv4" => nic.dig("IPv4Addresses", 0, "Address"),
+              "ipv6" => nic.dig("IPv6Addresses", 0, "Address")
+            }
+          end
+          
+          return nics
+        rescue JSON::ParserError
+          raise Error, "Failed to parse NIC response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get NICs. Status code: #{response.status}"
+      end
+    end
+
+    def system_info
+      response = authenticated_request(:get, "/redfish/v1/Systems/1")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          {
+            "name" => data["Name"],
+            "model" => data["Model"],
+            "manufacturer" => data["Manufacturer"],
+            "serial" => data["SerialNumber"],
+            "uuid" => data["UUID"],
+            "bios_version" => data["BiosVersion"],
+            "power_state" => data["PowerState"],
+            "health" => data.dig("Status", "Health"),
+            "total_memory_gb" => data["MemorySummary"]["TotalSystemMemoryGiB"],
+            "processor_count" => data.dig("ProcessorSummary", "Count"),
+            "processor_model" => data.dig("ProcessorSummary", "Model")
+          }
+        rescue JSON::ParserError
+          raise Error, "Failed to parse system info response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get system info. Status code: #{response.status}"
+      end
+    end
+
+    def power_consumption
+      response = authenticated_request(:get, "/redfish/v1/Chassis/1/Power")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          power_control = data["PowerControl"].first if data["PowerControl"]
+          
+          {
+            "consumed_watts" => power_control["PowerConsumedWatts"],
+            "capacity_watts" => power_control["PowerCapacityWatts"],
+            "average_watts" => power_control["PowerAverage"],
+            "min_watts" => power_control["MinConsumedWatts"],
+            "max_watts" => power_control["MaxConsumedWatts"]
+          }
+        rescue JSON::ParserError
+          raise Error, "Failed to parse power consumption response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get power consumption. Status code: #{response.status}"
+      end
+    end
+
+    def temperatures
+      response = authenticated_request(:get, "/redfish/v1/Chassis/1/Thermal")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          temps = data["Temperatures"].map do |temp|
+            {
+              "name" => temp["Name"],
+              "reading_celsius" => temp["ReadingCelsius"],
+              "upper_threshold" => temp["UpperThresholdCritical"],
+              "status" => temp.dig("Status", "Health") || "N/A"
+            }
+          end
+          
+          return temps
+        rescue JSON::ParserError
+          raise Error, "Failed to parse temperature response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get temperatures. Status code: #{response.status}"
+      end
+    end
+  end
+end

data/lib/supermicro/system_config.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'colorize'
+
+module Supermicro
+  module SystemConfig
+    def bios_attributes
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Bios")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          {
+            "attributes" => data["Attributes"],
+            "attribute_registry" => data["AttributeRegistry"]
+          }
+        rescue JSON::ParserError
+          raise Error, "Failed to parse BIOS attributes response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get BIOS attributes. Status code: #{response.status}"
+      end
+    end
+
+    def set_bios_attribute(attribute_name, value)
+      puts "Setting BIOS attribute #{attribute_name} to #{value}...".yellow
+      
+      body = {
+        "Attributes" => {
+          attribute_name => value
+        }
+      }
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Systems/1/Bios/Settings",
+        body: body.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "BIOS attribute set successfully. Changes will be applied on next reboot.".green
+        return true
+      else
+        raise Error, "Failed to set BIOS attribute: #{response.status} - #{response.body}"
+      end
+    end
+
+    def pending_bios_settings
+      response = authenticated_request(:get, "/redfish/v1/Systems/1/Bios/Settings")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          data["Attributes"] || {}
+        rescue JSON::ParserError
+          raise Error, "Failed to parse pending BIOS settings response: #{response.body}"
+        end
+      else
+        {}
+      end
+    end
+
+    def reset_bios_defaults
+      puts "Resetting BIOS to defaults...".yellow
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios",
+        body: {}.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "BIOS reset to defaults successfully. Changes will be applied on next reboot.".green
+        return true
+      else
+        raise Error, "Failed to reset BIOS: #{response.status} - #{response.body}"
+      end
+    end
+
+    def manager_network_protocol
+      response = authenticated_request(:get, "/redfish/v1/Managers/1/NetworkProtocol")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          protocols = {}
+          ["HTTP", "HTTPS", "IPMI", "SSH", "SNMP", "VirtualMedia", "KVMIP", "NTP", "Telnet"].each do |proto|
+            if data[proto]
+              protocols[proto.downcase] = {
+                "enabled" => data[proto]["ProtocolEnabled"],
+                "port" => data[proto]["Port"]
+              }
+            end
+          end
+          
+          protocols
+        rescue JSON::ParserError
+          raise Error, "Failed to parse network protocol response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get network protocols. Status code: #{response.status}"
+      end
+    end
+
+    def set_network_protocol(protocol, enabled:, port: nil)
+      puts "Configuring #{protocol} protocol...".yellow
+      
+      proto_key = protocol.upcase
+      body = {
+        proto_key => {
+          "ProtocolEnabled" => enabled
+        }
+      }
+      
+      body[proto_key]["Port"] = port if port
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Managers/1/NetworkProtocol",
+        body: body.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "Network protocol configured successfully.".green
+        return true
+      else
+        raise Error, "Failed to configure network protocol: #{response.status} - #{response.body}"
+      end
+    end
+
+    def manager_info
+      response = authenticated_request(:get, "/redfish/v1/Managers/1")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          {
+            "name" => data["Name"],
+            "model" => data["Model"],
+            "firmware_version" => data["FirmwareVersion"],
+            "uuid" => data["UUID"],
+            "status" => data.dig("Status", "Health"),
+            "datetime" => data["DateTime"],
+            "datetime_local_offset" => data["DateTimeLocalOffset"]
+          }
+        rescue JSON::ParserError
+          raise Error, "Failed to parse manager info response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get manager info. Status code: #{response.status}"
+      end
+    end
+
+    def set_manager_datetime(datetime_str)
+      puts "Setting BMC datetime to #{datetime_str}...".yellow
+      
+      body = {
+        "DateTime" => datetime_str
+      }
+      
+      response = authenticated_request(
+        :patch,
+        "/redfish/v1/Managers/1",
+        body: body.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "DateTime set successfully.".green
+        return true
+      else
+        raise Error, "Failed to set datetime: #{response.status} - #{response.body}"
+      end
+    end
+
+    def reset_manager
+      puts "Resetting BMC...".yellow
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Managers/1/Actions/Manager.Reset",
+        body: { "ResetType": "GracefulRestart" }.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "BMC reset initiated successfully.".green
+        return true
+      else
+        raise Error, "Failed to reset BMC: #{response.status} - #{response.body}"
+      end
+    end
+  end
+end