radfish 0.1.0

data/lib/radfish/client.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Radfish
+  class Client
+    include Debuggable
+    
+    attr_reader :adapter, :vendor
+    attr_accessor :verbosity
+    
+    def initialize(host:, username:, password:, vendor: nil, **options)
+      @verbosity = options[:verbosity] || 0
+      
+      # Auto-detect vendor if not specified
+      if vendor.nil?
+        detector = VendorDetector.new(
+          host: host,
+          username: username,
+          password: password,
+          port: options[:port] || 443,
+          use_ssl: options.fetch(:use_ssl, true),
+          verify_ssl: options.fetch(:verify_ssl, false)
+        )
+        detector.verbosity = @verbosity
+        @vendor = detector.detect
+        
+        if @vendor.nil?
+          raise UnsupportedVendorError, "Could not detect vendor for #{host}"
+        end
+        
+        debug "Auto-detected vendor: #{@vendor}", 1, :green
+      else
+        @vendor = vendor.to_s.downcase
+        debug "Using specified vendor: #{@vendor}", 1, :cyan
+      end
+      
+      # Get the adapter class for this vendor
+      adapter_class = Radfish.get_adapter(@vendor)
+      
+      if adapter_class.nil?
+        # Try to load the adapter gem dynamically
+        begin
+          require "radfish/#{@vendor}_adapter"
+          adapter_class = Radfish.get_adapter(@vendor)
+        rescue LoadError
+          # Adapter gem not installed
+        end
+      end
+      
+      if adapter_class.nil?
+        raise UnsupportedVendorError, "No adapter available for vendor: #{@vendor}. " \
+          "Please install the radfish-#{@vendor} gem or use a supported vendor."
+      end
+      
+      # Create the adapter instance
+      @adapter = adapter_class.new(
+        host: host,
+        username: username,
+        password: password,
+        **options
+      )
+      
+      # Pass verbosity to adapter
+      @adapter.verbosity = @verbosity if @adapter.respond_to?(:verbosity=)
+    end
+    
+    def self.connect(host:, username:, password:, vendor: nil, **options)
+      client = new(host: host, username: username, password: password, vendor: vendor, **options)
+      
+      if block_given?
+        begin
+          client.login
+          yield client
+        ensure
+          client.logout
+        end
+      else
+        client
+      end
+    end
+    
+    # Delegate all method calls to the adapter
+    def method_missing(method, *args, **kwargs, &block)
+      if @adapter.respond_to?(method)
+        if kwargs.empty?
+          @adapter.send(method, *args, &block)
+        else
+          @adapter.send(method, *args, **kwargs, &block)
+        end
+      else
+        super
+      end
+    end
+    
+    def respond_to_missing?(method, include_private = false)
+      @adapter.respond_to?(method, include_private) || super
+    end
+    
+    # Core methods that should always be available
+    
+    def login
+      @adapter.login
+    end
+    
+    def logout
+      @adapter.logout
+    end
+    
+    def vendor_name
+      @vendor
+    end
+    
+    def adapter_class
+      @adapter.class
+    end
+    
+    def supported_features
+      # Return a list of features this adapter supports
+      features = []
+      
+      # Check which modules are included
+      features << :power if @adapter.respond_to?(:power_status)
+      features << :system if @adapter.respond_to?(:system_info)
+      features << :storage if @adapter.respond_to?(:storage_controllers)
+      features << :virtual_media if @adapter.respond_to?(:virtual_media)
+      features << :boot if @adapter.respond_to?(:boot_options)
+      features << :jobs if @adapter.respond_to?(:jobs)
+      features << :utility if @adapter.respond_to?(:sel_log)
+      
+      features
+    end
+    
+    def info
+      {
+        vendor: @vendor,
+        adapter: adapter_class.name,
+        features: supported_features,
+        host: @adapter.host,
+        base_url: @adapter.base_url
+      }
+    end
+  end
+end

data/lib/radfish/core/base_client.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    class BaseClient
+      include Debuggable
+      
+      attr_reader :host, :username, :password, :port, :use_ssl, :verify_ssl, :host_header
+      attr_accessor :verbosity, :retry_count, :retry_delay
+      
+      def initialize(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: false, 
+                     retry_count: 3, retry_delay: 1, host_header: nil, **options)
+        @host = host
+        @username = username
+        @password = password
+        @port = port
+        @use_ssl = use_ssl
+        @verify_ssl = verify_ssl
+        @host_header = host_header
+        @verbosity = 0
+        @retry_count = retry_count
+        @retry_delay = retry_delay
+        
+        # Store any vendor-specific options
+        @options = options
+      end
+      
+      def base_url
+        protocol = use_ssl ? 'https' : 'http'
+        "#{protocol}://#{host}:#{port}"
+      end
+      
+      def connection
+        @connection ||= Faraday.new(url: base_url, ssl: { verify: verify_ssl }) do |faraday|
+          faraday.request :multipart
+          faraday.request :url_encoded
+          faraday.adapter Faraday.default_adapter
+          
+          if @verbosity > 0
+            faraday.response :logger, Logger.new(STDOUT), bodies: @verbosity >= 2 do |logger|
+              logger.filter(/(Authorization: Basic )([^,\n]+)/, '\1[FILTERED]')
+              logger.filter(/(Password"=>"?)([^,"]+)/, '\1[FILTERED]')
+            end
+          end
+        end
+      end
+      
+      def with_retries(max_retries = nil, initial_delay = nil, error_classes = nil)
+        max_retries ||= @retry_count
+        initial_delay ||= @retry_delay
+        error_classes ||= [StandardError]
+        
+        retries = 0
+        begin
+          yield
+        rescue *error_classes => e
+          retries += 1
+          if retries <= max_retries
+            delay = initial_delay * (retries ** 1.5).to_i
+            debug "RETRY: #{e.message} - Attempt #{retries}/#{max_retries}, waiting #{delay}s", 1, :yellow
+            sleep delay
+            retry
+          else
+            debug "MAX RETRIES REACHED: #{e.message} after #{max_retries} attempts", 1, :red
+            raise e
+          end
+        end
+      end
+      
+      # Vendor-specific methods to be overridden
+      
+      def vendor
+        raise NotImplementedError, "Subclass must implement #vendor"
+      end
+      
+      def login
+        raise NotImplementedError, "Subclass must implement #login"
+      end
+      
+      def logout
+        raise NotImplementedError, "Subclass must implement #logout"
+      end
+      
+      def authenticated_request(method, path, **options)
+        raise NotImplementedError, "Subclass must implement #authenticated_request"
+      end
+      
+      def redfish_version
+        response = authenticated_request(:get, "/redfish/v1")
+        if response.status == 200
+          data = JSON.parse(response.body)
+          data["RedfishVersion"]
+        else
+          raise Error, "Failed to get Redfish version: #{response.status}"
+        end
+      end
+      
+      def service_root
+        response = authenticated_request(:get, "/redfish/v1")
+        if response.status == 200
+          JSON.parse(response.body)
+        else
+          raise Error, "Failed to get service root: #{response.status}"
+        end
+      end
+      
+      # Helper for handling responses
+      def handle_response(response)
+        if response.headers["location"]
+          return handle_location(response.headers["location"])
+        end
+        
+        if response.status.between?(200, 299)
+          return response.body
+        else
+          raise Error, "Request failed: #{response.status} - #{response.body}"
+        end
+      end
+      
+      def handle_location(location)
+        # Subclasses can override for vendor-specific handling
+        nil
+      end
+    end
+  end
+end

data/lib/radfish/core/boot.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    module Boot
+      def boot_options
+        raise NotImplementedError, "Adapter must implement #boot_options"
+      end
+      
+      def set_boot_override(target, persistent: false)
+        raise NotImplementedError, "Adapter must implement #set_boot_override"
+      end
+      
+      def clear_boot_override
+        raise NotImplementedError, "Adapter must implement #clear_boot_override"
+      end
+      
+      def set_boot_order(devices)
+        raise NotImplementedError, "Adapter must implement #set_boot_order"
+      end
+      
+      def get_boot_devices
+        raise NotImplementedError, "Adapter must implement #get_boot_devices"
+      end
+      
+      def boot_to_pxe
+        raise NotImplementedError, "Adapter must implement #boot_to_pxe"
+      end
+      
+      def boot_to_disk
+        raise NotImplementedError, "Adapter must implement #boot_to_disk"
+      end
+      
+      def boot_to_cd
+        raise NotImplementedError, "Adapter must implement #boot_to_cd"
+      end
+      
+      def boot_to_usb
+        raise NotImplementedError, "Adapter must implement #boot_to_usb"
+      end
+      
+      def boot_to_bios_setup
+        raise NotImplementedError, "Adapter must implement #boot_to_bios_setup"
+      end
+    end
+  end
+end

data/lib/radfish/core/jobs.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    module Jobs
+      def jobs
+        raise NotImplementedError, "Adapter must implement #jobs"
+      end
+      
+      def job_status(job_id)
+        raise NotImplementedError, "Adapter must implement #job_status"
+      end
+      
+      def wait_for_job(job_id, timeout: 600)
+        raise NotImplementedError, "Adapter must implement #wait_for_job"
+      end
+      
+      def cancel_job(job_id)
+        raise NotImplementedError, "Adapter must implement #cancel_job"
+      end
+      
+      def clear_completed_jobs
+        raise NotImplementedError, "Adapter must implement #clear_completed_jobs"
+      end
+      
+      def jobs_summary
+        raise NotImplementedError, "Adapter must implement #jobs_summary"
+      end
+    end
+  end
+end

data/lib/radfish/core/power.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    module Power
+      def power_status
+        raise NotImplementedError, "Adapter must implement #power_status"
+      end
+      
+      def power_on
+        raise NotImplementedError, "Adapter must implement #power_on"
+      end
+      
+      def power_off
+        raise NotImplementedError, "Adapter must implement #power_off"
+      end
+      
+      def power_restart
+        raise NotImplementedError, "Adapter must implement #power_restart"
+      end
+      
+      def power_cycle
+        raise NotImplementedError, "Adapter must implement #power_cycle"
+      end
+      
+      def reset_type_allowed
+        raise NotImplementedError, "Adapter must implement #reset_type_allowed"
+      end
+    end
+  end
+end

data/lib/radfish/core/session.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    class Session
+      include Debuggable
+      
+      attr_reader :client, :x_auth_token, :session_id
+      
+      def initialize(client)
+        @client = client
+        @x_auth_token = nil
+        @session_id = nil
+      end
+      
+      def connection
+        @connection ||= Faraday.new(url: client.base_url, ssl: { verify: client.verify_ssl }) do |faraday|
+          faraday.request :url_encoded
+          faraday.adapter Faraday.default_adapter
+        end
+      end
+      
+      def create
+        debug "Creating Redfish session for #{client.host}", 1
+        
+        payload = {
+          UserName: client.username,
+          Password: client.password
+        }.to_json
+        
+        headers = {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json'
+        }
+        headers['Host'] = client.host_header if client.host_header
+        
+        begin
+          response = connection.post('/redfish/v1/SessionService/Sessions', payload, headers)
+          
+          if response.status == 201
+            @x_auth_token = response.headers['x-auth-token']
+            
+            if response.headers['location']
+              @session_id = response.headers['location'].split('/').last
+            end
+            
+            begin
+              body = JSON.parse(response.body)
+              @session_id ||= body["Id"] if body.is_a?(Hash)
+            rescue JSON::ParserError
+            end
+            
+            debug "Session created successfully. Token: #{@x_auth_token ? @x_auth_token[0..10] + '...' : 'nil'}", 1, :green
+            return true
+          else
+            debug "Failed to create session. Status: #{response.status}", 1, :red
+            debug "Response: #{response.body}", 2
+            return false
+          end
+        rescue Faraday::Error => e
+          debug "Connection error creating session: #{e.message}", 1, :red
+          return false
+        end
+      end
+      
+      def delete
+        return unless @x_auth_token && @session_id
+        
+        debug "Deleting session #{@session_id}", 1
+        
+        headers = {
+          'X-Auth-Token' => @x_auth_token,
+          'Accept' => 'application/json'
+        }
+        headers['Host'] = client.host_header if client.host_header
+        
+        begin
+          response = connection.delete("/redfish/v1/SessionService/Sessions/#{@session_id}", nil, headers)
+          
+          if response.status == 204 || response.status == 200
+            debug "Session deleted successfully", 1, :green
+            @x_auth_token = nil
+            @session_id = nil
+            return true
+          else
+            debug "Failed to delete session. Status: #{response.status}", 1, :yellow
+            return false
+          end
+        rescue Faraday::Error => e
+          debug "Error deleting session: #{e.message}", 1, :yellow
+          return false
+        end
+      end
+      
+      def valid?
+        return false unless @x_auth_token
+        
+        headers = {
+          'X-Auth-Token' => @x_auth_token,
+          'Accept' => 'application/json'
+        }
+        headers['Host'] = client.host_header if client.host_header
+        
+        begin
+          response = connection.get("/redfish/v1/SessionService/Sessions/#{@session_id}", nil, headers)
+          response.status == 200
+        rescue
+          false
+        end
+      end
+      
+      private
+      
+      def verbosity
+        client.verbosity
+      end
+    end
+  end
+end

data/lib/radfish/core/storage.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    module Storage
+      def storage_controllers
+        raise NotImplementedError, "Adapter must implement #storage_controllers"
+      end
+      
+      def drives
+        raise NotImplementedError, "Adapter must implement #drives"
+      end
+      
+      def volumes
+        raise NotImplementedError, "Adapter must implement #volumes"
+      end
+      
+      def storage_summary
+        raise NotImplementedError, "Adapter must implement #storage_summary"
+      end
+    end
+  end
+end

data/lib/radfish/core/system.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    module System
+      def system_info
+        raise NotImplementedError, "Adapter must implement #system_info"
+      end
+      
+      def cpus
+        raise NotImplementedError, "Adapter must implement #cpus"
+      end
+      
+      def memory
+        raise NotImplementedError, "Adapter must implement #memory"
+      end
+      
+      def nics
+        raise NotImplementedError, "Adapter must implement #nics"
+      end
+      
+      def fans
+        raise NotImplementedError, "Adapter must implement #fans"
+      end
+      
+      def temperatures
+        raise NotImplementedError, "Adapter must implement #temperatures"
+      end
+      
+      def psus
+        raise NotImplementedError, "Adapter must implement #psus"
+      end
+      
+      def power_consumption
+        raise NotImplementedError, "Adapter must implement #power_consumption"
+      end
+    end
+  end
+end

data/lib/radfish/core/utility.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    module Utility
+      def sel_log
+        raise NotImplementedError, "Adapter must implement #sel_log"
+      end
+      
+      def clear_sel_log
+        raise NotImplementedError, "Adapter must implement #clear_sel_log"
+      end
+      
+      def sel_summary(limit: 10)
+        raise NotImplementedError, "Adapter must implement #sel_summary"
+      end
+      
+      def accounts
+        raise NotImplementedError, "Adapter must implement #accounts"
+      end
+      
+      def create_account(username:, password:, role: "Administrator")
+        raise NotImplementedError, "Adapter must implement #create_account"
+      end
+      
+      def delete_account(username)
+        raise NotImplementedError, "Adapter must implement #delete_account"
+      end
+      
+      def update_account_password(username:, new_password:)
+        raise NotImplementedError, "Adapter must implement #update_account_password"
+      end
+      
+      def sessions
+        raise NotImplementedError, "Adapter must implement #sessions"
+      end
+      
+      def service_info
+        raise NotImplementedError, "Adapter must implement #service_info"
+      end
+      
+      def get_firmware_version
+        raise NotImplementedError, "Adapter must implement #get_firmware_version"
+      end
+    end
+  end
+end

data/lib/radfish/core/virtual_media.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Radfish
+  module Core
+    module VirtualMedia
+      def virtual_media
+        raise NotImplementedError, "Adapter must implement #virtual_media"
+      end
+      
+      def insert_virtual_media(iso_url, device: nil)
+        raise NotImplementedError, "Adapter must implement #insert_virtual_media"
+      end
+      
+      def eject_virtual_media(device: nil)
+        raise NotImplementedError, "Adapter must implement #eject_virtual_media"
+      end
+      
+      def virtual_media_status
+        raise NotImplementedError, "Adapter must implement #virtual_media_status"
+      end
+      
+      def mount_iso_and_boot(iso_url, device: nil)
+        raise NotImplementedError, "Adapter must implement #mount_iso_and_boot"
+      end
+      
+      def unmount_all_media
+        raise NotImplementedError, "Adapter must implement #unmount_all_media"
+      end
+    end
+  end
+end