def status (self): # pylint: disable=unused-argument rc = { "hostname": socket.gethostname (), "cpu": { "count": psutil.cpu_count (), "times": psutil.cpu_times (), "percent": psutil.cpu_percent (percpu = True), }, "memory": { "virtual": psutil.virtual_memory (), "swap": psutil.swap_memory (), }, "net": psutil.net_io_counters (), "uptime": { "ut": psutil.boot_time (), "since": logtool.time_str (psutil.boot_time (), slug = True), }, "disk": {}, } for part in psutil.disk_partitions (): rc["disk"]["mounts"] = { part.mountpoint: psutil.disk_usage (part.mountpoint), } for disk, io in psutil.disk_io_counters (perdisk = True).items (): rc["disk"]["io"] = { disk: io } return rc
def get_initial_since_values(since): last_snapshot_time = ( psutil.boot_time() if hasattr( psutil, 'boot_time') else psutil.BOOT_TIME) if since == 'EPOCH': since_timestamp = 0 elif since == 'BOOT': since_timestamp = ( psutil.boot_time() if hasattr( psutil, 'boot_time') else psutil.BOOT_TIME) elif since == 'LASTSNAPSHOT': # subsequent snapshots will update this value since_timestamp = last_snapshot_time else: # check if the value of since is a UTC timestamp (integer) try: since_timestamp = int(since) except: logger.error( 'Invalid value since={0}, defaulting to BOOT'.format(since)) # subsequent snapshots will update this value since_timestamp = last_snapshot_time return since_timestamp, last_snapshot_time
def update(self): """Get the latest system information.""" import psutil if self.type == 'disk_use_percent': self._state = psutil.disk_usage(self.argument).percent elif self.type == 'disk_use': self._state = round(psutil.disk_usage(self.argument).used / 1024**3, 1) elif self.type == 'disk_free': self._state = round(psutil.disk_usage(self.argument).free / 1024**3, 1) elif self.type == 'memory_use_percent': self._state = psutil.virtual_memory().percent elif self.type == 'memory_use': self._state = round((psutil.virtual_memory().total - psutil.virtual_memory().available) / 1024**2, 1) elif self.type == 'memory_free': self._state = round(psutil.virtual_memory().available / 1024**2, 1) elif self.type == 'swap_use_percent': self._state = psutil.swap_memory().percent elif self.type == 'swap_use': self._state = round(psutil.swap_memory().used / 1024**3, 1) elif self.type == 'swap_free': self._state = round(psutil.swap_memory().free / 1024**3, 1) elif self.type == 'processor_use': self._state = round(psutil.cpu_percent(interval=None)) elif self.type == 'process': if any(self.argument in l.name() for l in psutil.process_iter()): self._state = STATE_ON else: self._state = STATE_OFF elif self.type == 'network_out' or self.type == 'network_in': counters = psutil.net_io_counters(pernic=True) if self.argument in counters: counter = counters[self.argument][IO_COUNTER[self.type]] self._state = round(counter / 1024**2, 1) else: self._state = STATE_UNKNOWN elif self.type == 'packets_out' or self.type == 'packets_in': counters = psutil.net_io_counters(pernic=True) if self.argument in counters: self._state = counters[self.argument][IO_COUNTER[self.type]] else: self._state = STATE_UNKNOWN elif self.type == 'ipv4_address' or self.type == 'ipv6_address': addresses = psutil.net_if_addrs() if self.argument in addresses: self._state = addresses[self.argument][IF_ADDRS[self.type]][1] else: self._state = STATE_UNKNOWN elif self.type == 'last_boot': self._state = dt_util.as_local( dt_util.utc_from_timestamp(psutil.boot_time()) ).date().isoformat() elif self.type == 'since_last_boot': self._state = dt_util.utcnow() - dt_util.utc_from_timestamp( psutil.boot_time())
def test_boot_time_fluctuation(self): # https://github.com/giampaolo/psutil/issues/1007 with mock.patch('psutil._pswindows.cext.boot_time', return_value=5): self.assertEqual(psutil.boot_time(), 5) with mock.patch('psutil._pswindows.cext.boot_time', return_value=4): self.assertEqual(psutil.boot_time(), 5) with mock.patch('psutil._pswindows.cext.boot_time', return_value=6): self.assertEqual(psutil.boot_time(), 5) with mock.patch('psutil._pswindows.cext.boot_time', return_value=333): self.assertEqual(psutil.boot_time(), 333)
def update(self): """ Get the latest system informations. """ import psutil if self.type == 'disk_use_percent': self._state = psutil.disk_usage(self.argument).percent elif self.type == 'disk_use': self._state = round(psutil.disk_usage(self.argument).used / 1024**3, 1) elif self.type == 'disk_free': self._state = round(psutil.disk_usage(self.argument).free / 1024**3, 1) elif self.type == 'memory_use_percent': self._state = psutil.virtual_memory().percent elif self.type == 'memory_use': self._state = round((psutil.virtual_memory().total - psutil.virtual_memory().available) / 1024**2, 1) elif self.type == 'memory_free': self._state = round(psutil.virtual_memory().available / 1024**2, 1) elif self.type == 'swap_use_percent': self._state = psutil.swap_memory().percent elif self.type == 'swap_use': self._state = round(psutil.swap_memory().used / 1024**3, 1) elif self.type == 'swap_free': self._state = round(psutil.swap_memory().free / 1024**3, 1) elif self.type == 'processor_use': self._state = round(psutil.cpu_percent(interval=None)) elif self.type == 'process': if any(self.argument in l.name() for l in psutil.process_iter()): self._state = STATE_ON else: self._state = STATE_OFF elif self.type == 'network_out': self._state = round(psutil.net_io_counters(pernic=True) [self.argument][0] / 1024**2, 1) elif self.type == 'network_in': self._state = round(psutil.net_io_counters(pernic=True) [self.argument][1] / 1024**2, 1) elif self.type == 'packets_out': self._state = psutil.net_io_counters(pernic=True)[self.argument][2] elif self.type == 'packets_in': self._state = psutil.net_io_counters(pernic=True)[self.argument][3] elif self.type == 'ipv4_address': self._state = psutil.net_if_addrs()[self.argument][0][1] elif self.type == 'ipv6_address': self._state = psutil.net_if_addrs()[self.argument][1][1] elif self.type == 'last_boot': self._state = dt_util.datetime_to_date_str( dt_util.as_local( dt_util.utc_from_timestamp(psutil.boot_time()))) elif self.type == 'since_last_boot': self._state = dt_util.utcnow() - dt_util.utc_from_timestamp( psutil.boot_time())
def _use_time_info(self): self._use_time["count_user"] = len(psutil.users()) now = datetime.datetime.now() boot_time = datetime.datetime.fromtimestamp(psutil.boot_time()) live_time = now - boot_time self._use_time["live_time"] = str(live_time.days) + '天' + \ str(live_time.seconds//3600) + '小时' + str((live_time.seconds//60)%60) + '秒' self._use_time["start_time"] = str( datetime.datetime.fromtimestamp( psutil.boot_time()).strftime( "%Y-%m-%d %H:%M:%S")) return self._use_time
def _get_sysinfo(self): """ Gather system info into a dictionary for sendEvent. This is information that rarely if ever changes. Well, yeah, this changed with the uptime stats. """ sysinfo = { 'hostname': os.uname()[1], 'cpus': ps.cpu_count(logical=False), 'cpu_cores': ps.cpu_count(), 'architecture': pf.architecture()[0], 'bin_format': pf.architecture()[1], 'up_since': datetime.datetime.fromtimestamp(ps.boot_time()).strftime("%Y-%m-%d %H:%M:%S"), 'uptime': int((datetime.datetime.now() - datetime.datetime.fromtimestamp(ps.boot_time())).total_seconds() / 60), } return sysinfo
def index(): load_avg = os.getloadavg() uptime = datetime.now() - datetime.fromtimestamp(psutil.boot_time()) disks = get_disks() users = get_users() netifs = build_network_interfaces() netifs.sort(key=lambda x: x.get('bytes_sent'), reverse=True) data = { 'os': platform.platform().decode('utf-8'), 'hostname': socket.gethostname().decode('utf-8'), 'uptime': str(uptime).split('.')[0], 'load_avg': load_avg, 'cpus': psutil.cpu_count(), 'vmem': psutil.virtual_memory(), 'swap': psutil.swap_memory(), 'disks': disks, 'cpu_percent': psutil.cpu_times_percent(0), 'users': users, 'net_interfaces': netifs, 'page': 'overview', 'is_xhr': request.is_xhr } return render_template('index.html', **data)
def add_DFXML_execution_environment(self,e): ee = ET.SubElement(e, 'execution_environment') uname = os.uname() uname_fields = ['os_sysname','host','os_release','os_version','arch'] for i in range(len(uname_fields)): ET.SubElement(ee, uname_fields[i]).text = uname[i] ET.SubElement(ee, 'command_line').text = " ".join([sys.executable] + sys.argv) ET.SubElement(ee, 'uid').text = str(os.getuid()) ET.SubElement(ee, 'username').text = pwd.getpwuid(os.getuid())[0] ET.SubElement(ee, 'cwd').text = os.getcwd() ET.SubElement(ee, 'start_time').text = datetime.datetime.now().isoformat() try: import psutil ET.SubElement(ee, 'boot_time').text = datetime.datetime.fromtimestamp(psutil.boot_time()).isoformat() except ImportError: pass env = ET.SubElement(ee, 'vars') count = 0 # output the environment. Unfortunately, quoteattr doesn'doesn't quote enough, so we need to have it quote # every possible invalid value that might be in the environment entities = {} for ch in range(0,32): entities[chr(ch)] = "\\%03o" % ch for ch in range(127,256): entities[chr(ch)] = "\\%03o" % ch from xml.sax.saxutils import quoteattr,escape for (name,value) in os.environ.items(): ET.SubElement(env, 'var', {'name':escape(name,entities), 'value':escape(value,entities)})
def do_GET(self): self.send_response(200) self.end_headers() res = "" boot_time = datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S") cpu_util = psutil.cpu_percent(interval=1, percpu=True) mem = psutil.virtual_memory() res="<table width='40%' border=2><tr bgcolor='#CEF6F5'><td>BOOT TIME</td><td>" + boot_time + "</td></tr>" res += "<tr><td>CPU UTILIZATION</td><td><table border=0 width='100%'>" i = 1 for cpu in cpu_util: res += "<tr><td>CPU {}</td><td bgcolor=".format(i) if (cpu < 50) : res += "'#008000'> {}%</td></tr>".format(cpu) else: res += "'#ff0000'> {}%</td></tr>".format(cpu) i = i+1 res += "</table></td></tr><tr bgcolor='#CEF6F5'><td>AVAILABLE MEMORY</td><td>" + str(mem.available) + "</td></tr>" res += "<tr><td>USED MEMORY</td><td>" + str(mem.used) + "</td></tr>" res += "<tr ><td bgcolor='#CEF6F5'>USED PERCENTAGE</td><td bgcolor=" if ( mem.percent < 50) : res += "'#008000'>" + str(mem.percent) + "</td></tr></table></div>" else: res += "'#ff0000'>" + str(mem.percent) + "</td></tr></table></div>" self.wfile.write(bytes(res, 'utf-8')) return
def on_message(client, userdata, msg): command=json.loads(msg.payload.decode('ascii')) #Convert to ascii then json print("Received message : "+command+" on topic : "+str(msg.topic)) #Check command and respond accordingly if command == 'ifconfig': bashCommand = "ifconfig" process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE) output = process.communicate()[0] message = "{\"Message\":\""+str(output)+"\"}" client.publish(topic_result, message) print("Sent ls") elif command == 'ls': bashCommand = "ls" process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE) output = process.communicate()[0] message = "{\"Message\":\""+str(output)+"\"}" client.publish(topic_result, message) print("Sent cd") elif command == 'bootTime': date = datetime.fromtimestamp(psutil.boot_time()).strftime('%Y-%m-%d %H:%M') message = json.dumps({"Message":"Booted at "+date}) client.publish(topic_result, message) elif command == 'exit': sys.exit(1) else: message = "{\"Message\":\"I received an unknown command\"}" client.publish(topic_result, message) print("Sent unknown")
def my_app(environ, start_response): status = '200 OK' headers = [('Content-type', 'html; charset=utf-8')] start_response(status, headers) boot_time = datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S") cpu_util = psutil.cpu_percent(interval=1, percpu=True) message = "<h1>My System information</h1>" message += "<table>" message += "<tr><th bgcolor = 'lightblue' > BOOT TIME </th><th bgcolor='lightgreen' >" \ + str(boot_time) + "</th></tr>" message += "<tr><th bgcolor = 'lightblue' > CPU UTILIZATION </th></tr>" i = 1 for cpu in cpu_util: message += "<tr><th bgcolor = 'lightblue' > CPU " + str(i) + "</th><th bgcolor='lightpink'>" \ + str(cpu) + "</th><tr>" i += 1 mem = psutil.virtual_memory() THRESHOLD = 100 * 1024 * 1024 # 100MB message += "<tr><th bgcolor = 'lightblue' > AVAILABLE MEMORY </th><th bgcolor='lightgreen'>" \ + str(mem.available) + "</th></tr>" message += "<tr><th bgcolor = 'lightblue' > USED MEMORY </th><th bgcolor = 'lightgreen' >" \ + str(mem.used) + "</th></tr>" message += "<tr><th bgcolor = 'lightblue' > USED PERCENTAGE </th><th bgcolor= 'lightgreen' >" \ + str(mem.percent) + "</th></tr>" message += "</table>" return [bytes(message, 'utf-8')]
def _get_system_provenance(): """ return JSON string containing provenance for all things that are fixed during the runtime""" bits, linkage = platform.architecture() return dict( ctapipe_version=ctapipe.__version__, ctapipe_resources_version=ctapipe_resources.__version__, ctapipe_svc_path=os.getenv("CTAPIPE_SVC_PATH"), executable=sys.executable, platform=dict( architecture_bits=bits, architecture_linkage=linkage, machine=platform.machine(), processor=platform.processor(), node=platform.node(), version=platform.version(), system=platform.system(), release=platform.release(), libcver=platform.libc_ver(), num_cpus=psutil.cpu_count(), boot_time=Time(psutil.boot_time(), format='unix').isot, ), python=dict( version_string=sys.version, version=platform.python_version_tuple(), compiler=platform.python_compiler(), implementation=platform.python_implementation(), ), arguments=sys.argv, start_time_utc=Time.now().isot, )
def sysinfo(): boot_start = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(psutil.boot_time())) time.sleep(0.5) cpu_usage = psutil.cpu_percent() ram = int(psutil.virtual_memory().total / (1027 * 1024)) ram_percent = psutil.virtual_memory().percent swap = int(psutil.swap_memory().total / (1027 * 1024)) swap_percent = psutil.swap_memory().percent net_sent = psutil.net_io_counters().bytes_sent net_recv = psutil.net_io_counters().bytes_recv net_spkg = psutil.net_io_counters().packets_sent net_rpkg = psutil.net_io_counters().packets_recv sysinfo_string = "" if __name__ == "__main__": bfh = r'%' print(" \033[1;32m开机时间:%s\033[1;m" % boot_start) print(" \033[1;32m当前CPU使用率:%s%s\033[1;m" % (cpu_usage, bfh)) print(" \033[1;32m物理内存:%dM\t使用率:%s%s\033[1;m" % (ram, ram_percent, bfh)) print(" \033[1;32mSwap内存:%dM\t使用率:%s%s\033[1;m" % (swap, swap_percent, bfh)) print(" \033[1;32m发送:%d Byte\t发送包数:%d个\033[1;m" % (net_sent, net_spkg)) print(" \033[1;32m接收:%d Byte\t接收包数:%d个\033[1;m" % (net_recv, net_rpkg)) for i in psutil.disk_partitions(): print(" \033[1;32m盘符: %s 挂载点: %s 使用率: %s%s\033[1;m" % (i[0], i[1], psutil.disk_usage(i[1])[3], bfh)) sysinfo_string = '开机时间: ' + boot_start + '\n' sysinfo_string += '当前CPU使用率: ' + str(cpu_usage) + '%\n' sysinfo_string += '物理内存: ' + str(ram) + 'M\t使用率: ' + str(ram_percent) + '%\t' sysinfo_string += 'Swap内存: ' + str(swap) + 'M\t使用率: ' + str(swap_percent) + '%\n' return sysinfo_string else: file = open("sysinfo.log", "a") file.write("CPU:%s \tRAM:%s\tnet_recv:%d\tNet_sent:%d\r\n" % (cpu_usage, ram_percent, net_recv, net_sent)) file.flush() file.close()
def run_info(): return dict( cpu_usage = psutil.cpu_percent(), boot_time = psutil.boot_time(), swap_usage = psutil.swap_memory().used, mem_usage = psutil.virtual_memory().used )
def _boot_time_linux(): try: return psutil.boot_time() except: pass # Old psutil versions try: return psutil.BOOT_TIME except: pass # Get info from proc try: f = open('/proc/stat', 'r') for line in f: if line.startswith('btime'): f.close() return float(line.strip().split()[1]) f.close() return 0 except: pass raise Exception("Cannot get uptime")
def _health_loop(self): topic='{0}/linux_state'.format(self.id) msg=linux_state() msg.header=header() msg.header.seq=0 while True: msg.header.seq+=1 msg.header.time=time.time() msg.temp=get_temp() cpu_perc=[0,0,0,0] cpu_percent=psutil.cpu_percent(percpu=True) for i in range(len(cpu_percent)): cpu_perc[i] = cpu_percent[i] msg.cpu_use=cpu_perc msg.load_average=os.getloadavg() msg.uptime=time.time()-psutil.boot_time() msg.memory_use=psutil.virtual_memory().used/(1024*1024) try: self.lcm.publish(topic, msg.encode()) except IOError, e: print e time.sleep(.5)
def my_app(environ, start_response): status = '200 OK' headers = [('Content-type', 'html; charset=utf-8')] start_response(status, headers) boot_time = datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S") cpu_utilization = psutil.cpu_percent(interval=1, percpu=True) message = "<h1>My System information</h1>" message += "<table>" message += "<tr><th bgcolor = 'lightblue' > Boot time </th><th bgcolor='lightgreen' >" \ + str(boot_time) + "</th></tr>" message += "<tr><th bgcolor = 'lightblue' > CPU Utilization </th></tr>" i = 1 for cpu in cpu_utilization: message += "<tr><th bgcolor = 'lightblue' > CPU " + str(i) + "</th><th bgcolor='lightpink'>" \ + str(cpu) + "</th><tr>" i += 1 mem = psutil.virtual_memory() Threshold = 100 * 1024 * 1024 # 100MB message += "<tr><th bgcolor = 'lightblue' > Available memory </th><th bgcolor='lightgreen'>" \ + str(mem.available) + "</th></tr>" message += "<tr><th bgcolor = 'lightblue' > Used memory </th><th bgcolor = 'lightgreen' >" \ + str(mem.used) + "</th></tr>" message += "<tr><th bgcolor = 'lightblue' > Used percentage </th><th bgcolor= 'lightgreen' >" \ + str(mem.percent) + "</th></tr>" message += "</table>" return [bytes(message, 'utf-8')]
def serialize(self): memory = psutil.virtual_memory() if hasattr(psutil, 'boot_time'): uptime = str(datetime.now() - datetime.fromtimestamp(psutil.boot_time())) else: uptime = str(datetime.now() - datetime.fromtimestamp(psutil.BOOT_TIME)) try: dist = platform.linux_distribution() except: dist = platform.dist() return { 'hostname': socket.gethostname(), 'dist': dist, 'load': [str(val) for val in os.getloadavg()], 'uptime': uptime, 'users': len(getUsersLdap()), 'memory': { 'total': size_format(memory.total), 'used': size_format(memory.used), 'available': size_format(memory.available), 'free': size_format(memory.free), 'percent': memory.percent } }
def Run(self, arg): """Returns the client stats.""" if arg is None: arg = rdf_client.GetClientStatsRequest() proc = psutil.Process(os.getpid()) meminfo = proc.memory_info() response = rdf_client.ClientStats( RSS_size=meminfo.rss, VMS_size=meminfo.vms, memory_percent=proc.memory_percent(), bytes_received=stats.STATS.GetMetricValue("grr_client_received_bytes"), bytes_sent=stats.STATS.GetMetricValue("grr_client_sent_bytes"), create_time=long(proc.create_time() * 1e6), boot_time=long(psutil.boot_time() * 1e6)) samples = self.grr_worker.stats_collector.cpu_samples for (timestamp, user, system, percent) in samples: if arg.start_time < timestamp < arg.end_time: sample = rdf_client.CpuSample(timestamp=timestamp, user_cpu_time=user, system_cpu_time=system, cpu_percent=percent) response.cpu_samples.Append(sample) samples = self.grr_worker.stats_collector.io_samples for (timestamp, read_bytes, write_bytes) in samples: if arg.start_time < timestamp < arg.end_time: sample = rdf_client.IOSample(timestamp=timestamp, read_bytes=read_bytes, write_bytes=write_bytes) response.io_samples.Append(sample) self.Send(response)
def uptime(self): # now = time.localtime() now = time.time() # print(now) uptime = now - psutil.boot_time() # print(uptime) return int(uptime / 86400)
def getUptime(): uptime_file = "/proc/uptime" if os.path.exists(uptime_file): with open(uptime_file, 'r') as f: return f.read().split(' ')[0].strip("\n") else: return time.time() - psutil.boot_time()
def collect(self): meta = super(SystemMetaCollector, self).collect() meta.update({ 'boot': int(psutil.boot_time()) * 1000, 'hostname': self.hostname, 'uname': None, 'network': { 'interfaces': [], 'default': None }, 'ec2': None, }) for method in ( self.uname, self.network, self.ec2 ): try: method(meta) except Exception as e: exception_name = e.__class__.__name__ context.log.error('failed to collect meta %s due to %s' % (method.__name__, exception_name)) context.log.debug('additional info:', exc_info=True) self.object.metad.meta(meta)
def get_properties(group): mem = psutil.virtual_memory() disk = psutil.disk_usage('/') properties = {} if group is None or group == 'fresh': if platform.machine().startswith('arm') and platform.system() == 'Linux': # raspberry pi properties["cpuTemp"] = get_rpi_cpu_temperature() properties["ramAvailable"] = int(mem.available / (1024 * 1024)) properties["usedDiskSpaceRoot"] = int(disk.used / (1024 * 1024)) properties["bootTime"] = datetime.datetime.fromtimestamp(psutil.boot_time()).strftime(Publisher.DATE_FORMAT) properties["cpuLoad"] = psutil.cpu_percent(interval=3) if group is None or group == 'seldom': if platform.system() == 'Darwin': # mac properties["release"] = platform.mac_ver()[0] elif platform.machine().startswith('arm') and platform.system() == 'Linux': # raspberry pi properties["distribution"] = "{} {}".format(platform.dist()[0], platform.dist()[1]) for i in NET_INTERFACES: properties["{}IpAddress".format(i)] = get_ip(i) properties["totalDiskSpaceRoot"] = int(disk.total / (1024 * 1024)) properties["hostname"] = platform.node() properties["machine"] = platform.machine() properties["system"] = platform.system() properties["cpuProcessorCount"] = psutil.cpu_count() properties["ramTotal"] = int(mem.total / (1024 * 1024)) return properties
def boot_time(time_format=None): ''' Return the boot time in number of seconds since the epoch began. CLI Example: time_format Optionally specify a `strftime`_ format string. Use ``time_format='%c'`` to get a nicely-formatted locale specific date and time (i.e. ``Fri May 2 19:08:32 2014``). .. _strftime: https://docs.python.org/2/library/datetime.html#strftime-strptime-behavior .. versionadded:: 2014.1.4 .. code-block:: bash salt '*' ps.boot_time ''' try: b_time = int(psutil.boot_time()) except AttributeError: # get_boot_time() has been removed in newer psutil versions, and has # been replaced by boot_time() which provides the same information. b_time = int(psutil.get_boot_time()) if time_format: # Load epoch timestamp as a datetime.datetime object b_time = datetime.datetime.fromtimestamp(b_time) try: return b_time.strftime(time_format) except TypeError as exc: raise SaltInvocationError('Invalid format string: {0}'.format(exc)) return b_time
def server_health_app(environ, start_response): boot_time = datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S") cpu_util = psutil.cpu_percent(interval=1, percpu=True) mem = psutil.virtual_memory() message = "" status = '200 OK' headers = [('Content-type', 'html; charset=utf-8')] start_response(status, headers) message += "<h1>Server Health</h1>" message += "<table border =\"1\" allign=\"center\">" message += "<tr>"#row 1 message += "<td><b>BOOT TIME:</td>" message += "<td>{}".format(boot_time)+"</td>" message += "</tr>" message += "<tr>"#row 2 message += "<td><b>CPU UTILIZATION:</td>" message += "<td>" i=1 for cpu in cpu_util: if cpu > 10: message += "<font color = \"red\">" else: message += "<font color = \"black\">" message += "CPU {} : {}%<br>".format(i, cpu) i+=1 message += "</td>" message += "<tr><td><b>AVAILABLIE MEMORY:</td>" #row 3 message += "<td>{}</tr>".format(mem.available) message += "<tr><td><b>USED MEMORY:</td>"#row 4 message += "<td>{}</td></tr>".format(mem.used) message += "<tr><td><b>USED PERCENTAGE:</td>"#row 5 message += "<td>{}</td></tr>".format(mem.percent) return[bytes(message,'utf-8')]
def Sysinfo(): Hostname = platform.node() Sys_version = platform.platform() Boot_Start = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(psutil.boot_time())) time.sleep(0.5) Cpu_usage = psutil.cpu_percent() RAM = int(psutil.virtual_memory().total/(1027*1024)) RAM_percent = psutil.virtual_memory().percent Swap = int(psutil.swap_memory().total/(1027*1024)) Swap_percent = psutil.swap_memory().percent Net_sent = psutil.net_io_counters().bytes_sent Net_recv = psutil.net_io_counters().bytes_recv Net_spkg = psutil.net_io_counters().packets_sent Net_rpkg = psutil.net_io_counters().packets_recv BFH = r'%' print " \033[1;32m主机名: %s\033[1;m" % Hostname print " \033[1;32m系统版本: %s\033[1;m" % Sys_version print " \033[1;32m开机时间:%s\033[1;m" % Boot_Start print " \033[1;32m当前CPU使用率:%s%s\033[1;m" % (Cpu_usage,BFH) print " \033[1;32m物理内存:%dM\t使用率:%s%s\033[1;m" % (RAM,RAM_percent,BFH) print " \033[1;32mSwap内存:%dM\t使用率:%s%s\033[1;m" % (Swap,Swap_percent,BFH) print " \033[1;32m发送:%d Byte\t发送包数:%d个\033[1;m" % (Net_sent,Net_spkg) print " \033[1;32m接收:%d Byte\t接收包数:%d个\033[1;m" % (Net_recv,Net_rpkg) for i in psutil.disk_partitions(): print " \033[1;32m盘符: %s 挂载点: %s 使用率: %s%s\033[1;m" % (i[0],i[1],psutil.disk_usage(i[1])[3],BFH) for key in psutil.net_if_addrs().keys(): print " \033[1;32m网卡: %s IP: %s\033[1;m" % (key,psutil.net_if_addrs()[key][0][1])
def healthcheck(): import psutil import humanfriendly now = time.time() pid = os.getgid() ppid = os.getppid() current_process = psutil.Process(pid=ppid) # how about launching under gunicorn? process_uptime = current_process.create_time() process_uptime_delta = now - process_uptime process_uptime_human = humanfriendly.format_timespan(process_uptime_delta) system_uptime = psutil.boot_time() system_uptime_delta = now - system_uptime system_uptime_human = humanfriendly.format_timespan(system_uptime_delta) free_memory = psutil.disk_usage('/').free free_memory_human = humanfriendly.format_size(free_memory) return { 'status': 'Operational', 'free_disk_space': free_memory_human, 'system_uptime': system_uptime_human, 'process_uptime': process_uptime_human, }
def Run(self, arg): """Returns the client stats.""" if arg is None: arg = rdf_client_action.GetClientStatsRequest() proc = psutil.Process(os.getpid()) meminfo = proc.memory_info() boot_time = rdfvalue.RDFDatetime.FromSecondsSinceEpoch(psutil.boot_time()) create_time = rdfvalue.RDFDatetime.FromSecondsSinceEpoch(proc.create_time()) stats_collector = stats_collector_instance.Get() response = rdf_client_stats.ClientStats( RSS_size=meminfo.rss, VMS_size=meminfo.vms, memory_percent=proc.memory_percent(), bytes_received=stats_collector.GetMetricValue( "grr_client_received_bytes"), bytes_sent=stats_collector.GetMetricValue("grr_client_sent_bytes"), create_time=create_time, boot_time=boot_time) response.cpu_samples = self.grr_worker.stats_collector.CpuSamplesBetween( start_time=arg.start_time, end_time=arg.end_time) response.io_samples = self.grr_worker.stats_collector.IOSamplesBetween( start_time=arg.start_time, end_time=arg.end_time) self.Send(response)
def _add_sys_meta(self): try: self.element.add_attribute('platform', platform.system()) self.element.add_attribute('agent', self.version) if psutil: self.element.add_attribute('cpus', psutil.cpu_count()) mem = psutil.virtual_memory() self.element.add_attribute( 'ram', get_human_readable_size(mem.total)) self.element.add_attribute('ram bytes', mem.total) self.element.add_attribute( 'boottime', str(datetime.datetime.fromtimestamp(psutil.boot_time()))) if platform.system().startswith('Linux'): if check_lsb() is None: supported_dists = platform._supported_dists + ('system',) dist = platform.linux_distribution( supported_dists=supported_dists) else: dist = check_lsb() self.element.add_attribute('distribution_name', str(dist[0])) self.element.add_attribute( 'distribution_version', str(dist[1])) if dist[2] != '': self.element.add_attribute('distribution_id', str(dist[2])) except Exception as e: logging.debug(e) pass
def get_bootime_timestamp(): """Retourne le Timestamp du bootime""" return psutil.boot_time()
def risk(): risk_score = 0 # Check uptime uptime_sec = time.time() - psutil.boot_time() uptime_minute = uptime_sec * 60 uptime_hour = uptime_minute * 60 # Tally risk score if uptime_hour < 1: risk_score += 5 # Clock ran_int = random.randint(1,21)*5 time.sleep(ran_int) # Disk Size # with os.statvfs, we need to multiply block sizes by block counts to get bytes stats = os.statvfs(path) total = stats.f_frsize * stats.f_blocks free = stats.f_frsize * stats.f_bavail total_mb = total * 100 # Calculates from bytes to Mb total_free = free * 100 disk_usage ={ "total": total, "free" : free, "used" : total - free, } # Tally risk score if total_free < 40: risk_score += 5 # Clock ran_int = random.randint(1,21)*5 time.sleep(ran_int) # Anti VM VMProcessList = ["vmsrvc.exe", "vmware.exe","vbox.exe", "vmvss.exe","vmscsi.exe","vmhgfs.exe","vboxservice.exe", "vmxnet.exe","vmx_svga.exe","vmmemctl.exe", "autoruns.exe","autorunsc.exe","vmusbmouse.exe","vmtools.exe", "regmon.exe","vboxtray.exe", "vmrawdsk.exe","joeboxcontrol.exe", "joeboxserver.exe","vmtoolsd.exe","vmwaretray.exe","vmwareuser.exe", "vmusrvc.exe","xenservice.exe"] # Debug proc check DebugList = ["ollydbg.exe","ProcessHacker.exe", "fiddler.exe", "tcpview.exe","df5serv.exe", "filemon.exe","procmon.exe","regmon.exe", "procexp.exe","idaq.exe","idaq64.exe","ImmunityDebugger.exe","Wireshark.exe", "dumpcap.exe","HookExplorer.exe","ImportREC.exe","PETools.exe","LordPE.exe", "SysInspector.exe","proc_analyzer.exe","sysAnalyzer.exe","sniff_hit.exe","windbg.exe", "prl_cc.exe","prl_tools.exe","xenservice.exe"] DBG_out = [] for proc in psutil.process_iter(): if proc.name() in DebugList: #print(proc) DBG = True try: p = psutil.Process(proc.pid) time.sleep(0.33) p.kill() except Exception as e: #print e DBG_out.append(proc) continue elif proc.name() in VMProcessList: #print(proc) VM = True continue """ If there were DBG procs check to see if we managed to kill them all by counting the number of items in the DBG_out array In case it's empty assume we killed all and switch DBG back to False """ cnt = 0 for i in DBG_out: cnt += 1 if not cnt < 1: DBG = False if DBG and VM == True: risk_score += 15 return risk_score elif DBG == True: risk_score += 12 return risk_score elif VM == True: risk_score += 11 return risk_score else: return risk_score
def test_boot_time(self): # Duplicate of test_system.py. Keep it anyway. self.assertIsInstance(psutil.boot_time(), float)
def get_bootime_delay(): """Retourne le delai du bootime""" return time.time() - psutil.boot_time()
############################ #get disk partitions print("Disk partitions:", psutil.disk_partitions()) #get disk uage print("Disk Usage:", psutil.disk_usage('/')) #get disk IO print("Disk Usage:", psutil.disk_io_counters(perdisk=False)) ############################## # OTHERS ############################# #get users print("Users:", psutil.users()) #Get boot time print("Boot time:", psutil.boot_time()) #Get Pids print("Pids:", psutil.pids()) p = psutil.Process(7152) print("Process details for pid:", p) print("Exe:", p.exe()) print("CWD:", p.cwd()) print("cmdline:", p.cmdline()) print("Parent Process:", p.parent()) print("Parent Process id:", p.ppid()) print("creation time of the Process:", p.create_time()) # there are other features like suspend, terminate ,resume of processes and querying process's memory utilization
println(psutil.cpu_times()) println(psutil.cpu_times().user) mem = psutil.virtual_memory() println(mem) println(mem.total) partitions = psutil.disk_partitions() println(partitions) println(partitions[1]) println(psutil.disk_usage('/')) println(psutil.net_io_counters()) println(psutil.net_io_counters(pernic=True)) println(psutil.users()) println(psutil.boot_time()) ps = psutil.pids() println(ps) p = psutil.Process(1) println(p.name()) println(p.exe()) println(p.status()) println(p.memory_percent()) #https://pypi.python.org/pypi/psutil
def get_boot_time(): boot_time_timestamp = psutil.boot_time() bt = datetime.fromtimestamp(boot_time_timestamp) last_boot = ( f"{bt.month}/{bt.day}/{bt.year} {bt.hour}:{bt.minute}:{bt.second}") return last_boot
def get_uptime(): return int(time.time() - psutil.boot_time())
def test_boot_time(self): s = sysctl('kern.boottime') sys_bt = datetime.datetime.strptime(s, "%a %b %d %H:%M:%S %Y") psutil_bt = datetime.datetime.fromtimestamp(psutil.boot_time()) self.assertEqual(sys_bt, psutil_bt)
def test_boot_time(self): s = sysctl('sysctl kern.boottime') s = s[s.find(" sec = ") + 7:] s = s[:s.find(',')] btime = int(s) self.assertEqual(btime, psutil.boot_time())
def create_suite_execution(self, suite_execution, verbose=True, *args, **kwargs): # type: (dict, bool, list, dict) -> bool """ Uploads log file to logbook site """ se = {} try: se = suite_execution.copy() suite = kwargs.get('suite', None) # type: Suite try: se['hostname'] = get_hostname() se['host_uptime'] = int(psutil.boot_time()) mem = psutil.virtual_memory() se['host_memory_total'] = int(mem.total/1024/1042) se['host_memory_free'] = int(mem.free/1024/1042) except: pass try: se['host_cpu_usage'] = get_cpu_load_avg() se['host_system'] = platform.system() se['host_release'] = platform.release() se['host_version'] = platform.version() se['host_python_version'] = platform.python_version() se['host_user'] = os.getlogin() se['host_cpu_count'] = os.cpu_count() except: pass try: se['product_version'] = suite_execution['prod_v'] del se['prod_v'] except: pass try: project_list_ready = [] project = os.environ.get('GERRIT_PROJECT', '') # type: str if project.strip(): se['GERRIT_PROJECT'] = project.strip() except: pass try: clusters_list_ready = [] clusters = os.environ.get('CLUSTER', '') # type: str if clusters: clusters_list = clusters.split(',') # type: list if clusters_list: for x in clusters_list: if x.strip() not in clusters_list_ready: clusters_list_ready.append(x.strip()) se['clusters'] = clusters_list_ready except: pass try: se['description'] = suite_execution['desc'] del se['desc'] except: pass try: se['components'] = suite_execution['_components'] del se['_components'] except: pass gb = os.environ.get('GERRIT_BRANCH') # type: str mr = os.environ.get('MANIFEST_REVISION') # type: str if gb and len(gb) > 3: se['GERRIT_BRANCH'] = gb elif mr and len(mr) > 3: se['GERRIT_BRANCH'] = mr on_jenkins = False if os.environ.get('BUILD_ID', '') != '': on_jenkins = True se['is_jenkins'] = on_jenkins if on_jenkins: try: gpsn = os.environ.get('GERRIT_PATCHSET_NUMBER', '') # type: str gcn = os.environ.get('GERRIT_CHANGE_NUMBER', '') # type: str gci = os.environ.get('GERRIT_CHANGE_ID', '') # type: str if gcn != '' and int(gcn) > 0 and gci != '' and gpsn != '' and gb != '': se['PRE_COMMIT'] = f'{gb}_{gci}_{gcn}_{gpsn}' # TODO gpsn - not used? except: pass headers = {'Content-Type': 'application/json'} lbk_api = LogbookAPI() try: self.progress += 1 r = lbk_api.urlopen_lbk( # url=self.suite_execution_url, url='upload/create_suite_execution', method='POST', data=se, headers=headers, verbose=False, sleep_on_error=0, timeout=SUITE_CREATE_TIMEOUT ) filters = [] if 'FILTERS' in r: filters = r['FILTERS'] if suite: suite.set_filters(filters) if 'SUITE_EXECUTION_ID' in r: sid = r['SUITE_EXECUTION_ID'] if suite: self._suite_execution_id = suite.set_suite_execution_id(sid) logging.warning(f'LogBook Suite Execution http://{LOGBOOK_DOMAIN}/suites/show/{sid} ' f'for {se["summary"]}. Filters {len(filters)}') except (socket.timeout, Exception) as ex: if hasattr(ex, 'args') and len(ex.args) and 'Name or service not known' in ex.args[0]: return True logging.error(f'[create_suite_execution]: {ex}') finally: self.progress -= 1 return True except Exception as ex: if verbose: logging.error(f'Failed is suiteExecution creation {ex}') logging.exception(ex) logging.debug(f'{se}') return False
def get_bootime_formatted(): """Retourne la date formatté du bootime """ return datetime.datetime.fromtimestamp( psutil.boot_time()).strftime("%a %d %b %Y (S%W) %H:%M:%S")
hm1.MouseRightDown = onMouse_rightdown hm1.MouseRightUp = onMouse_rightup hm1.HookMouse() # 进入循环,如不手动关闭,程序将一直处于监听状态 if __name__ == "__main__": # 打开日志文件 # 电脑开机时间作为文件名 from datetime import datetime dt = datetime.fromtimestamp(psutil.boot_time()) windowsstarttime = dt.strftime("%Y-%m-%d-%H-%M-%S") print windowsstarttime fobj = open("D:\pycharm\pydata\mouse-" + windowsstarttime + ".txt", "a") # fobj.write("时间 位置 操作 进程名hash值 进程名 \n") # 以日期为文件名 # fobj = open("D:\pycharm\pydata\mouse-"+datetime.now().date().strftime('%Y%m%d') + '.txt', 'a') # 新线程执行的代码: print('thread %s is running..感受一下被支配的恐惧!! 哈哈哈哈.....' % threading.current_thread().name) # 创建hook句柄 hm = pyHook.HookManager()
def get_uptime(): '''Get current system uptime''' print(str(timedelta(seconds=round(time.time()-psutil.boot_time(),0)))[:-3])
import psutil import platform from datetime import datetime print("-" * 40, "Sys Info", "-" * 40) uname = platform.uname() print(f"System: {uname.system}") print(f"Node Name: {uname.node}") print(f"Release: {uname.release}") print(f"Version: {uname.version}") print(f"Machine: {uname.machine}") print(f"Processor: {uname.processor}") print("-" * 40, "Boot Time", "-" * 40) boot_time_timestamp = psutil.boot_time() bt = datetime.fromtimestamp(boot_time_timestamp) print( f"Boot Time: {bt.day}.{bt.month}.{bt.year} {bt.hour}:{bt.minute}:{bt.second}" ) print("-" * 40, "CPU Info", "-" * 40) print("Actual Cores:", psutil.cpu_count(logical=False)) print("Logical Cores:", psutil.cpu_count(logical=True)) print(f"Max Frequency: {psutil.cpu_freq().max:.1f}Mhz") print(f"Current Frequency: {psutil.cpu_freq().current:.1f}Mhz") print(f"CPU Usage: {psutil.cpu_percent()}%") print("CPU Usage/Core:") for i, perc in enumerate(psutil.cpu_percent(percpu=True, interval=1)): print(f"Core {i}: {perc}%")
def get_last_boot(): return str(as_local(utc_from_timestamp(psutil.boot_time())).isoformat())
def get_my_booting_time(): return datetime.datetime.fromtimestamp(psutil.boot_time())
('boot_time', ''), ('users', 'name') ] log_data_lists = [] for function in log_values: if function[0] == 'Datetime': log_data_lists.append(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) elif function[0] == 'disk_usage': function_value = "ps." + function[0] + "('/')." + function[1] log_data_lists.append(eval(function_value)) elif function[0] == 'users': function_value = "ps." + function[0] + "()[0]." + function[1] log_data_lists.append(eval(function_value)) elif function[0] == 'boot_time': log_data_lists.append(str(-(datetime.datetime.fromtimestamp(ps.boot_time()) - datetime.datetime.now()))) elif function[0] == 'Process': function_value = "len(ps." + function[0] + "()." + function[1] + "())" log_data_lists.append(eval(function_value)) elif function[0] == 'getloadavg': function_value = "os." + function[0] + "()" for value in range(len(eval(function_value))): log_data_lists.append(eval(function_value)[value]) elif len(function[1]): function_value = "ps." + function[0] + "()." + function[1] log_data_lists.append(eval(function_value)) else: function_value = "ps." + function[0] + "()" log_data_lists.append(eval(function_value)) log_file_key_value = ['DateTime', 'Cpu Count',
def boot_time(): # psutil-2.x.x is not backward compatible to psutil-1.x.x try: return psutil.boot_time() except AttributeError: return psutil.get_boot_time()
def boot_time(): return psutil.boot_time()
def test_boot_time(self): bt = psutil.boot_time() self.assertIsInstance(bt, float) self.assertGreater(bt, 0) self.assertLess(bt, time.time())
def _get_status(self): def meminfo(): return '{:.1f}%'.format(psutil.virtual_memory().percent) def temperature(): if 'temperature_method' in self.config: vars = {'temp': 'err'} try: exec(self.config['temperature_method'], globals(), vars) except Exception as ex: vars['temp'] = 'err: ' + str(ex) return vars['temp'] elif os.path.exists('/sys/class/thermal/thermal_zone0/temp'): with open('/sys/class/thermal/thermal_zone0/temp', 'r') as tmpo: temp = int(tmpo.read()) return '{:.1f}d'.format(temp / 1000) else: return '' def docker_status(container): s = subprocess.check_output([DOCKER_EXEC, 'ps']).decode('utf-8').split() return container in s status = {} status['shortcuts'] = cfg.get('shortcuts', []) status['services'] = {} if self.services: for _ in self.services: if '@' not in _['name']: status['services'][_['name']] = { 'status': False, 'dispname': _.get('dispname', _['name']), 'name': _['name'], 'actions': _.get('actions', []) } elif 'container' in _: status['services'][_['name']] = { 'status': docker_status(_['container']), 'dispname': _.get('dispname', _['container']), 'name': _['name'], 'actions': _.get('actions', []) } for _ in psutil.process_iter(): short_key = _.name() + ':' if os.name == 'nt': long_key = short_key else: long_key = short_key + _.username() s = None if short_key in self.serv_procs: s = self.serv_procs[short_key] if long_key in self.serv_procs: s = self.serv_procs[long_key] if s is None: continue if s.get('uname') and s['uname'] != _.username(): continue if s.get('args') and s['args'] not in _.cmdline(): continue status['services'][s['name']]['status'] = True if self.nodes: status['nodes'] = {} for m, n in self.nodes.items(): status['nodes'][m] = { 'type': type(n).__name__, 'dispname': n.dispname, 'name': m } t = time.time() - psutil.boot_time() status[ 'uptime'] = '{}:{:02d}:{:02d}:{:02d} {:.01f}% {} Mem: {}'.format( int(t / 86400), int(t / 3600) % 24, int(t % 3600 / 60), int(t % 60), psutil.cpu_percent(interval=None), ' '.join(['%.2f' % _ for _ in os.getloadavg()]), meminfo()) status['disks'] = [] for disk in psutil.disk_partitions(): try: usage = psutil.disk_usage(disk.mountpoint) status['disks'].append('{} {:.01f}%'.format( disk.mountpoint, usage.percent)) except PermissionError: pass status['temp'] = temperature() return status
def uptime(self): Uptime = datetime.datetime.fromtimestamp(psutil.boot_time()) Nowtime = datetime.datetime.now() return int(round((Nowtime - Uptime).seconds / 3600))
#cpu逻辑个数 cpunum = psutil.cpu_count() #cpu物理个数 cpuPhysical = psutil.cpu_count(logical=False) print(cpu) #内存信息 mem = psutil.virtual_memory() print(mem) mem.total mem.free mem.percent #磁盘信息 disk = psutil.disk_partitions() #磁盘完整信息 psutil.disk_usage('/') #分区信息 psutil.disk_io_counters() psutil.disk_io_counters(perdisk=True) #单个分区io个数 print(disk) #网络信息 net = psutil.net_io_counters(pernic=True) print(net) #当前用户 user = psutil.users() print(user) #开机时间 boottime = psutil.boot_time() print(boottime)
def test_get_uptime(self): sysinfo = self.service.get_sysinfo() uptime = int(time.time() - psutil.boot_time()) self.assertEqual(sysinfo['uptime'], uptime)
def system_start_time(): import datetime time = datetime.datetime.fromtimestamp(psutil.boot_time()) print(time)
def StatusPage(): f = open("/proc/device-tree/model") piType = f.read() boottime =datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S") Row1 = html.Div( [ dbc.Button( ["Raspberry Pi", dbc.Badge(piType, color="light", className="ml-1")], color="primary",), dbc.Button( ["SW2 Start Time ", dbc.Badge(boottime, color="light", className="ml-1")], color="primary",), dbc.Button( ["Pi Boot Time ", dbc.Badge(boottime, color="light", className="ml-1")], color="primary",), ]) Row2 = dbc.Row( [ daq.Gauge( id = {'type' : 'SPGdynamic', 'GaugeType' :'pi-loading'}, label="Pi CPU Loading", value=0, color={"gradient":True,"ranges":{"green":[0,50],"yellow":[50,85],"red":[85,100]}}, showCurrentValue=True, units="%", size=190, max = 100, min = 0, ), daq.Gauge( id = {'type' : 'SPGdynamic', 'GaugeType' :'pi-memory'}, label="Pi Memory Usage", value=0, color={"gradient":True,"ranges":{"green":[0,50],"yellow":[50,85],"red":[85,100]}}, max=100, size=190, showCurrentValue=True, units="%", ), daq.Gauge( id = {'type' : 'SPGdynamic', 'GaugeType' :'pi-disk'}, label="Pi Disk Free", value=0, showCurrentValue=True, units="%", size=190, color={"gradient":True,"ranges":{"red":[0,30],"yellow":[30,65],"green":[65,100]}}, max = 100, min = 0, ), daq.Gauge( id = {'type' : 'SPGdynamic', 'GaugeType' :'pi-temp'}, label="Pi CPU Temperature(C)", value=0, color={"gradient":True,"ranges":{"green":[0,50],"yellow":[50,85],"red":[85,130]}}, showCurrentValue=True, units="C", size=190, max = 130, min = 0, ), ], no_gutters=True, ) Row3 = html.Div( ) Row4 = html.Div( [ html.Div(id='log') ] ) Row5 = html.Div( [ dbc.Alert("No Alarm", color="primary"), ], style={'margin-top' : "-90px"} ) OutdoorIndicator = returnOutdoorIndicator() IndoorIndicators = returnIndoorIndicators() PiThrottled = returnPiThrottled() Row8 = html.Div( PiThrottled, ) Row6 = html.Div( OutdoorIndicator, ) Row7 = html.Div( IndoorIndicators, ) #layout = dbc.Container([ layout = dbc.Container([ Row1, Row2, Row5, Row3,html.Br(), Row8,html.Br(), Row4,html.Br(), Row6, html.Br(),Row7], className="status-1", ) return layout
def uptime(self, opts=None): """Get system uptime miliseconds""" return (time.time() - psutil.boot_time()) * 1000
def update(self): """Get the latest system information.""" import psutil if self.type == 'disk_use_percent': self._state = psutil.disk_usage(self.argument).percent elif self.type == 'disk_use': self._state = round( psutil.disk_usage(self.argument).used / 1024**3, 1) elif self.type == 'disk_free': self._state = round( psutil.disk_usage(self.argument).free / 1024**3, 1) elif self.type == 'memory_use_percent': self._state = psutil.virtual_memory().percent elif self.type == 'memory_use': virtual_memory = psutil.virtual_memory() self._state = round( (virtual_memory.total - virtual_memory.available) / 1024**2, 1) elif self.type == 'memory_free': self._state = round(psutil.virtual_memory().available / 1024**2, 1) elif self.type == 'swap_use_percent': self._state = psutil.swap_memory().percent elif self.type == 'swap_use': self._state = round(psutil.swap_memory().used / 1024**2, 1) elif self.type == 'swap_free': self._state = round(psutil.swap_memory().free / 1024**2, 1) elif self.type == 'processor_use': self._state = round(psutil.cpu_percent(interval=None)) elif self.type == 'process': for proc in psutil.process_iter(): try: if self.argument == proc.name(): self._state = STATE_ON return except psutil.NoSuchProcess as err: _LOGGER.warning( "Failed to load process with id: %s, old name: %s", err.pid, err.name) self._state = STATE_OFF elif self.type == 'network_out' or self.type == 'network_in': counters = psutil.net_io_counters(pernic=True) if self.argument in counters: counter = counters[self.argument][IO_COUNTER[self.type]] self._state = round(counter / 1024**2, 1) else: self._state = None elif self.type == 'packets_out' or self.type == 'packets_in': counters = psutil.net_io_counters(pernic=True) if self.argument in counters: self._state = counters[self.argument][IO_COUNTER[self.type]] else: self._state = None elif self.type == 'throughput_network_out' or\ self.type == 'throughput_network_in': counters = psutil.net_io_counters(pernic=True) if self.argument in counters: counter = counters[self.argument][IO_COUNTER[self.type]] now = datetime.now() if self._last_value and self._last_value < counter: self._state = round( (counter - self._last_value) / 1000**2 / (now - self._last_update_time).seconds, 3) else: self._state = None self._last_update_time = now self._last_value = counter else: self._state = None elif self.type == 'ipv4_address' or self.type == 'ipv6_address': addresses = psutil.net_if_addrs() if self.argument in addresses: for addr in addresses[self.argument]: if addr.family == IF_ADDRS_FAMILY[self.type]: self._state = addr.address else: self._state = None elif self.type == 'last_boot': self._state = dt_util.as_local( dt_util.utc_from_timestamp(psutil.boot_time())).isoformat() elif self.type == 'load_1m': self._state = os.getloadavg()[0] elif self.type == 'load_5m': self._state = os.getloadavg()[1] elif self.type == 'load_15m': self._state = os.getloadavg()[2]
def com_system_boot_time(): """ Get boot time """ return psutil.boot_time()