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