307 lines
8.7 KiB
Python
Executable File
307 lines
8.7 KiB
Python
Executable File
'''
|
|
Description:
|
|
Provides methods for reading the machines system info
|
|
|
|
Example:
|
|
import RS.Utils.SystemInfo as sysinfo
|
|
sysinfo.get.gpu
|
|
sysinfo.get.cpu
|
|
sysinfo.get.os
|
|
sysinfo.get.totalRam
|
|
sysinfo.get.hdTotal
|
|
'''
|
|
__author__ = 'mharrison-ball'
|
|
|
|
|
|
import ctypes
|
|
import math
|
|
import os
|
|
import platform
|
|
import re
|
|
import subprocess
|
|
import getpass
|
|
import sys
|
|
|
|
try:
|
|
import _winreg
|
|
except:
|
|
pass
|
|
|
|
LINUX_CONST = "Linux"
|
|
WINDOWS_CONST = "Windows"
|
|
|
|
|
|
class MemoryStatusStruct(ctypes.Structure):
|
|
_fields_ = [
|
|
("dwLength", ctypes.c_ulong),
|
|
("dwMemoryLoad", ctypes.c_ulong),
|
|
("ullTotalPhys", ctypes.c_ulonglong),
|
|
("ullAvailPhys", ctypes.c_ulonglong),
|
|
("ullTotalPageFile", ctypes.c_ulonglong),
|
|
("ullAvailPageFile", ctypes.c_ulonglong),
|
|
("ullTotalVirtual", ctypes.c_ulonglong),
|
|
("ullAvailVirtual", ctypes.c_ulonglong),
|
|
("sullAvailExtendedVirtual", ctypes.c_ulonglong),
|
|
]
|
|
|
|
def __init__(self):
|
|
'''
|
|
have to initialize this to the size of MEMORYSTATUSEX
|
|
|
|
:return:
|
|
'''
|
|
self.dwLength = ctypes.sizeof(self)
|
|
super(MemoryStatusStruct, self).__init__()
|
|
|
|
|
|
def getRegistryValue(key, subkey, value):
|
|
'''
|
|
|
|
:param key:
|
|
:param subkey:
|
|
:param value:
|
|
:return:
|
|
'''
|
|
try:
|
|
key = getattr(_winreg, key)
|
|
handle = _winreg.OpenKey(key, subkey)
|
|
(value, type) = _winreg.QueryValueEx(handle, value)
|
|
except:
|
|
return ""
|
|
return value
|
|
|
|
|
|
class SystemInformation(object):
|
|
'''
|
|
Get System Info
|
|
'''
|
|
def __init__(self):
|
|
'''
|
|
|
|
:return:
|
|
'''
|
|
super(SystemInformation, self).__init__()
|
|
self._os = self._osVersion().strip()
|
|
self._cpu = self._cpu().strip()
|
|
self._gpu = self._gpu().strip()
|
|
self._browsers = self._browsers()
|
|
self._ram = self._ram()
|
|
self._totalRam = math.ceil((self._ram.ullTotalPhys / 1024 /1024 /1000 ))
|
|
self._hdTotal = math.ceil(self._disk_c() / (1024*1024*1024))
|
|
self._user = getpass.getuser()
|
|
|
|
|
|
@property
|
|
def user(self):
|
|
return self._user
|
|
|
|
@property
|
|
def os(self):
|
|
return self._os
|
|
|
|
@property
|
|
def cpu(self):
|
|
return self._cpu
|
|
|
|
@property
|
|
def gpu(self):
|
|
return self._gpu
|
|
|
|
@property
|
|
def browsers(self):
|
|
return self._browsers
|
|
|
|
@property
|
|
def ram(self):
|
|
return self._ram
|
|
|
|
@property
|
|
def totalRam(self):
|
|
return self._totalRam
|
|
|
|
@property
|
|
def hdTotal(self):
|
|
return self._hdTotal
|
|
|
|
def _get(key, value):
|
|
return getRegistryValue(key, value)
|
|
|
|
def _osVersion(self):
|
|
'''
|
|
Get OS version
|
|
|
|
:return:
|
|
'''
|
|
# Linux Op
|
|
if platform.system() == LINUX_CONST:
|
|
osName = platform.platform()
|
|
build = platform.version()
|
|
return "{0} ({1})".format(osName, build)
|
|
|
|
# Windows Op
|
|
elif platform.system() == WINDOWS_CONST:
|
|
key = "HKEY_LOCAL_MACHINE"
|
|
subkey = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"
|
|
|
|
osName = getRegistryValue(key, subkey,"ProductName")
|
|
sp = getRegistryValue(key, subkey,"CSDVersion")
|
|
build = getRegistryValue(key, subkey,"CurrentBuildNumber")
|
|
return "{0} {1} (build {2})".format(osName, sp, build)
|
|
return platform.system()
|
|
|
|
def _cpu(self):
|
|
'''
|
|
Get CPU spec
|
|
:return:
|
|
'''
|
|
# Linux Op
|
|
if platform.system() == LINUX_CONST:
|
|
command = "cat /proc/cpuinfo"
|
|
allInfo = subprocess.check_output(command, shell=True).strip()
|
|
for line in allInfo.split("\n"):
|
|
if "model name" in line:
|
|
return re.sub(".*model name.*:", "", line, 1)
|
|
|
|
# Winows Op
|
|
elif platform.system() == WINDOWS_CONST:
|
|
return getRegistryValue(
|
|
"HKEY_LOCAL_MACHINE",
|
|
"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
|
|
"ProcessorNameString")
|
|
return None
|
|
|
|
def _gpu(self):
|
|
'''
|
|
|
|
Get GPU
|
|
:return:
|
|
'''
|
|
# Linux Op
|
|
if platform.system() == LINUX_CONST:
|
|
command = "lspci"
|
|
deviceInfo = subprocess.check_output(command, shell=True).strip()
|
|
for line in deviceInfo.split("\n"):
|
|
if "VGA compatible controller" in line:
|
|
return re.sub(".*VGA compatible controller.*:", "", line, 1).strip()
|
|
|
|
# Winows Op
|
|
elif platform.system() == WINDOWS_CONST:
|
|
return getRegistryValue(
|
|
"HKEY_LOCAL_MACHINE",
|
|
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winsat",
|
|
"PrimaryAdapterString")
|
|
return ""
|
|
|
|
def _firefoxVersion(self):
|
|
'''
|
|
Get Firefox Version
|
|
|
|
:return:
|
|
'''
|
|
# Linux Op
|
|
if platform.system() == LINUX_CONST:
|
|
return os.popen("firefox --version").read().strip()
|
|
|
|
# Windows Op
|
|
elif platform.system() == WINDOWS_CONST:
|
|
try:
|
|
version = getRegistryValue(
|
|
"HKEY_LOCAL_MACHINE",
|
|
"SOFTWARE\\Mozilla\\Mozilla Firefox",
|
|
"CurrentVersion")
|
|
return (u"Mozilla Firefox", version)
|
|
except WindowsError:
|
|
pass
|
|
return None
|
|
|
|
def _iexploreVersion(self):
|
|
'''
|
|
Get Internet Explorer Version
|
|
|
|
:return:
|
|
'''
|
|
# Windows Op
|
|
if platform.system() == WINDOWS_CONST:
|
|
try:
|
|
version = getRegistryValue(
|
|
"HKEY_LOCAL_MACHINE",
|
|
"SOFTWARE\\Microsoft\\Internet Explorer",
|
|
"Version")
|
|
return (u"Internet Explorer", version)
|
|
except WindowsError:
|
|
pass
|
|
return None
|
|
|
|
def _browsers(self):
|
|
'''
|
|
Get Firefox and Explorer version
|
|
|
|
:return:
|
|
'''
|
|
browsers = []
|
|
firefox = self._firefoxVersion()
|
|
if firefox:
|
|
browsers.append(firefox)
|
|
iexplore = self._iexploreVersion()
|
|
if iexplore:
|
|
browsers.append(iexplore)
|
|
|
|
return browsers
|
|
|
|
def _ram(self):
|
|
'''
|
|
Get Ram info
|
|
|
|
:return:
|
|
'''
|
|
self.stat = MemoryStatusStruct()
|
|
|
|
# Linux Op
|
|
if platform.system() == LINUX_CONST:
|
|
meminfo = open('/proc/meminfo').read()
|
|
memList = [mem for mem in meminfo.split("\n") if mem != ""]
|
|
memDict = {}
|
|
for memLine in memList:
|
|
parts = [mem for mem in memLine.strip().split(" ") if mem != ""]
|
|
try:
|
|
memDict[parts[0].split(":")[0]] = int(parts[1])
|
|
except:
|
|
pass
|
|
self.stat.dwMemoryLoad = int(memDict['MemFree']/float(memDict['MemTotal']) * 100)
|
|
self.stat.ullTotalPhys = memDict['MemTotal'] * 1000
|
|
self.stat.ullAvailPhys = memDict['MemFree']
|
|
self.stat.ullTotalPageFile = memDict['PageTables']
|
|
self.stat.ullAvailPageFile = 0 # Page files dont have an upper limit in linux
|
|
self.stat.ullTotalVirtual = memDict['VmallocTotal']
|
|
self.stat.ullAvailVirtual = memDict['VmallocTotal'] - memDict['VmallocUsed']
|
|
self.stat.sullAvailExtendedVirtual = 0 # docs say its always 0
|
|
|
|
# Windows Op
|
|
elif platform.system() == WINDOWS_CONST:
|
|
ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(self.stat))
|
|
return self.stat
|
|
|
|
def _disk_c(self):
|
|
'''
|
|
Get HD primary HD space
|
|
'''
|
|
# Linux Op
|
|
if platform.system() == LINUX_CONST:
|
|
statvfs = os.statvfs("/home")
|
|
return statvfs.f_frsize * statvfs.f_blocks
|
|
|
|
# Windows Op
|
|
elif platform.system() == WINDOWS_CONST:
|
|
drive = unicode(os.getenv("SystemDrive"))
|
|
freeuser = ctypes.c_int64()
|
|
total = ctypes.c_int64()
|
|
free = ctypes.c_int64()
|
|
ctypes.windll.kernel32.GetDiskFreeSpaceExW(drive,
|
|
ctypes.byref(freeuser),
|
|
ctypes.byref(total),
|
|
ctypes.byref(free))
|
|
return total.value
|
|
return None
|
|
|
|
get = SystemInformation()
|