supermicro 0.1.0

data/lib/supermicro/license.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Supermicro
+  module License
+    # Check if the BMC has the required licenses for virtual media
+    def check_virtual_media_license
+      response = authenticated_request(:get, "/redfish/v1/Managers/1/LicenseManager/QueryLicense")
+      
+      if response.status != 200
+        debug "Unable to query license status: #{response.status}", 1, :yellow
+        return { 
+          available: :unknown, 
+          message: "Unable to query license status",
+          licenses: []
+        }
+      end
+      
+      begin
+        data = JSON.parse(response.body)
+        licenses = data["Licenses"] || []
+        
+        found_licenses = []
+        has_oob = false
+        has_dcms = false
+        
+        licenses.each do |license_json|
+          # Parse the nested JSON structure
+          license_data = JSON.parse(license_json) rescue nil
+          next unless license_data
+          
+          license_name = license_data.dig("ProductKey", "Node", "LicenseName")
+          next unless license_name
+          
+          found_licenses << license_name
+          
+          # Check for required licenses
+          has_oob = true if license_name == "SFT-OOB-LIC"
+          has_dcms = true if license_name == "SFT-DCMS-SINGLE"
+        end
+        
+        # Virtual media requires either SFT-OOB-LIC or SFT-DCMS-SINGLE
+        has_required_license = has_oob || has_dcms
+        
+        {
+          available: has_required_license,
+          licenses: found_licenses,
+          message: if has_required_license
+                     "Virtual media license present: #{found_licenses.join(', ')}"
+                   elsif found_licenses.empty?
+                     "No licenses found. Virtual media requires SFT-OOB-LIC or SFT-DCMS-SINGLE"
+                   else
+                     "Virtual media requires SFT-OOB-LIC or SFT-DCMS-SINGLE. Found: #{found_licenses.join(', ')}"
+                   end
+        }
+      rescue JSON::ParserError => e
+        debug "Failed to parse license response: #{e.message}", 1, :red
+        { 
+          available: :unknown, 
+          message: "Failed to parse license response",
+          licenses: []
+        }
+      end
+    end
+    
+    # Get all licenses
+    def licenses
+      response = authenticated_request(:get, "/redfish/v1/Managers/1/LicenseManager/QueryLicense")
+      
+      return [] if response.status != 200
+      
+      begin
+        data = JSON.parse(response.body)
+        licenses = data["Licenses"] || []
+        
+        parsed_licenses = []
+        licenses.each do |license_json|
+          license_data = JSON.parse(license_json) rescue nil
+          next unless license_data
+          
+          node = license_data.dig("ProductKey", "Node") || {}
+          parsed_licenses << {
+            id: node["LicenseID"],
+            name: node["LicenseName"],
+            created: node["CreateDate"]
+          }
+        end
+        
+        parsed_licenses
+      rescue JSON::ParserError
+        []
+      end
+    end
+    
+    # Activate a license
+    def activate_license(license_key)
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Managers/1/LicenseManager/Actions/LicenseManager.ActivateLicense",
+        body: { "LicenseKey" => license_key }.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "License activated successfully", 1, :green
+        true
+      else
+        debug "Failed to activate license: #{response.status}", 1, :red
+        false
+      end
+    end
+    
+    # Clear/remove a license
+    def clear_license(license_id)
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Managers/1/LicenseManager/Actions/LicenseManager.ClearLicense",
+        body: { "LicenseID" => license_id }.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        debug "License cleared successfully", 1, :green
+        true
+      else
+        debug "Failed to clear license: #{response.status}", 1, :red
+        false
+      end
+    end
+  end
+end

data/lib/supermicro/power.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'colorize'
+
+module Supermicro
+  module Power
+    def power_status
+      response = authenticated_request(:get, "/redfish/v1/Systems/1?$select=PowerState")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          power_state = data["PowerState"]
+          return power_state
+        rescue JSON::ParserError
+          raise Error, "Failed to parse power status response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get power status. Status code: #{response.status}"
+      end
+    end
+
+    def power_on
+      current_state = power_status
+      
+      if current_state == "On"
+        puts "System is already powered on.".yellow
+        return true
+      end
+      
+      puts "Powering on system...".yellow
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Systems/1/Actions/ComputerSystem.Reset",
+        body: { "ResetType": "On" }.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "Power on command sent successfully.".green
+        return true
+      else
+        raise Error, "Failed to power on system: #{response.status} - #{response.body}"
+      end
+    end
+
+    def power_off(force: false)
+      current_state = power_status
+      
+      if current_state == "Off"
+        puts "System is already powered off.".yellow
+        return true
+      end
+      
+      reset_type = force ? "ForceOff" : "GracefulShutdown"
+      puts "#{force ? 'Force powering' : 'Gracefully shutting'} off system...".yellow
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Systems/1/Actions/ComputerSystem.Reset",
+        body: { "ResetType": reset_type }.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "Power off command sent successfully.".green
+        return true
+      elsif !force
+        puts "Graceful shutdown failed, trying force off...".yellow
+        
+        response = authenticated_request(
+          :post,
+          "/redfish/v1/Systems/1/Actions/ComputerSystem.Reset",
+          body: { "ResetType": "ForceOff" }.to_json,
+          headers: { 'Content-Type': 'application/json' }
+        )
+        
+        if response.status.between?(200, 299)
+          puts "Force power off command sent successfully.".green
+          return true
+        else
+          raise Error, "Failed to power off system: #{response.status} - #{response.body}"
+        end
+      else
+        raise Error, "Failed to force power off system: #{response.status} - #{response.body}"
+      end
+    end
+
+    def power_restart(force: false)
+      reset_type = force ? "ForceRestart" : "GracefulRestart"
+      puts "#{force ? 'Force restarting' : 'Gracefully restarting'} system...".yellow
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Systems/1/Actions/ComputerSystem.Reset",
+        body: { "ResetType": reset_type }.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "Restart command sent successfully.".green
+        return true
+      elsif !force
+        puts "Graceful restart failed, trying force restart...".yellow
+        
+        response = authenticated_request(
+          :post,
+          "/redfish/v1/Systems/1/Actions/ComputerSystem.Reset",
+          body: { "ResetType": "ForceRestart" }.to_json,
+          headers: { 'Content-Type': 'application/json' }
+        )
+        
+        if response.status.between?(200, 299)
+          puts "Force restart command sent successfully.".green
+          return true
+        else
+          raise Error, "Failed to restart system: #{response.status} - #{response.body}"
+        end
+      else
+        raise Error, "Failed to force restart system: #{response.status} - #{response.body}"
+      end
+    end
+
+    def power_cycle
+      puts "Power cycling system...".yellow
+      
+      response = authenticated_request(
+        :post,
+        "/redfish/v1/Systems/1/Actions/ComputerSystem.Reset",
+        body: { "ResetType": "PowerCycle" }.to_json,
+        headers: { 'Content-Type': 'application/json' }
+      )
+      
+      if response.status.between?(200, 299)
+        puts "Power cycle command sent successfully.".green
+        return true
+      else
+        raise Error, "Failed to power cycle system: #{response.status} - #{response.body}"
+      end
+    end
+
+    def reset_type_allowed
+      response = authenticated_request(:get, "/redfish/v1/Systems/1")
+      
+      if response.status == 200
+        begin
+          data = JSON.parse(response.body)
+          
+          allowed_values = data.dig("Actions", "#ComputerSystem.Reset", "ResetType@Redfish.AllowableValues")
+          
+          if allowed_values
+            puts "Allowed reset types:".green
+            allowed_values.each { |type| puts "  - #{type}" }
+            return allowed_values
+          else
+            puts "Could not determine allowed reset types".yellow
+            return []
+          end
+        rescue JSON::ParserError
+          raise Error, "Failed to parse system response: #{response.body}"
+        end
+      else
+        raise Error, "Failed to get system info. Status code: #{response.status}"
+      end
+    end
+  end
+end

data/lib/supermicro/session.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'faraday'
+require 'base64'
+
+module Supermicro
+  class Session
+    attr_reader :client, :x_auth_token, :session_id
+    
+    include Debuggable
+    
+    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

data/lib/supermicro/spinner.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Supermicro
+  class Spinner
+    SPINNERS = {
+      dots: {
+        frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+        interval: 0.08
+      },
+      line: {
+        frames: ['-', '\\', '|', '/'],
+        interval: 0.1
+      },
+      arrow: {
+        frames: ['←', '↖', '↑', '↗', '→', '↘', '↓', '↙'],
+        interval: 0.1
+      },
+      bounce: {
+        frames: ['⠁', '⠂', '⠄', '⡀', '⡈', '⡐', '⡠', '⣀', '⣁', '⣂', '⣄', '⣌', '⣔', '⣤', '⣥', '⣦', '⣮', '⣶', '⣷', '⣿', '⡿', '⠿', '⢟', '⠟', '⡛', '⠛', '⠫', '⢋', '⠋', '⠍', '⡉', '⠉', '⠑', '⠡', '⢁'],
+        interval: 0.08
+      },
+      bar: {
+        frames: ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█', '▇', '▆', '▅', '▄', '▃', '▂'],
+        interval: 0.08
+      }
+    }
+    
+    def initialize(message = "Working", type: :dots, color: :cyan)
+      @message = message
+      @type = type
+      @color = color
+      @running = false
+      @thread = nil
+      @current_frame = 0
+      @spinner_config = SPINNERS[@type] || SPINNERS[:dots]
+      @start_time = nil
+      @last_update = nil
+      @max_width = 0  # Track the maximum width we've printed
+    end
+    
+    def start
+      return if @running
+      @running = true
+      @start_time = Time.now
+      @current_frame = 0
+      
+      @thread = Thread.new do
+        while @running
+          render
+          sleep @spinner_config[:interval]
+          @current_frame = (@current_frame + 1) % @spinner_config[:frames].length
+        end
+      end
+    end
+    
+    def update(message)
+      @message = message
+      @last_update = Time.now
+      # Immediately render to show the update
+      render if @running
+    end
+    
+    def stop(final_message = nil, success: true)
+      return unless @running
+      @running = false
+      @thread&.join
+      
+      # Clear the spinner line completely
+      print "\r\033[2K"
+      
+      if final_message
+        icon = success ? "✓".green : "✗".red
+        elapsed = Time.now - @start_time
+        time_str = elapsed > 1 ? " (#{elapsed.round(1)}s)" : ""
+        puts "#{icon} #{final_message}#{time_str}"
+      end
+    end
+    
+    def with_spinner
+      start
+      begin
+        yield self
+      ensure
+        stop
+      end
+    end
+    
+    private
+    
+    def render
+      frame = @spinner_config[:frames][@current_frame]
+      elapsed = Time.now - @start_time
+      time_str = elapsed > 2 ? " (#{elapsed.round}s)" : ""
+      
+      # Build the output string without color codes to calculate real width
+      text_content = "#{frame} #{@message}#{time_str}"
+      current_width = text_content.length
+      
+      # Track maximum width seen
+      @max_width = current_width if current_width > @max_width
+      
+      # Pad with spaces to clear any leftover text from longer previous messages
+      padding = @max_width > current_width ? " " * (@max_width - current_width) : ""
+      
+      # Build the colored output
+      output = "\r#{frame.send(@color)} #{@message}#{time_str}#{padding}"
+      
+      # Print without newline and flush immediately
+      print output
+      $stdout.flush
+    end
+  end
+  
+  module SpinnerHelper
+    def with_spinner(message, type: :dots, color: :cyan, &block)
+      return yield if respond_to?(:verbosity) && verbosity > 0
+      
+      spinner = Spinner.new(message, type: type, color: color)
+      spinner.start
+      
+      begin
+        result = yield(spinner)
+        spinner.stop("#{message} - Complete", success: true)
+        result
+      rescue => e
+        spinner.stop("#{message} - Failed", success: false)
+        raise e
+      end
+    end
+    
+    def show_progress(message, duration: nil, &block)
+      if duration
+        # Show progress bar if duration is known
+        with_progress_bar(message, duration, &block)
+      else
+        # Show spinner if duration is unknown
+        with_spinner(message, &block)
+      end
+    end
+    
+    private
+    
+    def with_progress_bar(message, duration, &block)
+      return yield if respond_to?(:verbosity) && verbosity > 0
+      
+      start_time = Time.now
+      width = 30
+      
+      thread = Thread.new do
+        while true
+          elapsed = Time.now - start_time
+          progress = [elapsed / duration, 1.0].min
+          filled = (progress * width).round
+          bar = "█" * filled + "░" * (width - filled)
+          percent = (progress * 100).round
+          
+          print "\r#{message}: [#{bar}] #{percent}%"
+          $stdout.flush
+          
+          break if progress >= 1.0
+          sleep 0.1
+        end
+      end
+      
+      begin
+        result = yield
+        thread.join
+        print "\r\e[K"
+        puts "✓ #{message} - Complete".green
+        result
+      rescue => e
+        thread.kill
+        print "\r\e[K"
+        puts "✗ #{message} - Failed".red
+        raise e
+      end
+    end
+  end
+end