idrac 0.1.31 → 0.1.38

data/updater.rb

@@ -1,729 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'net/http'
-require 'uri'
-require 'json'
-require 'nokogiri'
-require 'open-uri'
-require 'fileutils'
-require 'zip'
-require 'set'
-require 'securerandom'
-
-class DellFirmwareUpdater
-  DEFAULT_USERNAME = 'root'
-  DEFAULT_PASSWORD = 'calvin'
-  DOWNLOAD_DIR = 'dell_firmware_downloads'
-
-  # Dell catalog URLs
-  DELL_CATALOG_BASE = 'https://downloads.dell.com'
-  DELL_CATALOG_URL = "#{DELL_CATALOG_BASE}/catalog/Catalog.xml.gz"
-  DELL_CATALOG_INDEX_URL = "#{DELL_CATALOG_BASE}/catalog/CatalogIndex.xml"
-
-  def initialize(idrac_ip, username = DEFAULT_USERNAME, password = DEFAULT_PASSWORD)
-    @idrac_ip = idrac_ip
-    @username = username
-    @password = password
-    @service_tag = nil
-    @model = nil
-    @redfish_base_url = "https://#{@idrac_ip}/redfish/v1"
-
-    FileUtils.mkdir_p(DOWNLOAD_DIR) unless Dir.exist?(DOWNLOAD_DIR)
-  end
-
-  def get_system_info
-    uri = URI.parse("#{@redfish_base_url}/Systems/System.Embedded.1")
-
-    begin
-      response = make_redfish_request(uri)
-      data = JSON.parse(response.body)
-      @service_tag = data['SKU']
-      @model = data['Model']
-
-      # Try to get additional system identifiers that might match Dell's catalog
-      @system_id = data['SystemType'] || ''
-      @manufacturer = data['Manufacturer'] || ''
-
-      puts "Service Tag: #{@service_tag}"
-      puts "Model: #{@model}"
-      puts "System ID: #{@system_id}" if @system_id
-      puts "Manufacturer: #{@manufacturer}" if @manufacturer
-
-      return {
-        service_tag: @service_tag,
-        model: @model,
-        system_id: @system_id,
-        manufacturer: @manufacturer
-      }
-    rescue => e
-      puts "Error retrieving system information: #{e.message}"
-      nil
-    end
-  end
-
-  def get_current_firmware_versions
-    uri = URI.parse("#{@redfish_base_url}/UpdateService/FirmwareInventory")
-
-    begin
-      response = make_redfish_request(uri)
-      data = JSON.parse(response.body)
-
-      firmware_list = []
-
-      if data['Members'] && !data['Members'].empty?
-        data['Members'].each do |member|
-          member_uri = member['@odata.id']
-          firmware_uri = URI.parse("https://#{@idrac_ip}#{member_uri}")
-          firmware_response = make_redfish_request(firmware_uri)
-          firmware_data = JSON.parse(firmware_response.body)
-
-          firmware_list << {
-            name: firmware_data['Name'],
-            id: firmware_data['Id'],
-            version: firmware_data['Version'],
-            updateable: firmware_data['Updateable'] || false
-          }
-        end
-      end
-
-      firmware_list
-    rescue => e
-      puts "Error retrieving current firmware versions: #{e.message}"
-      []
-    end
-  end
-
-  def download_dell_catalog
-    catalog_file = File.join(DOWNLOAD_DIR, 'Catalog.xml.gz')
-    catalog_xml = File.join(DOWNLOAD_DIR, 'Catalog.xml')
-    etag_file = File.join(DOWNLOAD_DIR, 'Catalog.etag')
-
-    # Check if we already have the catalog and if it's current
-    if File.exist?(catalog_xml) && File.exist?(etag_file)
-      current_etag = File.read(etag_file).strip
-
-      # Check if the catalog has changed using HEAD request
-      uri = URI.parse(DELL_CATALOG_URL)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-      request = Net::HTTP::Head.new(uri.request_uri)
-      response = http.request(request)
-
-      server_etag = response['etag']&.strip
-
-      if server_etag && server_etag == current_etag
-        puts "Catalog is already up to date (ETag: #{current_etag})"
-        return catalog_xml
-      else
-        puts "Catalog has changed. Current ETag: #{current_etag}, Server ETag: #{server_etag}"
-      end
-    end
-
-    puts "Downloading Dell catalog..."
-
-    begin
-      # Download the compressed catalog
-      uri = URI.parse(DELL_CATALOG_URL)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-      request = Net::HTTP::Get.new(uri.request_uri)
-      response = http.request(request)
-
-      # Save the ETag for future checks
-      if response['etag']
-        File.write(etag_file, response['etag'].strip)
-      end
-
-      # Save the catalog
-      File.open(catalog_file, 'wb') do |file|
-        file.write(response.body)
-      end
-
-      # Decompress the catalog
-      system("gunzip -f #{catalog_file}")
-
-      puts "Catalog downloaded and extracted to #{catalog_xml}"
-      return catalog_xml
-    rescue => e
-      puts "Error downloading Dell catalog: #{e.message}"
-      # If download fails but we have an existing catalog, use that
-      if File.exist?(catalog_xml)
-        puts "Using existing catalog file"
-        return catalog_xml
-      end
-      return nil
-    end
-  end
-
-  def get_available_updates_from_catalog(catalog_path)
-    return [] unless @model && File.exist?(catalog_path)
-
-    begin
-      doc = Nokogiri::XML(File.open(catalog_path))
-
-      # Extract model code from full model name (e.g., "PowerEdge R730" -> "R730")
-      model_code = @model.split(/\s+/).last
-
-      puts "Searching for updates for model: #{@model} (code: #{model_code})"
-
-      # First, build a mapping of model names to system IDs
-      model_to_system_id = {}
-
-      doc.xpath("//SupportedSystems/Brand/Model").each do |model_node|
-        system_id = model_node['systemID']
-        display_node = model_node.xpath("./Display[@lang='en']").first
-
-        if display_node && system_id
-          model_name = display_node.text.strip
-          model_to_system_id[model_name] = system_id
-
-          # Also map just the model number (R730, etc.)
-          if model_name =~ /[RT]\d+/
-            model_short = model_name.match(/([RT]\d+\w*)/)[1]
-            model_to_system_id[model_short] = system_id
-          end
-        end
-      end
-
-      # Find the system ID for our model
-      target_system_ids = []
-
-      # Try exact match first
-      if model_to_system_id[@model]
-        target_system_ids << model_to_system_id[@model]
-      end
-
-      # Try model code match
-      if model_to_system_id[model_code]
-        target_system_ids << model_to_system_id[model_code]
-      end
-
-      # If we still don't have a match, try a more flexible approach
-      if target_system_ids.empty?
-        model_to_system_id.each do |name, id|
-          if name.include?(model_code) || model_code.include?(name)
-            target_system_ids << id
-          end
-        end
-      end
-
-      # Print what we found
-      if target_system_ids.empty?
-        puts "Could not find system ID for #{@model} or #{model_code}"
-        puts "Available models in catalog: #{model_to_system_id.keys.take(10).join(', ')}..."
-      else
-        puts "Found system IDs for #{@model}: #{target_system_ids.join(', ')}"
-      end
-
-      # Find all components for this model
-      updates = []
-
-      # Find SoftwareComponents for this model
-      doc.xpath("//SoftwareComponent").each do |component|
-        # Check if this component supports any of our target system IDs
-        supported_system_ids = component.xpath(".//SupportedSystems/Brand/Model/@systemID").map(&:value)
-
-        match_found = false
-        matching_id = nil
-
-        # Check if any of our target system IDs are supported
-        target_system_ids.each do |target_id|
-          if supported_system_ids.include?(target_id)
-            match_found = true
-            matching_id = target_id
-            break
-          end
-        end
-
-        # If no direct match, try to match by model name in CDATA
-        if !match_found
-          cdata_content = component.xpath(".//SupportedSystems/Brand/Model/Display").map(&:text).join(" ")
-          if cdata_content.include?(model_code)
-            match_found = true
-            matching_id = "CDATA_match"
-          end
-        end
-
-        next unless match_found
-
-        # Get component details
-        name_node = component.xpath("./Name/Display[@lang='en']").first
-        name = name_node ? name_node.text.strip : ""
-
-        component_type_node = component.xpath("./ComponentType/Display[@lang='en']").first
-        component_type = component_type_node ? component_type_node.text.strip : ""
-
-        path = component['path'] || ""
-        category_node = component.xpath("./Category/Display[@lang='en']").first
-        category = category_node ? category_node.text.strip : ""
-
-        release_date = component['releaseDate'] || ""
-        version = component['dellVersion'] || component['vendorVersion'] || ""
-
-        # Only include firmware updates
-        if component_type.include?("Firmware") ||
-           category.include?("BIOS") ||
-           category.include?("Firmware") ||
-           category.include?("iDRAC") ||
-           name.include?("BIOS") ||
-           name.include?("Firmware") ||
-           name.include?("iDRAC")
-
-          download_url = "#{DELL_CATALOG_BASE}/#{path}"
-
-          updates << {
-            name: name,
-            version: version,
-            category: category,
-            release_date: release_date,
-            download_url: download_url,
-            file_name: File.basename(path),
-            matching_system_id: matching_id
-          }
-        end
-      end
-
-      puts "Found #{updates.length} firmware updates for #{@model}"
-      updates
-    rescue => e
-      puts "Error parsing Dell catalog: #{e.message}"
-      puts e.backtrace.join("\n")
-      []
-    end
-  end
-
-  def download_firmware(update)
-    return false unless update && update[:download_url]
-
-    begin
-      file_path = File.join(DOWNLOAD_DIR, update[:file_name])
-
-      puts "Downloading #{update[:name]} v#{update[:version]} (#{update[:file_name]})..."
-      File.open(file_path, 'wb') do |file|
-        file.write(URI.open(update[:download_url]).read)
-      end
-
-      puts "Downloaded to #{file_path}"
-
-      # If it's a zip file, extract it to find the DUP or EFI file
-      if file_path.end_with?('.zip')
-        extract_dir = File.join(DOWNLOAD_DIR, File.basename(file_path, '.zip'))
-        FileUtils.mkdir_p(extract_dir)
-
-        Zip::File.open(file_path) do |zip_file|
-          zip_file.each do |entry|
-            # Look for .EFI files which are suitable for Redfish update
-            if entry.name.end_with?('.EFI', '.efi')
-              entry_path = File.join(extract_dir, entry.name)
-              entry.extract(entry_path)
-              puts "Extracted #{entry.name} to #{entry_path}"
-              return entry_path
-            end
-          end
-        end
-      end
-
-      return file_path
-    rescue => e
-      puts "Error downloading firmware: #{e.message}"
-      false
-    end
-  end
-
-  def upload_firmware(file_path)
-    begin
-      # Step 1: Get the HttpPushUri from UpdateService
-      puts "Getting HttpPushUri from UpdateService..."
-      update_service_uri = URI.parse("#{@redfish_base_url}/UpdateService")
-      update_service_response = make_redfish_request(update_service_uri)
-      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
-
-      # Step 2: Get the ETag for the HttpPushUri
-      uri = URI.parse("https://#{@idrac_ip}#{http_push_uri}")
-      request = Net::HTTP::Get.new(uri)
-      request.basic_auth(@username, @password)
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-      response = http.request(request)
-      etag = response['ETag']
-
-      puts "Got ETag: #{etag}"
-
-      # Step 3: Upload the firmware file using multipart/form-data
-      puts "Uploading firmware file to iDRAC..."
-
-      # Create a boundary for multipart/form-data
-      boundary = "----WebKitFormBoundary#{SecureRandom.hex(16)}"
-
-      request = Net::HTTP::Post.new(uri)
-      request.basic_auth(@username, @password)
-      request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
-      request['If-Match'] = etag
-
-      # Read the file content
-      file_content = File.binread(file_path)
-      filename = File.basename(file_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"
-
-      request.body = post_body.join
-
-      response = http.request(request)
-
-      if response.code.to_i == 201
-        puts "Firmware file uploaded successfully"
-        upload_data = JSON.parse(response.body)
-        available_entry = upload_data['Id']
-        puts "Created entry ID: #{available_entry}"
-
-        # Step 4: Initiate the firmware update using SimpleUpdate
-        puts "Initiating firmware update..."
-        uri = URI.parse("#{@redfish_base_url}/UpdateService/Actions/UpdateService.SimpleUpdate")
-
-        request = Net::HTTP::Post.new(uri)
-        request.basic_auth(@username, @password)
-        request.content_type = 'application/json'
-
-        # Use the URI of the uploaded file
-        image_uri = "#{http_push_uri}/#{available_entry}"
-        puts "Using ImageURI: #{image_uri}"
-
-        request.body = JSON.generate({
-          'ImageURI' => image_uri,
-          '@Redfish.OperationApplyTime' => 'Immediate'
-        })
-
-        response = http.request(request)
-
-        if response.code.to_i >= 200 && response.code.to_i < 300
-          puts "Firmware update initiated successfully"
-
-          # Extract job ID from response
-          job_id = nil
-          if response['Location']
-            job_id = response['Location'].split('/').last
-          elsif response.body && !response.body.empty?
-            begin
-              response_data = JSON.parse(response.body)
-              if response_data['@odata.id']
-                job_id = response_data['@odata.id'].split('/').last
-              elsif response_data['Id']
-                job_id = response_data['Id']
-              end
-            rescue JSON::ParserError
-              # Not JSON, ignore
-            end
-          end
-
-          # If we have a job ID, monitor the job
-          if job_id
-            puts "Monitoring job #{job_id}..."
-            monitor_update_job(job_id)
-          else
-            puts "No job ID found. Cannot monitor progress."
-          end
-
-          return true
-        else
-          puts "Firmware update failed: #{response.code} - #{response.body}"
-          return false
-        end
-      else
-        puts "Firmware file upload failed: #{response.code} - #{response.body}"
-        return false
-      end
-    rescue => e
-      puts "Error uploading firmware: #{e.message}"
-      puts e.backtrace.join("\n")
-      false
-    end
-  end
-
-  def monitor_update_job(job_id)
-    uri = URI.parse("#{@redfish_base_url}/TaskService/Tasks/#{job_id}")
-
-    puts "Update job started. This may take several minutes."
-    puts "Progress: [" + " " * 50 + "] 0%"
-
-    completed = false
-    last_message = ""
-    start_time = Time.now
-
-    while !completed && (Time.now - start_time) < 3600 # 1 hour timeout
-      begin
-        response = make_redfish_request(uri)
-
-        if response.code.to_i >= 200 && response.code.to_i < 300
-          job_data = JSON.parse(response.body)
-
-          state = job_data['TaskState'] || ""
-          percent = job_data['PercentComplete'] || 0
-          status = job_data['TaskStatus'] || ""
-          message = job_data['Messages'].first['Message'] rescue ""
-
-          # Only update if something changed
-          if last_message != "#{state} - #{percent}% - #{status} - #{message}"
-            # Clear the current line
-            print "\r" + " " * 80 + "\r"
-
-            # Print progress bar
-            progress = (percent / 2).to_i
-            progress_bar = "[" + "#" * progress + " " * (50 - progress) + "] #{percent}%"
-            puts "Status: #{state} - #{status}"
-            puts "Progress: #{progress_bar}"
-            puts "Message: #{message}" if !message.empty?
-
-            last_message = "#{state} - #{percent}% - #{status} - #{message}"
-          end
-
-          # Check if job is completed
-          if ['Completed', 'Exception', 'Killed', 'Cancelled'].include?(state)
-            completed = true
-
-            if state == 'Completed' && status == 'OK'
-              puts "\nFirmware update completed successfully!"
-            else
-              puts "\nFirmware update failed: #{state} - #{status}"
-              puts "Error message: #{message}" if !message.empty?
-
-              # Try to get more detailed error information
-              if job_data['Messages'] && !job_data['Messages'].empty?
-                job_data['Messages'].each do |msg|
-                  puts "- #{msg['Message']}" if msg['Message']
-                end
-              end
-            end
-          end
-        else
-          puts "Error checking job status: #{response.code}"
-        end
-      rescue => e
-        puts "Error monitoring job: #{e.message}"
-      end
-
-      # Don't hammer the API
-      sleep 10 unless completed
-    end
-
-    if !completed
-      puts "Timeout waiting for job to complete. Please check the iDRAC web interface."
-    end
-  end
-
-  def compare_firmware_versions(current_firmware, available_updates)
-    puts "\nFirmware Version Comparison:"
-    puts "=" * 100
-    puts "%-30s %-20s %-20s %-10s %-15s %s" % ["Component", "Current Version", "Available Version", "Updateable", "Category", "Status"]
-    puts "-" * 100
-
-    # Track components we've already displayed to avoid duplicates
-    displayed_components = Set.new
-
-    # First show current firmware with available updates
-    current_firmware.each do |firmware|
-      # Make sure firmware name is not nil
-      firmware_name = firmware[:name] || ""
-
-      # Skip if we've already displayed this component
-      next if displayed_components.include?(firmware_name.downcase)
-      displayed_components.add(firmware_name.downcase)
-
-      # Extract key identifiers from the firmware name
-      # This helps match components like "Intel(R) Ethernet 10G 4P X520" to "Intel NIC Family for X520"
-      identifiers = extract_identifiers(firmware_name)
-
-      # Try to find a matching update
-      matching_update = available_updates.find do |update|
-        update_name = update[:name] || ""
-
-        # Check if any of our identifiers match the update name
-        identifiers.any? { |id| update_name.downcase.include?(id.downcase) } ||
-        # Or if the update name contains the firmware name
-        update_name.downcase.include?(firmware_name.downcase) ||
-        # Or if the firmware name contains the update name
-        firmware_name.downcase.include?(update_name.downcase)
-      end
-
-      current_version = firmware[:version] || "Unknown"
-      available_version = matching_update ? matching_update[:version] : "N/A"
-      category = matching_update ? matching_update[:category] : "N/A"
-
-      # Determine update status
-      status = if available_version == "N/A"
-                 "No update available"
-               elsif available_version == current_version
-                 "Current"
-               else
-                 "UPDATE AVAILABLE"
-               end
-
-      puts "%-30s %-20s %-20s %-10s %-15s %s" % [
-        firmware_name.to_s[0..29],
-        current_version,
-        available_version,
-        firmware[:updateable] ? "Yes" : "No",
-        category,
-        status
-      ]
-    end
-
-    # Then show available updates that don't match any current firmware
-    available_updates.each do |update|
-      update_name = update[:name] || ""
-
-      # Skip if we've already displayed this component
-      next if displayed_components.include?(update_name.downcase)
-      displayed_components.add(update_name.downcase)
-
-      # Skip if this update was already matched to a current firmware
-      next if current_firmware.any? do |firmware|
-        firmware_name = firmware[:name] || ""
-        identifiers = extract_identifiers(firmware_name)
-
-        identifiers.any? { |id| update_name.downcase.include?(id.downcase) } ||
-        update_name.downcase.include?(firmware_name.downcase) ||
-        firmware_name.downcase.include?(update_name.downcase)
-      end
-
-      puts "%-30s %-20s %-20s %-10s %-15s %s" % [
-        update_name.to_s[0..29],
-        "Not Installed",
-        update[:version] || "Unknown",
-        "N/A",
-        update[:category] || "N/A",
-        "NEW COMPONENT"
-      ]
-    end
-
-    puts "=" * 100
-  end
-
-  # Helper method to extract identifiers from component names
-  def extract_identifiers(name)
-    return [] unless name
-
-    identifiers = []
-
-    # Extract model numbers like X520, I350, etc.
-    model_matches = name.scan(/[IX]\d{3,4}/)
-    identifiers.concat(model_matches)
-
-    # Extract other common identifiers
-    if name.include?("NIC") || name.include?("Ethernet") || name.include?("Network")
-      identifiers << "NIC"
-    end
-
-    if name.include?("PERC") || name.include?("RAID")
-      identifiers << "PERC"
-      # Extract PERC model like H730
-      perc_match = name.match(/PERC\s+([A-Z]\d{3})/)
-      identifiers << perc_match[1] if perc_match
-    end
-
-    if name.include?("BIOS")
-      identifiers << "BIOS"
-    end
-
-    if name.include?("iDRAC") || name.include?("IDRAC")
-      identifiers << "iDRAC"
-    end
-
-    if name.include?("Power Supply") || name.include?("PSU")
-      identifiers << "PSU"
-    end
-
-    identifiers
-  end
-
-  private
-
-  def make_redfish_request(uri)
-    request = Net::HTTP::Get.new(uri)
-    request.basic_auth(@username, @password)
-
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = true
-    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-
-    http.request(request)
-  end
-end
-
-# Example usage
-if __FILE__ == $0
-  if ARGV.length < 1
-    puts "Usage: #{$0} <idrac_ip> [username] [password]"
-    exit 1
-  end
-
-  idrac_ip = ARGV[0]
-  username = ARGV[1] || DellFirmwareUpdater::DEFAULT_USERNAME
-  password = ARGV[2] || DellFirmwareUpdater::DEFAULT_PASSWORD
-
-  updater = DellFirmwareUpdater.new(idrac_ip, username, password)
-
-  # Get system information
-  system_info = updater.get_system_info
-  if system_info
-    # Get current firmware versions
-    current_firmware = updater.get_current_firmware_versions
-
-    # Download Dell catalog
-    catalog_path = updater.download_dell_catalog
-
-    if catalog_path
-      # Get available updates from catalog
-      available_updates = updater.get_available_updates_from_catalog(catalog_path)
-
-      if available_updates.any?
-        # Compare current vs available versions
-        updater.compare_firmware_versions(current_firmware, available_updates)
-
-        # Prompt for which update to download
-        puts "\nAvailable updates:"
-        available_updates.each_with_index do |update, index|
-          puts "#{index + 1}. #{update[:name]} - #{update[:version]} (#{update[:category]})"
-        end
-
-        print "\nEnter the number of the update to download (or 0 to exit): "
-        selection = STDIN.gets.chomp.to_i
-
-        if selection > 0 && selection <= available_updates.length
-          update = available_updates[selection - 1]
-          firmware_path = updater.download_firmware(update)
-
-          if firmware_path
-            print "Do you want to upload and install this firmware? (y/n): "
-            if STDIN.gets.chomp.downcase == 'y'
-              updater.upload_firmware(firmware_path)
-            end
-          end
-        end
-      else
-        puts "No updates found for #{system_info[:model]}"
-      end
-    end
-  end
-end
-