idrac 0.1.31 → 0.1.38

data/idrac-0.1.7/lib/idrac/firmware.rb

@@ -1,366 +0,0 @@
-require 'tempfile'
-require 'net/http'
-require 'uri'
-require 'json'
-require 'nokogiri'
-require 'fileutils'
-require 'securerandom'
-
-module IDRAC
-  class Firmware
-    attr_reader :client
-
-    CATALOG_URL = "https://downloads.dell.com/catalog/Catalog.xml.gz"
-    
-    def initialize(client)
-      @client = client
-    end
-
-    def update(firmware_path, options = {})
-      # Validate firmware file exists
-      unless File.exist?(firmware_path)
-        raise Error, "Firmware file not found: #{firmware_path}"
-      end
-
-      # Login to iDRAC
-      client.login unless client.instance_variable_get(:@session_id)
-
-      # Upload firmware file
-      job_id = upload_firmware(firmware_path)
-      
-      # Check if we should wait for the update to complete
-      if options[:wait]
-        wait_for_job_completion(job_id, options[:timeout] || 3600)
-      end
-
-      job_id
-    end
-    
-    def download_catalog(output_dir = nil)
-      output_dir ||= Dir.pwd
-      FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
-      
-      catalog_gz_path = File.join(output_dir, "Catalog.xml.gz")
-      catalog_path = File.join(output_dir, "Catalog.xml")
-      
-      puts "Downloading Dell catalog from #{CATALOG_URL}..."
-      
-      uri = URI.parse(CATALOG_URL)
-      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
-        request = Net::HTTP::Get.new(uri)
-        http.request(request) do |response|
-          if response.code == "200"
-            File.open(catalog_gz_path, 'wb') do |file|
-              response.read_body do |chunk|
-                file.write(chunk)
-              end
-            end
-          else
-            raise Error, "Failed to download catalog: #{response.code} #{response.message}"
-          end
-        end
-      end
-      
-      puts "Extracting catalog..."
-      system("gunzip -f #{catalog_gz_path}")
-      
-      if File.exist?(catalog_path)
-        puts "Catalog downloaded and extracted to #{catalog_path}"
-        return catalog_path
-      else
-        raise Error, "Failed to extract catalog"
-      end
-    end
-    
-    def get_system_inventory
-      puts "Retrieving system inventory..."
-      
-      # Get basic system information
-      system_uri = URI.parse("#{client.base_url}/redfish/v1/Systems/System.Embedded.1")
-      system_response = client.authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1")
-      
-      if system_response.status != 200
-        raise Error, "Failed to get system information: #{system_response.status}"
-      end
-      
-      system_data = JSON.parse(system_response.body)
-      
-      # Get firmware inventory
-      firmware_uri = URI.parse("#{client.base_url}/redfish/v1/UpdateService/FirmwareInventory")
-      firmware_response = client.authenticated_request(:get, "/redfish/v1/UpdateService/FirmwareInventory")
-      
-      if firmware_response.status != 200
-        raise Error, "Failed to get firmware inventory: #{firmware_response.status}"
-      end
-      
-      firmware_data = JSON.parse(firmware_response.body)
-      
-      # Get detailed firmware information for each component
-      firmware_inventory = []
-      
-      if firmware_data['Members'] && firmware_data['Members'].is_a?(Array)
-        firmware_data['Members'].each do |member|
-          if member['@odata.id']
-            component_uri = member['@odata.id']
-            component_response = client.authenticated_request(:get, component_uri)
-            
-            if component_response.status == 200
-              component_data = JSON.parse(component_response.body)
-              firmware_inventory << {
-                name: component_data['Name'],
-                id: component_data['Id'],
-                version: component_data['Version'],
-                updateable: component_data['Updateable'] || false,
-                status: component_data['Status'] ? component_data['Status']['State'] : 'Unknown'
-              }
-            end
-          end
-        end
-      end
-      
-      {
-        system: {
-          model: system_data['Model'],
-          manufacturer: system_data['Manufacturer'],
-          serial_number: system_data['SerialNumber'],
-          part_number: system_data['PartNumber'],
-          bios_version: system_data['BiosVersion'],
-          service_tag: system_data['SKU']
-        },
-        firmware: firmware_inventory
-      }
-    end
-    
-    def check_updates(catalog_path = nil)
-      # Download catalog if not provided
-      catalog_path ||= download_catalog
-      
-      # Get system inventory
-      inventory = get_system_inventory
-      
-      # Parse catalog
-      catalog_doc = File.open(catalog_path) { |f| Nokogiri::XML(f) }
-      
-      # Extract service tag
-      service_tag = inventory[:system][:service_tag]
-      
-      puts "Checking updates for system with service tag: #{service_tag}"
-      
-      # Find applicable updates
-      updates = []
-      
-      # Get current firmware versions
-      current_versions = {}
-      inventory[:firmware].each do |fw|
-        current_versions[fw[:name]] = fw[:version]
-      end
-      
-      # Find matching components in catalog
-      catalog_doc.xpath('//SoftwareComponent').each do |component|
-        name = component.at_xpath('Name')&.text
-        version = component.at_xpath('Version')&.text
-        path = component.at_xpath('Path')&.text
-        component_type = component.at_xpath('ComponentType')&.text
-        
-        # Check if this component matches any of our firmware
-        inventory[:firmware].each do |fw|
-          if fw[:name].include?(name) || name.include?(fw[:name])
-            current_version = fw[:version]
-            
-            # Simple version comparison (this could be improved)
-            if version != current_version
-              updates << {
-                name: name,
-                current_version: current_version,
-                available_version: version,
-                path: path,
-                component_type: component_type,
-                download_url: "https://downloads.dell.com/#{path}"
-              }
-            end
-          end
-        end
-      end
-      
-      updates
-    end
-    
-    def interactive_update(catalog_path = nil)
-      updates = check_updates(catalog_path)
-      
-      if updates.empty?
-        puts "No updates available for your system."
-        return
-      end
-      
-      puts "\nAvailable updates:"
-      updates.each_with_index do |update, index|
-        puts "#{index + 1}. #{update[:name]}: #{update[:current_version]} -> #{update[:available_version]}"
-      end
-      
-      puts "\nEnter the number of the update to install (or 'all' for all updates, 'q' to quit):"
-      choice = STDIN.gets.chomp
-      
-      return if choice.downcase == 'q'
-      
-      selected_updates = if choice.downcase == 'all'
-                          updates
-                        else
-                          index = choice.to_i - 1
-                          if index >= 0 && index < updates.size
-                            [updates[index]]
-                          else
-                            puts "Invalid selection."
-                            return
-                          end
-                        end
-      
-      selected_updates.each do |update|
-        puts "Downloading #{update[:name]} version #{update[:available_version]}..."
-        
-        # Create temp directory
-        temp_dir = Dir.mktmpdir
-        
-        begin
-          # Download the update
-          update_filename = File.basename(update[:path])
-          update_path = File.join(temp_dir, update_filename)
-          
-          uri = URI.parse(update[:download_url])
-          Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
-            request = Net::HTTP::Get.new(uri)
-            http.request(request) do |response|
-              if response.code == "200"
-                File.open(update_path, 'wb') do |file|
-                  response.read_body do |chunk|
-                    file.write(chunk)
-                  end
-                end
-              else
-                puts "Failed to download update: #{response.code} #{response.message}"
-                next
-              end
-            end
-          end
-          
-          puts "Installing #{update[:name]} version #{update[:available_version]}..."
-          job_id = update(update_path, wait: true)
-          puts "Update completed with job ID: #{job_id}"
-          
-        ensure
-          # Clean up temp directory
-          FileUtils.remove_entry(temp_dir)
-        end
-      end
-    end
-
-    private
-
-    def upload_firmware(firmware_path)
-      puts "Uploading firmware file: #{firmware_path}"
-      
-      # Get the HttpPushUri from UpdateService
-      update_service_response = client.authenticated_request(:get, "/redfish/v1/UpdateService")
-      update_service_data = JSON.parse(update_service_response.body)
-      
-      http_push_uri = update_service_data['HttpPushUri']
-      if http_push_uri.nil?
-        http_push_uri = "/redfish/v1/UpdateService/FirmwareInventory"
-        puts "HttpPushUri not found, using default: #{http_push_uri}"
-      else
-        puts "Found HttpPushUri: #{http_push_uri}"
-      end
-      
-      # Get the ETag for the HttpPushUri
-      etag_response = client.authenticated_request(:get, http_push_uri)
-      etag = etag_response.headers['etag']
-      
-      puts "Got ETag: #{etag}"
-      
-      # Create a boundary for multipart/form-data
-      boundary = "----WebKitFormBoundary#{SecureRandom.hex(16)}"
-      
-      # Read the file content
-      file_content = File.binread(firmware_path)
-      filename = File.basename(firmware_path)
-      
-      # Create the multipart body
-      post_body = []
-      post_body << "--#{boundary}\r\n"
-      post_body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{filename}\"\r\n"
-      post_body << "Content-Type: application/octet-stream\r\n\r\n"
-      post_body << file_content
-      post_body << "\r\n--#{boundary}--\r\n"
-      
-      # Upload the firmware
-      response = client.authenticated_request(
-        :post,
-        http_push_uri,
-        {
-          headers: {
-            'Content-Type' => "multipart/form-data; boundary=#{boundary}",
-            'If-Match' => etag
-          },
-          body: post_body.join
-        }
-      )
-      
-      if response.status < 200 || response.status >= 300
-        raise Error, "Firmware upload failed with status #{response.status}: #{response.body}"
-      end
-      
-      # Extract job ID from response
-      response_data = JSON.parse(response.body)
-      job_id = response_data['Id'] || response_data['TaskId']
-      
-      if job_id.nil?
-        raise Error, "Failed to extract job ID from firmware upload response"
-      end
-      
-      puts "Firmware update job created with ID: #{job_id}"
-      job_id
-    end
-
-    def wait_for_job_completion(job_id, timeout)
-      puts "Waiting for firmware update job #{job_id} to complete..."
-      
-      start_time = Time.now
-      loop do
-        status = get_job_status(job_id)
-        
-        case status
-        when 'Completed'
-          puts "Firmware update completed successfully"
-          return true
-        when 'Failed'
-          raise Error, "Firmware update job failed"
-        when 'Scheduled', 'Running', 'Downloading', 'Pending'
-          # Job still in progress
-        else
-          puts "Unknown job status: #{status}"
-        end
-        
-        if Time.now - start_time > timeout
-          raise Error, "Firmware update timed out after #{timeout} seconds"
-        end
-        
-        # Wait before checking again
-        sleep 10
-      end
-    end
-
-    def get_job_status(job_id)
-      response = client.authenticated_request(
-        :get,
-        "/redfish/v1/TaskService/Tasks/#{job_id}"
-      )
-      
-      if response.status != 200
-        raise Error, "Failed to get job status with status #{response.status}: #{response.body}"
-      end
-      
-      response_data = JSON.parse(response.body)
-      response_data['TaskState'] || 'Unknown'
-    end
-  end
-end 

data/idrac-0.1.7/lib/idrac/screenshot.rb

@@ -1,49 +0,0 @@
-require 'httparty'
-require 'nokogiri'
-
-module IDRAC
-  # Reverse engineered screenshot functionality for iDRAC
-  # This uses introspection on how the web UI creates screenshots rather than the Redfish API
-  class Screenshot
-    attr_reader :client
-
-    def initialize(client)
-      @client = client
-    end
-
-    def capture
-      # Login to get the forward URL and cookies
-      forward_url = client.login
-      
-      # Extract the key-value pairs from the forward URL (format: index?ST1=ABC,ST2=DEF)
-      tokens = forward_url.split("?").last.split(",").inject({}) do |acc, kv| 
-        k, v = kv.split("=")
-        acc[k] = v
-        acc
-      end
-      
-      # Generate a timestamp for the request
-      timestamp_ms = (Time.now.to_f * 1000).to_i
-      
-      # First request to trigger the screenshot capture
-      path = "data?get=consolepreview[manual%20#{timestamp_ms}]"
-      res = client.get(path: path, headers: tokens)
-      raise Error, "Failed to trigger screenshot capture." unless res.code.between?(200, 299)
-      
-      # Wait for the screenshot to be generated
-      sleep 2
-      
-      # Second request to get the actual screenshot image
-      path = "capconsole/scapture0.png?#{timestamp_ms}"
-      res = client.get(path: path, headers: tokens)
-      raise Error, "Failed to retrieve screenshot image." unless res.code.between?(200, 299)
-      
-      # Save the screenshot to a file
-      filename = "idrac_screenshot_#{timestamp_ms}.png"
-      File.open(filename, "wb") { |f| f.write(res.body) }
-      
-      # Return the filename
-      filename
-    end
-  end
-end 

data/idrac-0.1.7/lib/idrac/version.rb

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

data/idrac-0.1.7/lib/idrac.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'httparty'
-require 'nokogiri'
-require 'faraday'
-require 'faraday/multipart'
-require 'base64'
-require 'uri'
-# If dev, required debug
-require 'debug' if ENV['RUBY_ENV'] == 'development'
-
-require_relative "idrac/version"
-require_relative "idrac/client"
-require_relative "idrac/screenshot"
-require_relative "idrac/firmware"
-
-module IDRAC
-  class Error < StandardError; end
-  
-  def self.new(host:, username:, password:, port: 443, use_ssl: true, verify_ssl: true)
-    Client.new(
-      host: host,
-      username: username,
-      password: password,
-      port: port,
-      use_ssl: use_ssl,
-      verify_ssl: verify_ssl
-    )
-  end
-end

data/idrac-0.1.7/sig/idrac.rbs

@@ -1,4 +0,0 @@
-module Idrac
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end