def get_host_info():
host_hsh = {}
uname = os.uname()
host_hsh['hostname'] = uname.nodename
host_hsh['release'] = uname.release
host_hsh['machine'] = uname.machine
# Not cross platform....
try:
with open('/proc/uptime', 'r') as fid:
uptime_seconds = float(fid.readline().split()[0])
uptime_str = str(datetime.timedelta(seconds = uptime_seconds))
host_hsh['uptime'] = re.sub('\.\d+$','',uptime_str)
except Exception as err:
pass
try:
with open('/proc/loadavg', 'r') as fid:
(host_hsh['ld1'],host_hsh['ld5'],host_hsh['ld10']) = fid.readline().split()[0:3]
except Exception as err:
pass
try:
host_hsh.update(distro.info())
except Exception as err:
print("Not supported ",err, file=sys.stderr)
return host_hsh
def get_specific_target(
libc: str, arch: str, portable: bool
) -> targets.LinuxTarget:
target: targets.LinuxTarget
if portable:
if libc == "musl":
target = LinuxPortableMuslTarget(arch)
elif libc == "gnu":
target = LinuxGenericTarget(arch, libc)
else:
raise RuntimeError(f"Unsupported libc: {libc}")
else:
distro_info = distro.info()
like = distro_info["like"]
if not like:
like = distro_info["id"]
like_set = set(like.split(" "))
if like_set & {"rhel", "fedora", "centos"}:
target = rpm.get_specific_target(distro_info, arch, libc)
elif like_set & {"debian", "ubuntu"}:
target = deb.get_specific_target(distro_info, arch, libc)
else:
raise RuntimeError(
f"Linux distro not supported: {distro_info['id']}, use "
f"--generic to build a generic portable build"
)
return target
def detect_target(io):
system = platform.system()
if system == 'Linux':
distro_info = distro.info()
like = distro_info['like']
if not like:
like = distro_info['id']
like_set = set(like.split(' '))
if like_set & {'rhel', 'fedora', 'centos'}:
target = rpm.get_specific_target(distro_info)
elif like_set & {'debian', 'ubuntu'}:
target = deb.get_specific_target(distro_info)
else:
raise RuntimeError(
f'Linux distro not supported: {distro_info["id"]}')
elif system == 'Darwin':
v, _, _ = platform.mac_ver()
version = tuple(int(p) for p in v.split('.'))
return macos.get_specific_target(version)
else:
raise RuntimeError(
f'System not supported: {system}')
return target
def __init__(self, config: ConfigHelper) -> None:
self.server = config.get_server()
dist_info: Dict[str, Any]
dist_info = {'name': distro.name(pretty=True)}
dist_info.update(distro.info())
dist_info['release_info'] = distro.distro_release_info()
self.inside_container = False
self.system_info: Dict[str, Any] = {
'python': {
"version": sys.version_info,
"version_string": sys.version.replace("\n", " ")
},
'cpu_info': self._get_cpu_info(),
'sd_info': self._get_sdcard_info(),
'distribution': dist_info,
'virtualization': self._check_inside_container()
}
self._update_log_rollover(log=True)
providers: Dict[str, type] = {
"none": BaseProvider,
"systemd_cli": SystemdCliProvider,
"systemd_dbus": SystemdDbusProvider
}
ptype = config.get('provider', 'systemd_dbus')
pclass = providers.get(ptype)
if pclass is None:
raise config.error(f"Invalid Provider: {ptype}")
self.sys_provider: BaseProvider = pclass(config)
logging.info(f"Using System Provider: {ptype}")
self.server.register_endpoint("/machine/reboot", ['POST'],
self._handle_machine_request)
self.server.register_endpoint("/machine/shutdown", ['POST'],
self._handle_machine_request)
self.server.register_endpoint("/machine/services/restart", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/services/stop", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/services/start", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/system_info", ['GET'],
self._handle_sysinfo_request)
self.server.register_notification("machine:service_state_changed")
# Register remote methods
self.server.register_remote_method("shutdown_machine",
self.sys_provider.shutdown)
self.server.register_remote_method("reboot_machine",
self.sys_provider.reboot)
# IP network shell commands
shell_cmd: SCMDComp = self.server.load_component(
config, 'shell_command')
self.addr_cmd = shell_cmd.build_shell_command("ip -json address")
iwgetbin = "/sbin/iwgetid"
if not pathlib.Path(iwgetbin).exists():
iwgetbin = "iwgetid"
self.iwgetid_cmd = shell_cmd.build_shell_command(iwgetbin)
self.init_evt = asyncio.Event()
def __init__(self, config):
self.server = config.get_server()
dist_info = {'name': distro.name(pretty=True)}
dist_info.update(distro.info())
self.system_info = {
'cpu_info': self._get_cpu_info(),
'sd_info': self._get_sdcard_info(),
'distribution': dist_info
}
# Add system info to log rollover
sys_info_msg = "\nSystem Info:"
for header, info in self.system_info.items():
sys_info_msg += f"\n\n***{header}***"
for key, val in info.items():
sys_info_msg += f"\n {key}: {val}"
self.server.add_log_rollover_item('system_info', sys_info_msg)
self.server.register_endpoint("/machine/reboot", ['POST'],
self._handle_machine_request)
self.server.register_endpoint("/machine/shutdown", ['POST'],
self._handle_machine_request)
self.server.register_endpoint("/machine/services/restart", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/services/stop", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/services/start", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/system_info", ['GET'],
self._handle_sysinfo_request)
# Register remote methods
self.server.register_remote_method("shutdown_machine",
self.shutdown_machine)
self.server.register_remote_method("reboot_machine",
self.reboot_machine)
def get_platform(get_ip=True):
p = {
"processor": platform.processor(),
"python_version": platform.python_version(),
"platform": platform.platform(),
"os_release": platform.release(),
"os_system": platform.system(),
"lbrynet_version": get_lbrynet_version(),
"lbryschema_version": lbryschema_version,
"build": build_type.BUILD, # CI server sets this during build step
}
if p["os_system"] == "Linux":
try:
import distro
p["distro"] = distro.info()
p["desktop"] = os.environ.get('XDG_CURRENT_DESKTOP', 'Unknown')
except ModuleNotFoundError:
pass
# TODO: remove this from get_platform and add a get_external_ip function using treq
if get_ip:
try:
response = json.loads(request.urlopen("https://api.lbry.io/ip").read())
if not response['success']:
raise URLError("failed to get external ip")
p['ip'] = response['data']['ip']
except (URLError, AssertionError):
p['ip'] = "Could not determine IP"
return p
def print_command_result(click_ctx: click.core.Command,
result: typing.Union[dict, list],
analyzer: str,
analyzer_version: str,
output: str = None,
duration: float = None,
pretty: bool = True,
dry_run: bool = False) -> None:
"""Print or submit results, nicely if requested."""
metadata = {
'analyzer': analyzer,
'datetime': datetime2datetime_str(datetime.datetime.utcnow()),
'timestamp': int(time.time()),
'hostname': platform.node(),
'analyzer_version': analyzer_version,
'distribution': distro.info(),
'arguments': _get_click_arguments(click_ctx),
'duration': int(duration) if duration is not None else None,
'python': {
'major': sys.version_info.major,
'minor': sys.version_info.minor,
'micro': sys.version_info.micro,
'releaselevel': sys.version_info.releaselevel,
'serial': sys.version_info.serial,
'api_version': sys.api_version,
'implementation_name': sys.implementation.name
}
}
content = {'result': result, 'metadata': metadata}
if dry_run:
_LOG.info("Printing results to log")
_LOG.info(content)
return
if isinstance(output, str) and output.startswith(('http://', 'https://')):
_LOG.info("Submitting results to %r", output)
response = requests.post(output, json=content)
response.raise_for_status()
_LOG.info("Successfully submitted results to %r, response: %s", output,
response.json()) # Ignore PycodestyleBear (E501)
return
kwargs = {}
if pretty:
kwargs['sort_keys'] = True
kwargs['separators'] = (',', ': ')
kwargs['indent'] = 2
content = json.dumps(content, **kwargs, cls=SafeJSONEncoder)
if output is None or output == '-':
sys.stdout.write(content)
else:
_LOG.info("Writing results to %r", output)
with open(output, 'w') as output_file:
output_file.write(content)
def get_os_version() -> Tuple[str, LooseVersion]:
system_str = platform.system()
if system_str == "Darwin":
return "macos", LooseVersion(platform.mac_ver()[0])
elif system_str == "Windows":
if LooseVersion(platform.release()) >= LooseVersion("10"):
return "windows" + "_" + get_windows_edition(), LooseVersion(
platform.release())
else:
return "windows", LooseVersion(platform.release())
elif system_str == "Linux":
os_info = distro.info()
return os_info["id"], LooseVersion(os_info["version"])
return "", LooseVersion("0")
def install_msbuild(self):
if System.windows: raise OSError('Install Visual Studio 2019 to get MSBuild on Windows')
if System.macos: raise OSError('install_msbuild not implemented for macOS')
dist = distro.info()
if dist['id'] != "ubuntu": raise OSError('install_msbuild only supports Ubuntu')
codename = dist['codename']
execute('curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > /tmp/microsoft.gpg')
execute('sudo mv /tmp/microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg')
execute(f"sudo sh -c 'echo \"deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-{codename}-prod {codename} main\" > /etc/apt/sources.list.d/dotnetdev.list'")
execute('sudo apt-get install apt-transport-https')
execute('sudo apt-get update')
execute('sudo apt-get install dotnet-sdk-2.1')
def get_platform() -> dict:
p = {
"processor": platform.processor(),
"python_version": platform.python_version(),
"platform": platform.platform(),
"os_release": platform.release(),
"os_system": platform.system(),
"lbrynet_version": lbrynet_version,
"build": build_type.BUILD, # CI server sets this during build step
}
if p["os_system"] == "Linux":
import distro
p["distro"] = distro.info()
p["desktop"] = os.environ.get('XDG_CURRENT_DESKTOP', 'Unknown')
return p
def install_clang6(self):
if System.windows: raise OSError('Install Visual Studio 2019 with Clang support')
if System.macos: raise OSError('Install Xcode to get Clang on macOS')
suffix = '1404'
try:
dist = distro.info()
if dist['id'] != "ubuntu": raise OSError('install_clang6 only supports Ubuntu')
majorVersion = int(dist['version_parts']['major'])
if majorVersion >= 16:
suffix = '1604'
console(f'Choosing {suffix} for kernel major={majorVersion}')
except Exception as err:
console(f'Failed to parse linux distro; falling back to {suffix}: {err}')
self.install_clang(clang_major='6', clang_ver='6.0', suffix=suffix)
def dep():
go()
like = distro.info()['like']
if like == "ubuntu":
print("更新缓存...")
cmd = delegator.run("apt update")
if cmd.return_code == 0:
print("完成")
print("安装 git make...")
cmd = delegator.run("apt install -y git make")
if cmd.return_code == 0:
print("安装完成")
elif like.find("rhel") >= 0:
print("安装 git make...")
cmd = delegator.run("yum install git make -y")
if cmd.return_code == 0:
print("安装完成")
else:
print("暂不支持的发行版，请手动安装git make")
def get_platform() -> dict:
os_system = platform.system()
if os.environ and 'ANDROID_ARGUMENT' in os.environ:
os_system = 'android'
d = {
"processor": platform.processor(),
"python_version": platform.python_version(),
"platform": platform.platform(),
"os_release": platform.release(),
"os_system": os_system,
"lbrynet_version": lbrynet_version,
"version": lbrynet_version,
"build": build_info.BUILD, # CI server sets this during build step
}
if d["os_system"] == "Linux":
import distro # pylint: disable=import-outside-toplevel
d["distro"] = distro.info()
d["desktop"] = os.environ.get('XDG_CURRENT_DESKTOP', 'Unknown')
return d
def __init__(self, config: ConfigHelper) -> None:
self.server = config.get_server()
dist_info: Dict[str, Any]
dist_info = {'name': distro.name(pretty=True)}
dist_info.update(distro.info())
self.system_info: Dict[str, Any] = {
'cpu_info': self._get_cpu_info(),
'sd_info': self._get_sdcard_info(),
'distribution': dist_info
}
# Add system info to log rollover
sys_info_msg = "\nSystem Info:"
for header, info in self.system_info.items():
sys_info_msg += f"\n\n***{header}***"
for key, val in info.items():
sys_info_msg += f"\n {key}: {val}"
self.server.add_log_rollover_item('system_info', sys_info_msg)
self.available_services: List[str] = []
self.server.register_endpoint("/machine/reboot", ['POST'],
self._handle_machine_request)
self.server.register_endpoint("/machine/shutdown", ['POST'],
self._handle_machine_request)
self.server.register_endpoint("/machine/services/restart", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/services/stop", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/services/start", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/system_info", ['GET'],
self._handle_sysinfo_request)
# Register remote methods
self.server.register_remote_method("shutdown_machine",
self.shutdown_machine)
self.server.register_remote_method("reboot_machine",
self.reboot_machine)
# Retreive list of services
event_loop = self.server.get_event_loop()
event_loop.register_callback(self._find_active_services)
def __init__(self, config: ConfigHelper) -> None:
self.server = config.get_server()
dist_info: Dict[str, Any]
dist_info = {'name': distro.name(pretty=True)}
dist_info.update(distro.info())
dist_info['release_info'] = distro.distro_release_info()
self.inside_container = False
self.virt_id = "none"
self.system_info: Dict[str, Any] = {
'cpu_info': self._get_cpu_info(),
'sd_info': self._get_sdcard_info(),
'distribution': dist_info,
'virtualization': self._check_inside_container()
}
self._update_log_rollover(log=True)
self.available_services: Dict[str, Dict[str, str]] = {}
self.server.register_endpoint("/machine/reboot", ['POST'],
self._handle_machine_request)
self.server.register_endpoint("/machine/shutdown", ['POST'],
self._handle_machine_request)
self.server.register_endpoint("/machine/services/restart", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/services/stop", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/services/start", ['POST'],
self._handle_service_request)
self.server.register_endpoint("/machine/system_info", ['GET'],
self._handle_sysinfo_request)
self.server.register_notification("machine:service_state_changed")
# Register remote methods
self.server.register_remote_method("shutdown_machine",
self.shutdown_machine)
self.server.register_remote_method("reboot_machine",
self.reboot_machine)
self.init_evt = asyncio.Event()
def go():
print("Install Go...")
like = distro.info()['like']
print("当前系统为" + like)
if like == "ubuntu":
print("配置软件源...")
cmd = delegator.run(
"add-apt-repository ppa:longsleep/golang-backports")
if cmd.return_code == 0:
print("成功")
print("更新缓存...")
cmd = delegator.run("apt update")
if cmd.return_code == 0:
print("完成")
print("安装Golang...")
cmd = delegator.run("apt install golang-go -y")
if cmd.return_code == 0:
print("安装完成")
else:
print("尝试使用二进制文件方式安装Golang...")
go_bin()
elif like.find("rhel") >= 0:
print("安装epel...")
cmd = delegator.run("yum install epel-release -y")
if cmd.return_code == 0:
print("成功")
print("安装Golang...")
cmd = delegator.run("yum install golang -y")
if cmd.return_code == 0:
print("安装完成")
else:
print("暂不支持的发行版...\n尝试使用二进制文件方式安装Golang...")
go_bin()
print("换用国内镜像源")
delegator.run("go env -w GO111MODULE=on")
delegator.run("go env -w GOPROXY=https://goproxy.cn,direct")
def print_command_result(
click_ctx: click.core.Command,
result: typing.Union[dict, list],
analyzer: str,
analyzer_version: str,
output: str = None,
duration: float = None,
pretty: bool = True,
dry_run: bool = False,
) -> None:
"""Print or submit results, nicely if requested."""
metadata = {
"analyzer": analyzer,
"datetime": datetime2datetime_str(datetime.datetime.utcnow()),
"document_id": os.getenv("THOTH_DOCUMENT_ID"),
"timestamp": int(time.time()),
"hostname": platform.node(),
"analyzer_version": analyzer_version,
"distribution": distro.info(),
"arguments": _get_click_arguments(click_ctx),
"duration": int(duration) if duration is not None else None,
"python": {
"major": sys.version_info.major,
"minor": sys.version_info.minor,
"micro": sys.version_info.micro,
"releaselevel": sys.version_info.releaselevel,
"serial": sys.version_info.serial,
"api_version": sys.api_version,
"implementation_name": sys.implementation.name,
},
"os_release": _gather_os_release(),
"thoth_deployment_name": os.getenv("THOTH_DEPLOYMENT_NAME"),
}
content = {"result": result, "metadata": metadata}
if dry_run:
_LOG.info("Printing results to log")
_LOG.info(content)
return
if isinstance(output, str) and output.startswith(("http://", "https://")):
_LOG.info("Submitting results to %r", output)
response = requests.post(output, json=content)
response.raise_for_status()
_LOG.info(
"Successfully submitted results to %r, response: %s",
output,
response.json(),
) # Ignore PycodestyleBear (E501)
return
kwargs = {}
if pretty:
kwargs["sort_keys"] = True
kwargs["separators"] = (",", ": ")
kwargs["indent"] = 2
content = json.dumps(content, **kwargs, cls=SafeJSONEncoder)
if output is None or output == "-":
sys.stdout.write(content)
else:
_LOG.info("Writing results to %r", output)
with open(output, "w") as output_file:
output_file.write(content)
def onekey_report(report_type=REPORT_SUCCESS, traceback_str=None, msg=None):
"""
发送报告到服务器
尽可能保证在致命错误发生时也能传出错误报告
"""
try:
import json
except:
import simplejson as json
try:
import distro
except:
dist = "Unable to load package distro\n" + traceback.format_exc()
else:
try:
dist = json.dumps(distro.info(best=True))
except:
dist = "Unable to read dist\n" + traceback.format_exc()
try:
stdout_str = stdout_logger_last.get_value() + stdout_logger.get_value()
except:
stdout_str = "Unable to read stdout.\n" + traceback.format_exc()
try:
stderr_str = stderr_logger.get_value()
except:
stderr_str = "Unable to read stderr.\n" + traceback.format_exc()
data = {
"linux_dist": dist,
"stdout": stdout_str,
"stderr": stderr_str,
}
try:
if mirrors_to_deploy:
data['installing_mirror'] = ','.join(mirrors_to_deploy)
except:
data['installing_mirror'] = "Unable to get installing_mirror"
if traceback_str is not None and isinstance(traceback_str, str):
data['traceback'] = traceback_str
try:
import platform
except:
pass
else:
try:
data['uname'] = json.dumps(dict(zip(
platform.uname()._fields,
platform.uname()
)))
except:
pass
try:
data['python_version'] = sys.version
except:
pass
try:
if msg is not None:
data['extra_msg'] = str(msg)
except:
pass
try:
if isinstance(email, str) and email:
data["email"] = email
except:
data["email"] = "*****@*****.**"
try:
meminfo = open('/proc/meminfo').read()
matched = re.search(r'^MemTotal:\s+(\d+)', meminfo)
if matched:
mem_total_KB = int(matched.groups()[0])
data['memory'] = mem_total_KB
except:
data['memory'] = 1
dbgprint(__REPORT_URLS__[report_type], data)
try:
r = requests.post(__REPORT_URLS__[report_type], data=data)
except:
if DEBUG:
traceback.print_exc()
try:
r = requests.post(
__REPORT_URLS__[report_type],
data={
"traceback": str(data)
+ "\n-----Except during request-----\n"
+ traceback.format_exc()
},
verify=False, )
except:
raise
else:
dbgprint(r.text, r.headers, r.request.body)
def setup(self): # pylint: disable=too-many-branches
"""
No arguments at this time.
args = (
ConfigArgument(
"--samples",
help="Number of samples to perform.",
dest="samples",
env_var="SAMPLES",
default=1,
type=int,
)
)
"""
self.config.parse_args()
"""Setup the systemd-analyze Test Benchmark.""" # pylint: disable=pointless-string-statement
# Get test_config values
#
# kernel version
# kversion_out = platform.release()
kversion_out = subprocess.run(["uname", "-r"], stdout=subprocess.PIPE, check=False)
kversion_out = kversion_out.stdout.decode("utf-8")
self.tc_values.insert(0, kversion_out.strip())
# cpu test config values
cpuinfo_out = subprocess.run(["lscpu"], stdout=subprocess.PIPE, check=False)
cpuinfo_out = cpuinfo_out.stdout.decode("utf-8")
# cpu model
for line in cpuinfo_out.split("\n"):
if "Model name:" in line:
model = re.search("Model name.*:(.*)", cpuinfo_out).group(1)
# Check for value
if not model:
self.tc_values.insert(1, "NULL")
else:
self.tc_values.insert(1, model.lstrip())
# number of cores
for line in cpuinfo_out.split("\n"):
if "CPU(s):" in line:
numcores = re.search(r"CPU\(s\):(.*)", cpuinfo_out).group(1)
# Check for value
if not numcores:
self.tc_values.insert(2, "NULL")
else:
self.tc_values.insert(2, numcores.strip())
# CPU max MHz
for line in cpuinfo_out.split("\n"):
if "CPU max MHz:" in line:
maxmhz = re.search("CPU max MHz:(.*)", cpuinfo_out).group(1)
# Check for value
if not maxmhz:
self.tc_values.insert(3, "NULL")
else:
self.tc_values.insert(3, maxmhz.strip())
# systemctl target
sysctl_out = subprocess.run(["systemctl", "get-default"], stdout=subprocess.PIPE, check=False)
sysctl_out = sysctl_out.stdout.decode("utf-8")
# Check for value
if not sysctl_out:
self.tc_values.insert(4, "NULL")
else:
self.tc_values.insert(4, sysctl_out.strip())
self.sa_config = {} # pylint: disable=attribute-defined-outside-init
self.sa_config["test_config"] = {}
for index in range(len(self.tc_list)): # pylint: disable=consider-using-enumerate
self.sa_config["test_config"][self.tc_list[index]] = self.tc_values[index]
self.sa_config["test_config"]["distro"] = distro.info(True)
distro_name = distro.name(pretty=True)
distro_name = distro_name.replace(" ", "_")
self.sa_config["test_config"]["distro"]["name"] = distro_name
if "clustername" in os.environ:
clustername = os.environ["clustername"]
self.sa_config["test_config"]["platform"] = clustername + "_" + distro_name + "_" + self.short_curtime
return True
def onekey_report(report_type=REPORT_SUCCESS, traceback_str=None, msg=None):
"""
发送报告到服务器
尽可能保证在致命错误发生时也能传出错误报告
"""
try:
import json
except:
import simplejson as json
try:
import distro
except:
dist = "Unable to load package distro\n" + traceback.format_exc()
else:
try:
dist = json.dumps(distro.info(best=True))
except:
dist = "Unable to read dist\n" + traceback.format_exc()
try:
stdout_str = stdout_logger_last.get_value() + stdout_logger.get_value()
except:
stdout_str = "Unable to read stdout.\n" + traceback.format_exc()
try:
stderr_str = stderr_logger.get_value()
except:
stderr_str = "Unable to read stderr.\n" + traceback.format_exc()
data = {
"linux_dist": dist,
"stdout": stdout_str,
"stderr": stderr_str,
}
try:
if mirrors_to_deploy:
data['installing_mirror'] = ','.join(mirrors_to_deploy)
except:
data['installing_mirror'] = "Unable to get installing_mirror"
if traceback_str is not None and isinstance(traceback_str, str):
data['traceback'] = traceback_str
try:
import platform
except:
pass
else:
try:
data['uname'] = json.dumps(
dict(zip(platform.uname()._fields, platform.uname())))
except:
pass
try:
data['python_version'] = sys.version
except:
pass
try:
if msg is not None:
data['extra_msg'] = str(msg)
except:
pass
try:
if isinstance(email, str) and email:
data["email"] = email
except:
data["email"] = "*****@*****.**"
try:
meminfo = open('/proc/meminfo').read()
matched = re.search(r'^MemTotal:\s+(\d+)', meminfo)
if matched:
mem_total_KB = int(matched.groups()[0])
data['memory'] = mem_total_KB
except:
data['memory'] = 1
dbgprint(__REPORT_URLS__[report_type], data)
try:
r = requests.post(__REPORT_URLS__[report_type], data=data)
except:
if DEBUG:
traceback.print_exc()
try:
r = requests.post(
__REPORT_URLS__[report_type],
data={
"traceback":
str(data) + "\n-----Except during request-----\n" +
traceback.format_exc()
},
verify=False,
)
except:
raise
else:
dbgprint(r.text, r.headers, r.request.body)
def onekey_report(report_type=REPORT_SUCCESS, traceback_str=None, msg=None):
"""
发送报告到服务器
尽可能保证在致命错误发生时也能传出错误报告
"""
try:
import json
except:
import simplejson as json
try:
import distro
except:
dist = "Unable to load package distro\n" + traceback.format_exc()
else:
try:
dist = json.dumps(distro.info(best=True))
except:
dist = "Unable to read dist\n" + traceback.format_exc()
try:
stdout_str = stdout_logger_last.get_value() + stdout_logger.get_value()
except:
stdout_str = "Unable to read stdout.\n" + traceback.format_exc()
try:
stderr_str = stderr_logger.get_value()
except:
stderr_str = "Unable to read stderr.\n" + traceback.format_exc()
data = {
"linux_dist": dist,
"stdout": stdout_str,
"stderr": stderr_str,
}
try:
if mirrors_to_deploy:
data['installing_mirror'] = ','.join(mirrors_to_deploy)
except:
data['installing_mirror'] = "Unable to get installing_mirror"
if traceback_str is not None and isinstance(traceback_str, str):
data['traceback'] = traceback_str
try:
import platform
except:
pass
else:
try:
data['uname'] = json.dumps(dict(zip(
platform.uname()._fields,
platform.uname()
)))
except:
pass
try:
data['python_version'] = sys.version
except:
pass
try:
if msg is not None:
data['extra_msg'] = str(msg)
except:
pass
try:
if isinstance(email, str) and email:
data["email"] = email
except:
data["email"] = "*****@*****.**"
try:
meminfo = open('/proc/meminfo').read()
matched = re.search(r'^MemTotal:\s+(\d+)', meminfo)
if matched:
mem_total_KB = int(matched.groups()[0])
data['memory'] = mem_total_KB
except:
data['memory'] = 1
dbgprint(__REPORT_URLS__[report_type], data)
# 将发送到远程服务器的报告写入到本地
filename = datetime.now().strftime('%Y%m%d_%H%M%S.log')
jsObj = json.dumps(data)
f1 = open(filename,'w',encoding='utf-8')
f1.write(jsObj)
f1.close()
def get_info():
data = {'error': False, 'rippled': [], 'system': []}
jstr = fdata()
if jstr == False:
data['error'] = True
else:
jstr = json.loads(jstr)
data['error'] = False
#Rippled info
data['rippled'].append({'domain_stated': domain})
server_state = jstr['result']['info']['server_state']
data['rippled'].append({'state': server_state})
data['rippled'].append(
{'version': jstr['result']['info']['build_version']})
data['rippled'].append({'uptime': jstr['result']['info']['uptime']})
data['rippled'].append(
{'complete_ledgers': jstr['result']['info']['complete_ledgers']})
data['rippled'].append({'peers': jstr['result']['info']['peers']})
data['rippled'].append(
{'io_latency_ms': jstr['result']['info']['io_latency_ms']})
data['rippled'].append(
{'validation_quorum': jstr['result']['info']['validation_quorum']})
data['rippled'].append({
'validator_list_expiration':
jstr['result']['info']['validator_list']['expiration'].split(" ")
[0]
})
data['rippled'].append(
{'pubkey_validator': jstr['result']['info']['pubkey_validator']})
#These two entries may not always be present
try:
data['rippled'].append({
'validated_ledger_hash':
jstr['result']['info']["validated_ledger"]["hash"]
})
except:
data['rippled'].append({'validated_ledger_hash': "Not Found"})
try:
data['rippled'].append({
'validated_ledger_age':
jstr['result']['info']["validated_ledger"]["age"]
})
except:
data['rippled'].append({'validated_ledger_age': "Unknown"})
numproposers = jstr['result']['info']["last_close"]["proposers"]
data['rippled'].append({'proposers': numproposers})
if numproposers == 0 or server_state != 'proposing':
data['error'] = True
#System information
data['system'].append({
'mem_free_gb':
round(psutil.virtual_memory().available / 1024 / 1024 / 1024, 2)
})
s_uptime = psutil.boot_time()
ts = datetime.datetime.now().timestamp()
data['system'].append({'uptime': int(ts - s_uptime)})
data['system'].append({'timestamp_epoch': round(time.time(), 0)})
data['system'].append({
'swap_used_gb':
round(psutil.swap_memory().used / 1024 / 1024 / 1024, 2)
})
data['system'].append({'iowait%': psutil.cpu_times_percent().iowait})
data['system'].append({'stats_interval': interval})
osinfo = distro.info()
data['system'].append({'os_info': osinfo})
return data
