radfish-ami 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 348afbf5f47b34017b22b55684ae17457b46ed74d4f160c85e2c648b4ac30b55
+  data.tar.gz: 5538ed34280b652637c588280019bff2fd08cbc420854b63fe96d9d190e572c3
+SHA512:
+  metadata.gz: 1107faba3f94f2f40b5e4f21e2ecd2889715fa0806dca5b2503c6926206c6d80d0657aee05fccb2f6bdc270790e7a1a3550ed63f839178051f352abaee210a4d
+  data.tar.gz: 786c5c3e9fc08e8b52b9b7c866bdacb7e9ced148bdfb68a75eee0b5bd754731e5383e7343712fa9d0e79ba85fd8872885440be691395eb3b978db47a3648fc0b

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jonathan Siegel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,87 @@
+# Radfish-AMI
+
+AMI BMC adapter for the [Radfish](https://github.com/buildio/radfish) Redfish API client. Provides support for ASRockRack servers and other systems using AMI MegaRAC BMC firmware.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'radfish-ami'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install radfish-ami
+```
+
+## Usage
+
+The adapter is automatically registered when you require the gem:
+
+```ruby
+require 'radfish-ami'
+
+# Connect to an ASRockRack server
+client = Radfish.connect(
+  host: 'bmc.example.com',
+  username: 'admin',
+  password: 'your-password',
+  vendor: 'ami'  # or 'asrockrack'
+)
+
+# Get system information
+puts client.system_info
+
+# Power operations
+puts client.power_status  # => "On"
+client.power_restart(force: true)
+
+# Virtual media
+client.insert_virtual_media('http://example.com/boot.iso')
+client.set_boot_override('Cd', persistent: false)
+client.power_restart
+
+# Thermal data
+client.fans.each { |fan| puts "#{fan['Name']}: #{fan['Reading']} RPM" }
+client.temperatures.each { |t| puts "#{t['Name']}: #{t['ReadingCelsius']}C" }
+
+# Storage
+client.storage_controllers.each do |controller|
+  puts "Controller: #{controller.name}"
+  client.drives(controller).each { |d| puts "  Drive: #{d['Name']}" }
+end
+
+# Disconnect
+client.logout
+```
+
+## Supported Features
+
+- **Power Management**: Power on, off, restart, cycle, status
+- **System Information**: Make, model, serial, BIOS version, CPU, memory, NICs
+- **Thermal Monitoring**: Fan speeds, temperatures
+- **Power Monitoring**: PSU status, power consumption
+- **Storage**: Controllers, drives, volumes
+- **Virtual Media**: Insert/eject ISO images
+- **Boot Configuration**: Set boot order, one-time boot overrides
+- **Network Configuration**: BMC network settings
+- **Account Management**: Create, delete, update user accounts
+- **SEL Log**: Read and clear system event logs
+- **Task/Job Management**: Monitor long-running operations
+
+## Tested Hardware
+
+- ASRockRack GENOAD8UD-2T/X550 (AMD EPYC)
+- Other ASRockRack servers with AMI MegaRAC BMC
+
+## License
+
+MIT License - see LICENSE file.

data/lib/radfish/ami/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Ami
+    VERSION = "0.1.0"
+  end
+end

data/lib/radfish/ami.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Convenience require for the gem
+require_relative "../radfish-ami"

data/lib/radfish/ami_adapter.rb

@@ -0,0 +1,790 @@
+# frozen_string_literal: true
+
+module Radfish
+  class AmiAdapter < Core::BaseClient
+    include Core::Power
+    include Core::System
+    include Core::Storage
+    include Core::VirtualMedia
+    include Core::Boot
+    include Core::Jobs
+    include Core::Utility
+    include Core::Network
+
+    # AMI BMC uses "Self" as the default system/manager/chassis ID
+    SYSTEM_ID = "Self"
+    MANAGER_ID = "Self"
+    CHASSIS_ID = "Self"
+
+    def vendor
+      "ami"
+    end
+
+    # Session management
+    def login
+      @session = Core::Session.new(self)
+      @session.create
+    end
+
+    def logout
+      return true unless @session
+      result = @session.delete
+      @session = nil
+      result
+    end
+
+    def authenticated_request(method, path, **options)
+      ensure_session!
+
+      headers = options[:headers] || {}
+      headers["X-Auth-Token"] = @session.x_auth_token
+      headers["Accept"] ||= "application/json"
+      headers["Content-Type"] ||= "application/json" if [:post, :put, :patch].include?(method)
+      headers["Host"] = host_header if host_header
+
+      options[:headers] = headers
+
+      case method
+      when :get
+        http_get(path, **options)
+      when :post
+        http_post(path, **options)
+      when :put
+        http_put(path, **options)
+      when :patch
+        http_patch(path, **options)
+      when :delete
+        http_delete(path, **options)
+      else
+        raise ArgumentError, "Unknown HTTP method: #{method}"
+      end
+    end
+
+    # Power management
+    def power_status
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}")
+      if response.status == 200
+        data = JSON.parse(response.body)
+        data["PowerState"]
+      else
+        raise Error, "Failed to get power status: #{response.status}"
+      end
+    end
+
+    def power_on
+      perform_reset_action("On")
+    end
+
+    def power_off(force: true)
+      if force
+        perform_reset_action("ForceOff")
+      else
+        perform_reset_action("GracefulShutdown")
+      end
+    end
+
+    def power_restart(force: true)
+      if force
+        perform_reset_action("ForceRestart")
+      else
+        # Graceful restart: shutdown then power on
+        power_off(force: false)
+        sleep 5
+        power_on
+      end
+    end
+
+    def power_cycle
+      perform_reset_action("PowerCycle")
+    end
+
+    def reset_type_allowed
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}/ResetActionInfo")
+      if response.status == 200
+        data = JSON.parse(response.body)
+        params = data.dig("Parameters") || []
+        reset_param = params.find { |p| p["Name"] == "ResetType" }
+        reset_param&.dig("AllowableValues") || []
+      else
+        # Fallback to common AMI reset types
+        %w[On ForceOff ForceRestart GracefulShutdown PowerCycle]
+      end
+    end
+
+    # System information
+    def system_info
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}")
+      raise Error, "Failed to get system info: #{response.status}" unless response.status == 200
+      JSON.parse(response.body)
+    end
+
+    def service_tag
+      system_info["SerialNumber"]
+    end
+
+    def make
+      info = system_info
+      info["Manufacturer"] || "ASRockRack"
+    end
+
+    def model
+      system_info["Model"]
+    end
+
+    def serial
+      system_info["SerialNumber"]
+    end
+
+    def cpus
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}/Processors")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+
+      members.map do |member|
+        cpu_response = authenticated_request(:get, member["@odata.id"])
+        next nil unless cpu_response.status == 200
+        JSON.parse(cpu_response.body)
+      end.compact
+    end
+
+    def memory
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}/Memory")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+
+      members.map do |member|
+        mem_response = authenticated_request(:get, member["@odata.id"])
+        next nil unless mem_response.status == 200
+        JSON.parse(mem_response.body)
+      end.compact
+    end
+
+    def nics
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}/EthernetInterfaces")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+
+      members.map do |member|
+        nic_response = authenticated_request(:get, member["@odata.id"])
+        next nil unless nic_response.status == 200
+        JSON.parse(nic_response.body)
+      end.compact
+    end
+
+    def fans
+      thermal = get_thermal_data
+      thermal["Fans"] || []
+    end
+
+    def temperatures
+      thermal = get_thermal_data
+      thermal["Temperatures"] || []
+    end
+
+    def psus
+      power_data = get_power_data
+      power_data["PowerSupplies"] || []
+    end
+
+    def power_consumption
+      power_data = get_power_data
+      power_data["PowerControl"]&.first || {}
+    end
+
+    def power_consumption_watts
+      consumption = power_consumption
+      consumption.dig("PowerMetrics", "AverageConsumedWatts") ||
+        consumption.dig("PowerMetrics", "CurConsumedWatts") ||
+        0
+    end
+
+    # Storage
+    def storage_controllers
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}/Storage")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+
+      members.map do |member|
+        controller_response = authenticated_request(:get, member["@odata.id"])
+        next nil unless controller_response.status == 200
+        data = JSON.parse(controller_response.body)
+        Radfish::Controller.new(
+          client: self,
+          id: data["Id"],
+          name: data["Name"],
+          model: data["Model"],
+          status: data.dig("Status", "Health"),
+          adapter_data: data
+        )
+      end.compact
+    end
+
+    def drives(controller)
+      controller_id = controller.is_a?(Radfish::Controller) ? controller.id : controller
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}/Storage/#{controller_id}")
+      return [] unless response.status == 200
+
+      data = JSON.parse(response.body)
+      drive_refs = data["Drives"] || []
+
+      drive_refs.map do |ref|
+        drive_response = authenticated_request(:get, ref["@odata.id"])
+        next nil unless drive_response.status == 200
+        JSON.parse(drive_response.body)
+      end.compact
+    end
+
+    def volumes(controller)
+      controller_obj = controller.is_a?(Radfish::Controller) ? controller : nil
+      controller_id = controller.is_a?(Radfish::Controller) ? controller.id : controller
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}/Storage/#{controller_id}/Volumes")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+
+      members.map do |member|
+        volume_response = authenticated_request(:get, member["@odata.id"])
+        next nil unless volume_response.status == 200
+        data = JSON.parse(volume_response.body)
+        Radfish::Volume.new(
+          client: self,
+          controller: controller_obj,
+          id: data["Id"],
+          name: data["Name"],
+          capacity_bytes: data["CapacityBytes"],
+          raid_type: data["RAIDType"],
+          health: data.dig("Status", "Health"),
+          adapter_data: data
+        )
+      end.compact
+    end
+
+    def volume_drives(volume)
+      volume_id = volume.is_a?(Radfish::Volume) ? volume.id : volume
+      # Get volume details to find linked drives
+      volume_data = volume.is_a?(Radfish::Volume) ? volume.adapter_data : nil
+
+      unless volume_data
+        # Need to fetch volume data
+        storage_controllers.each do |controller|
+          vols = volumes(controller)
+          vol = vols.find { |v| v.id == volume_id }
+          if vol
+            volume_data = vol.adapter_data
+            break
+          end
+        end
+      end
+
+      return [] unless volume_data
+
+      drive_refs = volume_data.dig("Links", "Drives") || []
+      drive_refs.map do |ref|
+        drive_response = authenticated_request(:get, ref["@odata.id"])
+        next nil unless drive_response.status == 200
+        JSON.parse(drive_response.body)
+      end.compact
+    end
+
+    def storage_summary
+      controllers = storage_controllers
+      {
+        controller_count: controllers.size,
+        controllers: controllers.map do |c|
+          {
+            id: c.id,
+            name: c.name,
+            drive_count: drives(c).size,
+            volume_count: volumes(c).size
+          }
+        end
+      }
+    end
+
+    # Virtual Media
+    def virtual_media
+      response = authenticated_request(:get, "/redfish/v1/Managers/#{MANAGER_ID}/VirtualMedia")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+
+      members.map do |member|
+        vm_response = authenticated_request(:get, member["@odata.id"])
+        next nil unless vm_response.status == 200
+        JSON.parse(vm_response.body)
+      end.compact
+    end
+
+    def virtual_media_status
+      virtual_media.map do |vm|
+        {
+          id: vm["Id"],
+          name: vm["Name"],
+          media_types: vm["MediaTypes"],
+          inserted: vm["Inserted"],
+          image: vm["Image"],
+          connected: vm["ConnectedVia"]
+        }
+      end
+    end
+
+    def insert_virtual_media(iso_url, device: nil)
+      devices = virtual_media
+      target_device = if device
+                        devices.find { |d| d["Id"] == device || d["Name"]&.include?(device.to_s) }
+                      else
+                        # Find first CD/DVD device
+                        devices.find { |d| d["MediaTypes"]&.include?("CD") || d["MediaTypes"]&.include?("DVD") }
+                      end
+
+      raise VirtualMediaNotFoundError, "No suitable virtual media device found" unless target_device
+
+      device_path = target_device["@odata.id"]
+      actions = target_device.dig("Actions", "#VirtualMedia.InsertMedia")
+
+      if actions && actions["target"]
+        # Use the InsertMedia action
+        payload = { "Image" => iso_url, "Inserted" => true, "WriteProtected" => true }
+        response = authenticated_request(:post, actions["target"], body: payload.to_json)
+      else
+        # Fallback to PATCH method
+        payload = { "Image" => iso_url, "Inserted" => true, "WriteProtected" => true }
+        response = authenticated_request(:patch, device_path, body: payload.to_json)
+      end
+
+      if response.status.between?(200, 204)
+        debug "Virtual media inserted successfully", 1, :green
+        true
+      else
+        error_msg = begin
+                      JSON.parse(response.body).dig("error", "message")
+                    rescue
+                      response.body
+                    end
+        raise VirtualMediaError, "Failed to insert virtual media: #{error_msg}"
+      end
+    end
+
+    def eject_virtual_media(device: nil)
+      devices = virtual_media
+      target_device = if device
+                        devices.find { |d| d["Id"] == device || d["Name"]&.include?(device.to_s) }
+                      else
+                        # Find first mounted device
+                        devices.find { |d| d["Inserted"] == true }
+                      end
+
+      return true unless target_device && target_device["Inserted"]
+
+      device_path = target_device["@odata.id"]
+      actions = target_device.dig("Actions", "#VirtualMedia.EjectMedia")
+
+      if actions && actions["target"]
+        response = authenticated_request(:post, actions["target"], body: "{}".to_json)
+      else
+        payload = { "Image" => nil, "Inserted" => false }
+        response = authenticated_request(:patch, device_path, body: payload.to_json)
+      end
+
+      response.status.between?(200, 204)
+    end
+
+    def unmount_all_media
+      virtual_media.each do |device|
+        next unless device["Inserted"]
+        eject_virtual_media(device: device["Id"])
+      end
+      true
+    end
+
+    def mount_iso_and_boot(iso_url, device: nil)
+      insert_virtual_media(iso_url, device: device)
+      set_boot_override("Cd", persistent: false)
+      power_restart(force: true)
+    end
+
+    # Boot configuration
+    def boot_config
+      info = system_info
+      info["Boot"] || {}
+    end
+
+    def set_boot_override(target, persistent: false)
+      enabled = persistent ? "Continuous" : "Once"
+      payload = {
+        "Boot" => {
+          "BootSourceOverrideTarget" => target,
+          "BootSourceOverrideEnabled" => enabled
+        }
+      }
+
+      response = authenticated_request(:patch, "/redfish/v1/Systems/#{SYSTEM_ID}", body: payload.to_json)
+
+      if response.status.between?(200, 204)
+        debug "Boot override set to #{target} (#{enabled})", 1, :green
+        true
+      else
+        error_msg = begin
+                      JSON.parse(response.body).dig("error", "message")
+                    rescue
+                      response.body
+                    end
+        raise Error, "Failed to set boot override: #{error_msg}"
+      end
+    end
+
+    def clear_boot_override
+      payload = {
+        "Boot" => {
+          "BootSourceOverrideTarget" => "None",
+          "BootSourceOverrideEnabled" => "Disabled"
+        }
+      }
+
+      response = authenticated_request(:patch, "/redfish/v1/Systems/#{SYSTEM_ID}", body: payload.to_json)
+      response.status.between?(200, 204)
+    end
+
+    def set_boot_order(devices)
+      payload = {
+        "Boot" => {
+          "BootOrder" => devices
+        }
+      }
+
+      response = authenticated_request(:patch, "/redfish/v1/Systems/#{SYSTEM_ID}", body: payload.to_json)
+      response.status.between?(200, 204)
+    end
+
+    def get_boot_devices
+      boot_config["BootOrder"] || []
+    end
+
+    def boot_to_pxe(persistent: false)
+      set_boot_override("Pxe", persistent: persistent)
+    end
+
+    def boot_to_disk(persistent: false)
+      set_boot_override("Hdd", persistent: persistent)
+    end
+
+    def boot_to_cd(persistent: false)
+      set_boot_override("Cd", persistent: persistent)
+    end
+
+    def boot_to_usb(persistent: false)
+      set_boot_override("Usb", persistent: persistent)
+    end
+
+    def boot_to_bios_setup(persistent: false)
+      set_boot_override("BiosSetup", persistent: persistent)
+    end
+
+    # Jobs/Tasks
+    def jobs
+      response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+
+      members.map do |member|
+        task_response = authenticated_request(:get, member["@odata.id"])
+        next nil unless task_response.status == 200
+        JSON.parse(task_response.body)
+      end.compact
+    end
+
+    def job_status(job_id)
+      response = authenticated_request(:get, "/redfish/v1/TaskService/Tasks/#{job_id}")
+      if response.status == 200
+        JSON.parse(response.body)
+      else
+        raise TaskError, "Failed to get task status: #{response.status}"
+      end
+    end
+
+    def wait_for_job(job_id, timeout: 600)
+      start_time = Time.now
+      loop do
+        status = job_status(job_id)
+        state = status["TaskState"]
+
+        case state
+        when "Completed"
+          return status
+        when "Exception", "Killed", "Cancelled"
+          raise TaskFailedError, "Task #{job_id} failed: #{status['Messages']}"
+        end
+
+        if Time.now - start_time > timeout
+          raise TaskTimeoutError, "Task #{job_id} timed out after #{timeout} seconds"
+        end
+
+        sleep 5
+      end
+    end
+
+    def cancel_job(job_id)
+      response = authenticated_request(:delete, "/redfish/v1/TaskService/Tasks/#{job_id}")
+      response.status.between?(200, 204)
+    end
+
+    def clear_completed_jobs
+      jobs.each do |job|
+        next unless %w[Completed Exception Killed Cancelled].include?(job["TaskState"])
+        cancel_job(job["Id"])
+      end
+      true
+    end
+
+    def jobs_summary
+      all_jobs = jobs
+      {
+        total: all_jobs.size,
+        running: all_jobs.count { |j| j["TaskState"] == "Running" },
+        completed: all_jobs.count { |j| j["TaskState"] == "Completed" },
+        failed: all_jobs.count { |j| %w[Exception Killed Cancelled].include?(j["TaskState"]) }
+      }
+    end
+
+    # Utility
+    def sel_log
+      response = authenticated_request(:get, "/redfish/v1/Systems/#{SYSTEM_ID}/LogServices/Log1/Entries")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      collection["Members"] || []
+    end
+
+    def clear_sel_log
+      response = authenticated_request(:post, "/redfish/v1/Systems/#{SYSTEM_ID}/LogServices/Log1/Actions/LogService.ClearLog", body: "{}".to_json)
+      response.status.between?(200, 204)
+    end
+
+    def sel_summary(limit: 10)
+      entries = sel_log.first(limit)
+      entries.map do |entry|
+        {
+          id: entry["Id"],
+          created: entry["Created"],
+          severity: entry["Severity"],
+          message: entry["Message"]
+        }
+      end
+    end
+
+    def accounts
+      response = authenticated_request(:get, "/redfish/v1/AccountService/Accounts")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+
+      members.map do |member|
+        account_response = authenticated_request(:get, member["@odata.id"])
+        next nil unless account_response.status == 200
+        JSON.parse(account_response.body)
+      end.compact
+    end
+
+    def create_account(username:, password:, role: "Administrator")
+      payload = {
+        "UserName" => username,
+        "Password" => password,
+        "RoleId" => role
+      }
+
+      response = authenticated_request(:post, "/redfish/v1/AccountService/Accounts", body: payload.to_json)
+
+      if response.status == 201
+        JSON.parse(response.body)
+      else
+        error_msg = begin
+                      JSON.parse(response.body).dig("error", "message")
+                    rescue
+                      response.body
+                    end
+        raise Error, "Failed to create account: #{error_msg}"
+      end
+    end
+
+    def delete_account(username)
+      account = accounts.find { |a| a["UserName"] == username }
+      raise NotFoundError, "Account not found: #{username}" unless account
+
+      response = authenticated_request(:delete, account["@odata.id"])
+      response.status.between?(200, 204)
+    end
+
+    def update_account_password(username:, new_password:)
+      account = accounts.find { |a| a["UserName"] == username }
+      raise NotFoundError, "Account not found: #{username}" unless account
+
+      payload = { "Password" => new_password }
+      response = authenticated_request(:patch, account["@odata.id"], body: payload.to_json)
+      response.status.between?(200, 204)
+    end
+
+    def sessions
+      response = authenticated_request(:get, "/redfish/v1/SessionService/Sessions")
+      return [] unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+
+      members.map do |member|
+        session_response = authenticated_request(:get, member["@odata.id"])
+        next nil unless session_response.status == 200
+        JSON.parse(session_response.body)
+      end.compact
+    end
+
+    def service_info
+      service_root
+    end
+
+    def get_firmware_version
+      response = authenticated_request(:get, "/redfish/v1/Managers/#{MANAGER_ID}")
+      if response.status == 200
+        data = JSON.parse(response.body)
+        data["FirmwareVersion"]
+      else
+        nil
+      end
+    end
+
+    # Network configuration
+    def get_bmc_network
+      response = authenticated_request(:get, "/redfish/v1/Managers/#{MANAGER_ID}/EthernetInterfaces")
+      return {} unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+      return {} if members.empty?
+
+      # Get the first interface (typically the main BMC interface)
+      interface_response = authenticated_request(:get, members.first["@odata.id"])
+      return {} unless interface_response.status == 200
+
+      data = JSON.parse(interface_response.body)
+
+      ipv4 = data.dig("IPv4Addresses", 0) || {}
+      dhcp_enabled = data.dig("DHCPv4", "DHCPEnabled")
+      {
+        "id" => data["Id"],
+        "hostname" => data["HostName"],
+        "fqdn" => data["FQDN"],
+        "mac_address" => data["MACAddress"],
+        "ipv4_address" => ipv4["Address"],
+        "subnet_mask" => ipv4["SubnetMask"],
+        "gateway" => ipv4["Gateway"],
+        "mode" => dhcp_enabled ? "DHCP" : "Static",
+        "address_origin" => ipv4["AddressOrigin"],
+        "dhcp_enabled" => dhcp_enabled,
+        "dns_servers" => data["NameServers"]
+      }
+    end
+
+    def set_bmc_network(ip_address: nil, subnet_mask: nil, gateway: nil,
+                        dns_primary: nil, dns_secondary: nil, hostname: nil,
+                        dhcp: false)
+      response = authenticated_request(:get, "/redfish/v1/Managers/#{MANAGER_ID}/EthernetInterfaces")
+      return false unless response.status == 200
+
+      collection = JSON.parse(response.body)
+      members = collection["Members"] || []
+      return false if members.empty?
+
+      interface_path = members.first["@odata.id"]
+
+      if dhcp
+        payload = {
+          "DHCPv4" => { "DHCPEnabled" => true }
+        }
+      else
+        payload = {}
+
+        if ip_address || subnet_mask || gateway
+          payload["IPv4Addresses"] = [{
+            "Address" => ip_address,
+            "SubnetMask" => subnet_mask,
+            "Gateway" => gateway
+          }.compact]
+        end
+
+        if dns_primary || dns_secondary
+          payload["NameServers"] = [dns_primary, dns_secondary].compact
+        end
+
+        payload["HostName"] = hostname if hostname
+
+        payload["DHCPv4"] = { "DHCPEnabled" => false }
+      end
+
+      response = authenticated_request(:patch, interface_path, body: payload.to_json)
+      response.status.between?(200, 204)
+    end
+
+    private
+
+    def ensure_session!
+      unless @session&.x_auth_token
+        raise AuthenticationError, "Not logged in. Call #login first."
+      end
+    end
+
+    def perform_reset_action(reset_type)
+      payload = { "ResetType" => reset_type }
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Systems/#{SYSTEM_ID}/Actions/ComputerSystem.Reset",
+        body: payload.to_json
+      )
+
+      if response.status.between?(200, 204)
+        debug "Reset action #{reset_type} performed successfully", 1, :green
+        true
+      else
+        error_msg = begin
+                      JSON.parse(response.body).dig("error", "message")
+                    rescue
+                      response.body
+                    end
+        raise Error, "Failed to perform reset action #{reset_type}: #{error_msg}"
+      end
+    end
+
+    def get_thermal_data
+      response = authenticated_request(:get, "/redfish/v1/Chassis/#{CHASSIS_ID}/Thermal")
+      if response.status == 200
+        JSON.parse(response.body)
+      else
+        {}
+      end
+    end
+
+    def get_power_data
+      response = authenticated_request(:get, "/redfish/v1/Chassis/#{CHASSIS_ID}/Power")
+      if response.status == 200
+        JSON.parse(response.body)
+      else
+        {}
+      end
+    end
+  end
+
+  # Register the AMI adapter
+  register_adapter("ami", AmiAdapter)
+  register_adapter("asrockrack", AmiAdapter)
+end

data/lib/radfish-ami.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "radfish"
+require_relative "radfish/ami/version"
+require_relative "radfish/ami_adapter"
+
+module Radfish
+  module Ami
+  end
+end

data/radfish-ami.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "lib/radfish/ami/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "radfish-ami"
+  spec.version = Radfish::Ami::VERSION
+  spec.authors = ["Jonathan Siegel"]
+  spec.email = ["248302+usiegj00@users.noreply.github.com"]
+
+  spec.summary = "AMI/ASRockRack adapter for Radfish"
+  spec.description = "AMI BMC adapter for Radfish Redfish API client. Provides support for ASRockRack servers and other systems using AMI MegaRAC BMC firmware."
+  spec.homepage = "https://github.com/buildio/radfish-ami"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir["{lib}/**/*", "LICENSE", "README.md", "*.gemspec"].reject { |f| File.directory?(f) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "radfish", "~> 0.2"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock", "~> 3.0"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: radfish-ami
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jonathan Siegel
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: radfish
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: AMI BMC adapter for Radfish Redfish API client. Provides support for
+  ASRockRack servers and other systems using AMI MegaRAC BMC firmware.
+email:
+- 248302+usiegj00@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/radfish-ami.rb
+- lib/radfish/ami.rb
+- lib/radfish/ami/version.rb
+- lib/radfish/ami_adapter.rb
+- radfish-ami.gemspec
+homepage: https://github.com/buildio/radfish-ami
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/buildio/radfish-ami
+  source_code_uri: https://github.com/buildio/radfish-ami
+  changelog_uri: https://github.com/buildio/radfish-ami/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: AMI/ASRockRack adapter for Radfish
+test_files: []