sys-cpu 0.6.1-x86-linux → 0.6.2-x86-linux

data/lib/windows/sys/cpu.rb

@@ -0,0 +1,784 @@
+require 'win32ole'
+require 'socket'
+
+# The Sys module serves only as a namespace
+module Sys
+   # Encapsulates system CPU information
+   class CPU
+      # Error raised if any of the Sys::CPU methods fail.
+      class Error < StandardError; end
+
+      # The version of this library
+      VERSION = '0.6.2'
+
+      # Base connect string
+      BASE_CS = "winmgmts:{impersonationLevel=impersonate}" # :nodoc:
+      
+      # Fields used in the CPUStruct
+      fields = %w/
+         address_width
+         architecture
+         availability
+         caption
+         config_manager_error_code
+         config_manager_user_config
+         cpu_status
+         creation_class_name
+         freq
+         voltage
+         data_width
+         description
+         device_id
+         error_cleared?
+         error_description
+         ext_clock
+         family
+         install_date
+         l2_cache_size
+         l2_cache_speed
+         last_error_code
+         level
+         load_avg
+         manufacturer
+         max_clock_speed
+         name
+         other_family_description
+         pnp_device_id
+         power_management_supported?
+         power_management_capabilities
+         processor_id
+         processor_type
+         revision
+         role
+         socket_designation
+         status
+         status_info
+         stepping
+         system_creation_class_name
+         system_name
+         unique_id
+         upgrade_method
+         version
+         voltage_caps
+      /
+      
+      # The struct returned by the CPU.processors method
+      CPUStruct = Struct.new("CPUStruct", *fields) # :nodoc:
+      
+      # Returns the +host+ CPU's architecture, or nil if it cannot be
+      # determined.
+      #
+      def self.architecture(host=Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"     
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            self.get_cpu_arch(wmi.Architecture)
+         end
+      end
+      
+      # Returns an integer indicating the speed (i.e. frequency in Mhz) of
+      # +cpu_num+ on +host+, or the localhost if no +host+ is specified.
+      # If +cpu_num+ +1 is greater than the number of cpu's on your system
+      # or this call fails for any other reason, a Error is raised.
+      #
+      def self.freq(cpu_num = 0, host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu#{cpu_num}'"    
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.CurrentClockSpeed
+         end
+      end
+      
+      # Returns the load capacity for +cpu_num+ on +host+, or the localhost
+      # if no host is specified, averaged to the last second. Processor
+      # loading refers to the total computing burden for each processor at
+      # one time.
+      #
+      # Note that this attribute is actually the LoadPercentage.  I may use
+      # one of the Win32_Perf* classes in the future.
+      #
+      def self.load_avg(cpu_num = 0, host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu#{cpu_num}'"    
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.LoadPercentage
+         end    
+      end
+      
+      # Returns a string indicating the cpu model, e.g. Intel Pentium 4.
+      #
+      def self.model(host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"    
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.Name
+         end
+      end
+      
+      # Returns an integer indicating the number of cpu's on the system.
+      #--
+      # This (oddly) requires a different class.
+      #
+      def self.num_cpu(host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_ComputerSystem='#{host}'"
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.NumberOfProcessors
+         end
+      end
+      
+      # Returns a CPUStruct for each CPU on +host+, or the localhost if no
+      # +host+ is specified.  A CPUStruct contains the following members:
+      #
+      # * address_width
+      # * architecture
+      # * availability
+      # * caption
+      # * config_manager_error_code
+      # * config_manager_user_config
+      # * cpu_status
+      # * creation_class_name
+      # * freq
+      # * voltage
+      # * data_width
+      # * description
+      # * device_id
+      # * error_cleared?
+      # * error_description
+      # * ext_clock
+      # * family
+      # * install_date
+      # * l2_cache_size
+      # * l2_cache_speed
+      # * last_error_code
+      # * level
+      # * load_avg
+      # * manufacturer
+      # * max_clock_speed
+      # * name
+      # * other_family_description
+      # * pnp_device_id
+      # * power_management_supported?
+      # * power_management_capabilities
+      # * processor_id
+      # * processor_type
+      # * revision
+      # * role
+      # * socket_designation
+      # * status
+      # * status_info
+      # * stepping
+      # * system_creation_class_name
+      # * system_name
+      # * unique_id
+      # * upgrade_method
+      # * version
+      # * voltage_caps
+      #
+      # Note that not all of these members will necessarily be defined.
+      #
+      def self.processors(host = Socket.gethostname) # :yields: CPUStruct
+         begin
+            wmi = WIN32OLE.connect(BASE_CS + "//#{host}/root/cimv2")
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            wmi.InstancesOf("Win32_Processor").each{ |cpu|
+               yield CPUStruct.new(
+                  cpu.AddressWidth,
+                  self.get_cpu_arch(cpu.Architecture),
+                  self.get_availability(cpu.Availability),
+                  cpu.Caption,
+                  self.get_cmec(cpu.ConfigManagerErrorCode),
+                  cpu.ConfigManagerUserConfig,
+                  get_status(cpu.CpuStatus),
+                  cpu.CreationClassName,
+                  cpu.CurrentClockSpeed,
+                  cpu.CurrentVoltage,
+                  cpu.DataWidth,
+                  cpu.Description,
+                  cpu.DeviceId,
+                  cpu.ErrorCleared,
+                  cpu.ErrorDescription,
+                  cpu.ExtClock,
+                  self.get_family(cpu.Family),
+                  cpu.InstallDate,
+                  cpu.L2CacheSize,
+                  cpu.L2CacheSpeed,
+                  cpu.LastErrorCode,
+                  cpu.Level,
+                  cpu.LoadPercentage,
+                  cpu.Manufacturer,
+                  cpu.MaxClockSpeed,
+                  cpu.Name,
+                  cpu.OtherFamilyDescription,
+                  cpu.PNPDeviceID,
+                  cpu.PowerManagementSupported,
+                  cpu.PowerManagementCapabilities,
+                  cpu.ProcessorId,
+                  self.get_processor_type(cpu.ProcessorType),
+                  cpu.Revision,
+                  cpu.Role,
+                  cpu.SocketDesignation,
+                  cpu.Status,
+                  cpu.StatusInfo,
+                  cpu.Stepping,
+                  cpu.SystemCreationClassName,
+                  cpu.SystemName,
+                  cpu.UniqueId,
+                  self.get_upgrade_method(cpu.UpgradeMethod),
+                  cpu.Version,
+                  self.get_voltage_caps(cpu.VoltageCaps)
+               )
+            }
+         end           
+      end
+
+      # Returns a string indicating the type of processor, e.g. GenuineIntel.
+      #
+      def self.type(host = Socket.gethostname)
+         cs = BASE_CS + "//#{host}/root/cimv2:Win32_Processor='cpu0'"    
+         begin
+            wmi = WIN32OLE.connect(cs)
+         rescue WIN32OLERuntimeError => e
+            raise Error, e
+         else
+            return wmi.Manufacturer
+         end
+      end
+            
+      private
+      
+      # Convert the ConfigManagerErrorCode number to its corresponding string
+      # Note that this value returns nil on my system.
+      #
+      def self.get_cmec(num)
+         case
+            when 0
+               str = "The device is working properly."
+               return str
+            when 1
+               str = "The device is not configured correctly."
+               return str
+            when 2
+               str = "Windows cannot load the driver for the device."
+               return str
+            when 3
+               str = "The driver for the device might be corrupted, or the"
+               str << " system may be running low on memory or other"
+               str << " resources."
+               return str
+            when 4
+               str = "The device is not working properly. One of the drivers"
+               str << " or the registry might be corrupted."
+               return str
+            when 5
+               str = "The driver for this device needs a resource that"
+               str << " Windows cannot manage."
+               return str
+            when 6
+               str = "The boot configuration for this device conflicts with"
+               str << " other devices."
+               return str
+            when 7
+               str = "Cannot filter."
+               return str
+            when 8
+               str = "The driver loader for the device is missing."
+               return str
+            when 9
+               str = "This device is not working properly because the"
+               str << " controlling firmware is reporting the resources"
+               str << " for the device incorrectly."
+               return str
+            when 10
+               str = "This device cannot start."
+               return str
+            when 11
+               str = "This device failed."
+               return str
+            when 12
+               str = "This device cannot find enough free resources that"
+               str << " it can use."
+               return str
+            when 13
+               str = "Windows cannot verify this device's resources."
+               return str
+            when 14
+               str = "This device cannot work properly until you restart"
+               str << " your computer."
+               return str
+            when 15
+               str = "This device is not working properly because there is"
+               str << " probably a re-enumeration problem."
+               return str
+            when 16
+               str = "Windows cannot identify all the resources this device "
+               str << " uses."
+               return str
+            when 17
+               str = "This device is asking for an unknown resource type."
+               return str
+            when 18
+               str = "Reinstall the drivers for this device."
+               return str
+            when 19
+               str = "Failure using the VXD loader."
+               return str
+            when 20
+               str = "Your registry might be corrupted."
+               return str
+            when 21
+               str = "System failure: try changing the driver for this device."
+               str << " If that does not work, see your hardware documentation."
+               str << " Windows is removing this device."
+               return str
+            when 22
+               str = "This device is disabled."
+               return str
+            when 23
+               str = "System failure: try changing the driver for this device."
+               str << "If that doesn't work, see your hardware documentation."
+               return str
+            when 24
+               str = "This device is not present, not working properly, or"
+               str << " does not have all its drivers installed."
+               return str
+            when 25
+               str = "Windows is still setting up this device."
+               return str
+            when 26
+               str = "Windows is still setting up this device."
+               return str
+            when 27
+               str = "This device does not have valid log configuration."
+               return str
+            when 28
+               str = "The drivers for this device are not installed."
+               return str
+            when 29
+               str = "This device is disabled because the firmware of the"
+               str << " device did not give it the required resources."
+               return str
+            when 30
+               str = "This device is using an Interrupt Request (IRQ)"
+               str << " resource that another device is using."
+               return str
+            when 31
+               str = "This device is not working properly because Windows"
+               str << " cannot load the drivers required for this device"
+               return str
+            else
+               return nil
+         end
+      end
+      
+      # Convert an cpu architecture number to a string
+      def self.get_cpu_arch(num)
+         case num
+            when 0
+               return "x86"
+            when 1
+               return "MIPS"
+            when 2
+               return "Alpha"
+            when 3
+               return "PowerPC"
+            when 4
+               return "IA64"
+            else
+               return nil
+         end
+      end
+      
+      # convert an Availability number into a string
+      def self.get_availability(num)
+         case num
+            when 1
+               return "Other"
+            when 2
+               return "Unknown"
+            when 3
+               return "Running"
+            when 4
+               return "Warning"
+            when 5
+               return "In Test"
+            when 6
+               return "Not Applicable"
+            when 7
+               return "Power Off"
+            when 8
+               return "Off Line"
+            when 9
+               return "Off Duty"
+            when 10
+               return "Degraded"
+            when 11
+               return "Not Installed"
+            when 12
+               return "Install Error"
+            when 13
+               return "Power Save - Unknown"
+            when 14
+               return "Power Save - Low Power Mode"
+            when 15
+               return "Power Save - Standby"
+            when 16
+               return "Power Cycle"
+            when 17
+               return "Power Save - Warning"
+            when 18
+               return "Paused"
+            when 19
+               return "Not Ready"
+            when 20
+               return "Not Configured"
+            when 21
+               return "Quiesced"
+            else
+               return nil
+         end     
+      end
+      
+      # convert CpuStatus to a string form.  Note that values 5 and 6 are
+      # skipped because they're reserved.
+      def self.get_status(num)
+         case num
+            when 0
+               return "Unknown"
+            when 1
+               return "Enabled"
+            when 2
+               return "Disabled by User via BIOS Setup"
+            when 3
+               return "Disabled By BIOS (POST Error)"
+            when 4
+               return "Idle"
+            when 7
+               return "Other"
+            else
+               return nil
+         end
+      end
+      
+      # Convert a family number into the equivalent string
+      def self.get_family(num)
+         case num
+            when 1
+               return "Other"
+		    when 2
+		       return "Unknown"
+		    when 3
+		       return "8086"
+		    when 4
+		       return "80286"
+		    when 5
+		       return "80386"
+		    when 6
+		       return "80486"
+		    when 7
+		       return "8087"
+		    when 8
+		       return "80287"
+		    when 9
+		       return "80387"
+		    when 10
+		       return "80487"
+		    when 11
+		       return "Pentium?"
+		    when 12
+		       return "Pentium?"
+		    when 13
+		       return "Pentium?"
+		    when 14
+		       return "Pentium?"
+		    when 15
+		       return "Celeron?"
+		    when 16
+		       return "Pentium?"
+		    when 17
+		       return "Pentium?"
+		    when 18
+		       return "M1"
+		    when 19
+		       return "M2"
+		    when 24
+		       return "K5"
+		    when 25
+		       return "K6"
+		    when 26
+		       return "K6-2"
+		    when 27
+		       return "K6-3"
+		    when 28
+		       return "AMD"
+		    when 29
+		       return "AMD?"
+		    when 30
+		       return "AMD2900"
+		    when 31
+		       return "K6-2+"
+		    when 32
+		       return "Power"
+		    when 33
+		       return "Power"
+		    when 34
+		       return "Power"
+		    when 35
+		       return "Power"
+		    when 36
+		       return "Power"
+		    when 37
+		       return "Power"
+		    when 38
+		       return "Power"
+		    when 39
+		       return "Power"
+		    when 48
+		       return "Alpha"
+		    when 49
+		       return "Alpha"
+		    when 50
+		       return "Alpha"
+		    when 51
+		       return "Alpha"
+		    when 52
+		       return "Alpha"
+		    when 53
+		       return "Alpha"
+		    when 54
+		       return "Alpha"
+		    when 55
+		       return "Alpha"
+		    when 64
+		       return "MIPS"
+		    when 65
+		       return "MIPS"
+		    when 66
+		       return "MIPS"
+		    when 67
+		       return "MIPS"
+		    when 68
+		       return "MIPS"
+		    when 69
+		       return "MIPS"
+		    when 80
+		       return "SPARC"
+		    when 81
+		       return "SuperSPARC"
+		    when 82
+		       return "microSPARC"
+		    when 83
+		       return "microSPARC"
+		    when 84
+		       return "UltraSPARC"
+		    when 85
+		       return "UltraSPARC"
+		    when 86
+		       return "UltraSPARC"
+		    when 87
+		       return "UltraSPARC"
+		    when 88
+		       return "UltraSPARC"
+		    when 96
+		       return "68040"
+		    when 97
+		       return "68xxx"
+		    when 98
+		       return "68000"
+		    when 99
+		       return "68010"
+		    when 100
+		       return "68020"
+		    when 101
+		       return "68030"
+		    when 112
+		       return "Hobbit"
+		    when 120
+		       return "Crusoe?"
+		    when 121
+		       return "Crusoe?"
+		    when 128
+		       return "Weitek"
+		    when 130
+		       return "Itanium?"
+		    when 144
+		       return "PA-RISC"
+		    when 145
+		       return "PA-RISC"
+		    when 146
+		       return "PA-RISC"
+		    when 147
+		       return "PA-RISC"
+		    when 148
+	           return "PA-RISC"
+		    when 149
+		       return "PA-RISC"
+		    when 150
+		       return "PA-RISC"
+		    when 160
+		       return "V30"
+		    when 176
+		       return "Pentium?"
+		    when 177
+		       return "Pentium?"
+		    when 178
+		       return "Pentium?"
+		    when 179
+		       return "Intel?"
+		    when 180
+		       return "AS400"
+		    when 181
+		       return "Intel?"
+		    when 182
+		       return "AMD"
+		    when 183
+		       return "AMD"
+		    when 184
+		       return "Intel?"
+		    when 185
+		       return "AMD"
+		    when 190
+		       return "K7"
+		    when 200
+		       return "IBM390"
+		    when 201
+		       return "G4"
+		    when 202
+		       return "G5"
+		    when 250
+		       return "i860"
+		    when 251
+		       return "i960"
+		    when 260
+		       return "SH-3"
+		    when 261
+		       return "SH-4"
+		    when 280
+		       return "ARM"
+		    when 281
+		       return "StrongARM"
+		    when 300
+		       return "6x86"
+		    when 301
+		       return "MediaGX"
+		    when 302
+		       return "MII"
+		    when 320
+		       return "WinChip"
+		    when 350
+		       return "DSP"
+		    when 500
+		       return "Video"
+		    else
+		       return nil
+	     end
+      end
+      
+      # Convert power management capabilities number to its equivalent string
+      def self.get_pmc(num)
+         case num
+            when 0
+               return "Unknown"
+            when 1
+               return "Not Supported"
+            when 2
+               return "Disabled"
+            when 3
+               return "Enabled"
+            when 4
+               return "Power Saving Modes Entered Automatically"
+            when 5
+               return "Power State Settable"
+            when 6
+               return "Power Cycling Supported"
+            when 7
+               return "Timed Power On Supported"
+            else
+               return nil
+         end
+      end
+      
+      # Convert a processor type into its equivalent string
+      def self.get_processor_type(num)
+         case num
+            when 1
+               return "Other"
+            when 2
+               return "Unknown"
+            when 3
+               return "Central Processor"
+            when 4
+               return "Math Processor"
+            when 5
+               return "DSP Processor"
+            when 6
+               return "Video Processor"
+            else
+               return nil
+         end
+      end
+      
+      # Convert an upgrade method into its equivalent string
+      def self.get_upgrade_method(num)
+         case num
+            when 1
+               return "Other"
+            when 2
+               return "Unknown"
+            when 3
+               return "Daughter Board"
+            when 4
+               return "ZIF Socket"
+            when 5
+               return "Replacement/Piggy Back"
+            when 6
+               return "None"
+            when 7
+               return "LIF Socket"
+            when 8
+               return "Slot 1"
+            when 9
+               return "Slot 2"
+            when 10
+               return "370 Pin Socket"
+            when 11
+               return "Slot A"
+            when 12
+               return "Slot M"
+            else
+               return nil
+         end
+      end
+      
+      # Convert return values to voltage cap values (floats)
+      def self.get_voltage_caps(num)
+         case num
+            when 1
+               return 5.0
+            when 2
+               return 3.3
+            when 4
+               return 2.9
+            else
+               return nil
+         end
+      end
+   end
+end