def Update(self): # Send base data self.SetTopicValue(TOPIC_PERCENTAGE, psutil.cpu_percent(), ValueFormatter.TYPE_PERCENTAGE) self.SetTopicValue(TOPIC_COUNT, psutil.cpu_count()) # Send if wanted, extra data if self.GetOption(ADVANCED_INFO_OPTION_KEY): # CPU times self.SetTopicValue(TOPIC_TIMES_USER, psutil.cpu_times()[0], ValueFormatter.TYPE_TIME) self.SetTopicValue(TOPIC_TIMES_SYSTEM, psutil.cpu_times()[1], ValueFormatter.TYPE_TIME) self.SetTopicValue(TOPIC_TIMES_IDLE, psutil.cpu_times()[2], ValueFormatter.TYPE_TIME) # CPU stats self.SetTopicValue(TOPIC_STATS_CTX, psutil.cpu_stats()[0]) self.SetTopicValue(TOPIC_STATS_INTERR, psutil.cpu_stats()[1]) # CPU freq self.SetTopicValue(TOPIC_FREQ_CURRENT, psutil.cpu_freq()[0], ValueFormatter.TYPE_FREQUENCY) self.SetTopicValue(TOPIC_FREQ_MIN, psutil.cpu_freq()[1], ValueFormatter.TYPE_FREQUENCY) self.SetTopicValue(TOPIC_FREQ_MAX, psutil.cpu_freq()[2], ValueFormatter.TYPE_FREQUENCY) if self.os != 'macOS': # CPU avg load self.SetTopicValue(TOPIC_AVERAGE_LOAD_LAST_1, psutil.getloadavg()[0]) self.SetTopicValue(TOPIC_AVERAGE_LOAD_LAST_5, psutil.getloadavg()[1]) self.SetTopicValue(TOPIC_AVERAGE_LOAD_LAST_15, psutil.getloadavg()[2])
def get_servermoni(self): response=BaseResponse() try: # 系统负载 load_5m = round(psutil.getloadavg()[0], 3) load_10m = round(psutil.getloadavg()[1], 3) load_15m = round(psutil.getloadavg()[2], 3) # cpu利用率 cpu_util = psutil.cpu_percent(interval=1) # 内存利用率 memory_util = psutil.virtual_memory().percent # swap利用率 swap_util = psutil.swap_memory().percent # 磁盘流量 import re disk_list=[] for disk in psutil.disk_partitions(): name = re.findall('\w+', disk.device)[1] space_util = psutil.disk_usage(disk.mountpoint).percent obj = psutil.disk_io_counters(perdisk=True).get(name) if obj: rmbs = round(obj.read_bytes / 1024 / 1024 / obj.read_time, 3) wmbs = round(obj.write_bytes / 1024 / 1024 / obj.write_time, 3) else: rmbs = 0 wmbs = 0 disk_list.append({"name":name,"space_util":space_util,"rmbs":rmbs,"wmbs":wmbs}) # 网卡流量 uptime = int(psutil.boot_time()) #系统运行时间 sentmbs = round(psutil.net_io_counters().bytes_sent / 1024 / 1024 / uptime, 3) recvmbs = round(psutil.net_io_counters().bytes_recv / 1024 / 1024 / uptime, 3) servermoni_dict={ "flag":"1", "load":{ "load_5m":load_5m, "load_10m":load_10m, "load_15m":load_15m }, "cpu_util":cpu_util, "memory_util":memory_util, "swap_util":swap_util, "disk_list":disk_list, "net_flow":{ "sentmbs":sentmbs, "recvmbs":recvmbs }, "uptime":uptime, } response.data=servermoni_dict except Exception as e: msg = "主机-%s抓取系统监控信息失败,class ServerMoni出错,%s" self.logger.log(msg % (self.hostname,self.ip, traceback.format_exc()), False) response.status = False response.error = msg % (self.hostname,self.ip, traceback.format_exc()) return response
def sys_load_avg(): print(color.BLUE + 'Load Avg:' + color.END) sysload5 = psutil.getloadavg()[0] sysload10 = psutil.getloadavg()[1] sysload15 = psutil.getloadavg()[2] print('5 min Load Avg:', round((sysload5), 2)) print('10 min Load Avg:', round((sysload10), 2)) if sysload15 > psutil.cpu_count(): print('ERROR: Sysload Average:', sysload15) else: print('15 min Load Avg:', round((sysload15), 2))
def get_system_metrics(): metrics = {} # record datetime metrics['datetime'] = datetime.datetime.now( datetime.timezone.utc).isoformat() # current cpu utlization cpu_utilization = psutil.cpu_percent(interval=0.1) metrics['cpu_percent'] = cpu_utilization # cpu load over the last 1, 5 and 15 minutes in percentage cpu_load = [ round((value / psutil.cpu_count() * 100), 2) for value in psutil.getloadavg() ] metrics['cpu_load_interval_percent'] = dict({ '1min': cpu_load[0], '5min': cpu_load[1], '15min': cpu_load[2] }) metrics['memory_usage'] = dict(psutil.virtual_memory()._asdict()) metrics['disk_usage'] = dict(psutil.disk_usage('/')._asdict()) log.info("Recorded metrics: {}".format(metrics)) return metrics
async def getcpuload(): """Return tuple of cpu information Returns: TUPLE (INT, FLOAT, FLOAT, FLOAT, FLOAT): Description: (numcores, cpufreq, 1minload, 5minload, 15minload) """ rawcpuload = psutil.getloadavg() numcores = psutil.cpu_count() try: numcores = int(numcores) cpufreq = psutil.cpu_freq()[0] / 1000 load1 = (rawcpuload[0] / numcores) * 100 load5 = (rawcpuload[1] / numcores) * 100 load15 = (rawcpuload[2] / numcores) * 100 except ValueError: log.error("Invalid cpu statistics retrieved from server") return ( numcores, truncate_float(cpufreq, 1), truncate_float(load1, 1), truncate_float(load5, 1), truncate_float(load15, 1), )
def cpu_load(): load_tuple = psutil.getloadavg() return { "load1": load_tuple[0], "load5": load_tuple[1], "load15": load_tuple[2] }
def linux(self): response = BaseResponse() try: # 物理个数 2 cpu_physical_count = psutil.cpu_count(logical=False) # 逻辑个数 4 cpu_core_count = psutil.cpu_count() # 负载 (0.0, 0.0, 0.0) cpu_load_tuple = psutil.getloadavg() #cpu 总的cpu使用率 0.8 cpu_total_util = psutil.cpu_percent(interval=1) response.data = {"cpu_physical_count":cpu_physical_count, "cpu_core_count":cpu_core_count, "cpu_load_tuple":cpu_load_tuple, "cpu_total_util":cpu_total_util} except Exception as e: msg = "%s linux CpuPlugin error: %s" self.logger.log(msg % (self.hostname, traceback.format_exc()), False) response.status = False response.error = msg % (self.hostname, traceback.format_exc()) return response
def measure(): # take a timestamp for this measurement time = datetime.datetime.utcnow() # collect some stats from psutil disk = psutil.disk_usage('/') mem = psutil.virtual_memory() load = psutil.getloadavg() temp = psutil.sensors_temperatures()['cpu-thermal'][0].current # format the data as a single measurement for influx body = [{ "measurement": measurement_name, "time": time, "fields": { "load_1": load[0], "load_5": load[1], "load_15": load[2], "disk_percent": disk.percent, "disk_free": disk.free, "disk_used": disk.used, "mem_percent": mem.percent, "mem_free": mem.free, "mem_used": mem.used, "cpu_temp": temp, } }] # write the measurement ifclient.write_points(body)
def get_cpu() -> CPU: if hasattr(psutil, "cpu_count") and hasattr(psutil, "getloadavg"): cpu_usage = [x / psutil.cpu_count() * 100 for x in psutil.getloadavg()] else: cpu_usage = [0.0, 0.0, 0.0] if hasattr(psutil, "sensors_temperatures" ) and 'coretemp' in psutil.sensors_temperatures(): current = [] high = [] critical = [] for temp in psutil.sensors_temperatures()['coretemp']: current.append(temp.current) high.append(temp.high) critical.append(temp.critical) temp = TempCPU( current=sum(current) / len(current), high=sum(high) / len(high), critical=sum(critical) / len(critical), ) else: temp = TempCPU() if hasattr(psutil, "cpu_count"): return CPU(count=psutil.cpu_count(), percent_usage=UsageCPU(last_minute=cpu_usage[0], last_five_minute=cpu_usage[1], last_fifteen_minute=cpu_usage[2]), sensors_temperatures=temp) return CPU()
def print_cpu_memory_usage(): try: import psutil cpu_usage_percent = psutil.cpu_percent(interval=1) virtual_memory = psutil.virtual_memory() last_minute_load, last_5_minute_load, last_15_minute_load = [ x / psutil.cpu_count() * 100 for x in psutil.getloadavg() ] logger.info(""" Cpu usage %%: %s" "Virtual memory: %s" "Last minute cpu load %%: %s" "Last 5 minute cpu load %%: %s" "Last 15 minute cpu load %%: %s" """ % ( cpu_usage_percent, virtual_memory, last_minute_load, last_5_minute_load, last_15_minute_load, )) except Exception as e: logger.info("Could not read cpu and memory usage! Exception: %s", e)
def render(self, image): draw = ImageDraw.Draw(image) mem = psutil.virtual_memory() cpu_util = psutil.cpu_percent(percpu=True) load_avg = psutil.getloadavg() for i in range(4): for j in range(4): draw.text((0 + i * 32, 0 + j * 10), '{:>3}'.format(str(int(cpu_util[j + i * 4])) + '%'), fill=self.fill, font=self.fontSm) draw.rectangle([(0 + i * 32 + 13, 0 + j * 10), (0 + i * 32 + 30, 0 + j * 10 + 6)], fill=(255, 255, 255), outline=self.fill, width=1) bar = self.val_map(int(cpu_util[j + i * 4]), 0, 100, 13, 30) draw.rectangle([(0 + i * 32 + 13, 0 + j * 10), (0 + i * 32 + bar, 0 + j * 10 + 6)], fill=self.fill, width=1) draw.text((0, 41), 'Load Average:' + str(load_avg), fill=self.fill, font=self.fontSm) return image
def gather(self, timestamp: datetime): partitions = psutil.disk_partitions(all=False) disk_usage = {} for disk in partitions: if disk.mountpoint is not None: try: usage = psutil.disk_usage(disk.mountpoint) except PermissionError: continue disk_usage[disk.device.replace('/dev/', '')] = usage self.raw_data.append({ 'time': timestamp, 'data': { "cpu_usage": psutil.cpu_times_percent(percpu=True), "cpu_freq": psutil.cpu_freq(percpu=True), "load_avg": psutil.getloadavg(), "virtual_memory": psutil.virtual_memory(), "swap": psutil.swap_memory(), "disk_usage": disk_usage, "net_io_counters": psutil.net_io_counters(pernic=True), "disk_io_counters": psutil.disk_io_counters(perdisk=True), "processes": len(psutil.pids()) } }) battery = psutil.sensors_battery() if battery is not None: self.raw_data['battery'] = battery
def cpu(): def getCPUtemperature(): res = psutil.sensors_temperatures() highest_core_temp = 0 if 'coretemp' not in res: return int(float(getCPUtemperature_vcgencmd())) for core_temp in res['coretemp']: last_core_temp = core_temp[1] if last_core_temp > highest_core_temp: highest_core_temp = last_core_temp return highest_core_temp def getCPUtemperature_vcgencmd(): res = os.popen('vcgencmd measure_temp').readline() res = res.replace("temp=", "") res = res.replace("'C", "") return res def getCPUfrequ(): freq = str(psutil.cpu_freq()) freq_list = freq.split(',') freq_current = freq_list[0].replace("scpufreq(current=", "") return freq_current response = { 'load': psutil.cpu_percent(), 'load_avg': psutil.getloadavg(), 'freq': int(float(getCPUfrequ())), 'temp': getCPUtemperature() } return jsonify(response)
def get_raspberry_internals(): #Create dictionary values = OrderedDict() values['Device_Name'] = "SOLARIAN_DATALOGGER" # Get CPU and Load related values load_averages = psutil.getloadavg() values['CPU_Temp'] = measure_raspberry_cpu_temp() values['CPU_Usage'] = psutil.cpu_percent() values['SystemLoad_5mins'] = load_averages[0] values['SystemLoad_10mins'] = load_averages[1] values['SystemLoad_15mins'] = load_averages[2] # Get ram values ram = psutil.virtual_memory() values['RAM_Cached'] = round(ram.cached / 2**20, 2) # MiB. values['RAM_Used'] = round(ram.used / 2**20, 2) values['RAM_Free'] = round(ram.free / 2**20, 2) values['RAM_Available'] = round(ram.available / 2**20, 2) values['RAM_Percent'] = ram.percent # Get disk usage information disk = psutil.disk_usage('/') values['DISK_Total'] = round(disk.total / 2**30, 2) # GiB. values['DISK_Used'] = round(disk.used / 2**30, 2) values['DISK_Free'] = round(disk.free / 2**30, 2) values['DISK_Percent'] = disk.percent # Append the time for database values['Date'] = get_timestamp_for_influxdb() # Add the device serial number also values['Device_Serial'] = get_device_serial() return values
def test_getloadavg(self): loadavg = psutil.getloadavg() assert len(loadavg) == 3 for load in loadavg: self.assertIsInstance(load, float) self.assertGreaterEqual(load, 0.0)
def get_cpu_info(): cpu_count = psutil.cpu_count() load_average = psutil.getloadavg() return info_pb2.CpuInfo( cpu_count=cpu_count, load_average=load_average, )
def data(): # Показывает текущую дату и время t = datetime.datetime.now() # Возвращает количество логических процессоров в системе a = psutil.cpu_count() # Возвращает уровень нагрузки процессора в процентах b = psutil.cpu_percent(interval=3) # Возвращает время работы центрального процессора c = psutil.cpu_times(percpu=False) # Возвращает данные о средней загрузке системы d = psutil.getloadavg() # Возвращает данные в байтах об использовании системной памяти e = psutil.virtual_memory() # Возвращает данные в байтах об использовании swap f = psutil.swap_memory() # Возвращает список именованных кортежей всех смонтированных разделов диска g = psutil.disk_partitions(all=False) # Возвращает данных о вводе/выводе h = psutil.disk_io_counters(perdisk=False) # Возвращает глобальные данные сетевого ввода/вывода i = psutil.net_io_counters(pernic=False) results = { "time": t, "cpu_count": a, "cpu_percent": b, "cpu_times": c, "getloadavg": d, "virtual_memory": e, "swap_memory": f, "disk_partitions": g, "disk_io_counters": h, "net_io_counters": i } return results
def display_update(self): cpu_percentage_numeric = psutil.cpu_percent() cpu_percentage_string = 'CPU:{}'.format(psutil.getloadavg()) cpu_temperature_numeric = psutil.sensors_temperatures(fahrenheit=True) cpu_temperature_degree = cpu_temperature_numeric.get( "cpu-thermal")[0][1] boot_time = datetime.datetime.fromtimestamp( psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S") memory = psutil.virtual_memory() log = False if log: self.log.debug('LOCAL TIMER RUNNING...') self.log.debug("CPU %: {}".format(cpu_percentage_numeric)) self.log.debug("CPU LOAD AVG : {}".format(cpu_percentage_string)) self.log.debug( "CPU Temperature : {} def F".format(cpu_temperature_numeric)) self.log.debug("BootTime : {}".format(boot_time)) self.log.debug("Memory : {}".format(memory)) self.log.debug("THREADS RUNNING {0:d}".format( threading.active_count())) self.window.LBL_threads_value.setText(str(threading.active_count())) str1 = "" t_list = threading.enumerate() for ele in t_list: str1 += str(ele) + "\r\n" self.window.LBL_t_list.setText(str(str1)) self.window.LBL_cpu_percent_value.setText( "{:3.2f}".format(cpu_percentage_numeric)) self.window.LBL_cpu_temperature_value.setText( "{:3.2f}".format(cpu_temperature_degree)) self.window.LBL_boot_time_value.setText(boot_time) if not self.spi_log_pause: self.window.TE_spi_log.insertPlainText(str(self.spi.data))
def traiter_message(self, ch, method, properties, body): # Pour l'instant on a juste les evenements ceduleur message_dict = self.json_helper.bin_utf8_json_vers_dict(body) routing_key = method.routing_key exchange = method.exchange if routing_key.startswith('ceduleur'): indicateurs = message_dict['indicateurs'] cpu_load = psutil.getloadavg()[0] if cpu_load < 3.0: if self.__thread_entretien is None or not self.__thread_entretien.is_alive( ): if 'heure' in indicateurs: self.__thread_entretien = Thread( target=self._nettoyer_transactions_expirees, name="Entretien") self.__thread_entretien.start() else: self.__thread_entretien = Thread( target=self._verifier_signature, name="Entretien") self.__thread_entretien.start() else: self.__logger.warning( "CPU load %s > 2.5, pas d'entetien de transactions" % cpu_load) elif routing_key == Constantes.EVENEMENT_ROUTING_PRESENCE_DOMAINES: self.__traiter_presence_domaine(message_dict, properties)
def update(self): avg = getloadavg() with self.block: if self._text: self.block.full_text = self._text.format(*avg) if self._short: self.block.short_text = self._short.format(*avg)
def get(self): loadavg = list(psutil.getloadavg()) cpu_stats = { "percent": psutil.cpu_percent(interval=1, percpu=True), "loadavg": { "last 1 min": loadavg[0], "last 5 min": loadavg[1], "last 10 min": loadavg[2], }, } memory_stats = { "total": psutil.virtual_memory().total, "used": psutil.virtual_memory().used, "available": psutil.virtual_memory().available, "percent": psutil.virtual_memory().percent, } nb_jobs = 0 if config.ENABLE_JOB_QUEUE: from zou.app.stores.queue_store import job_queue registry = job_queue.started_job_registry nb_jobs = registry.count job_stats = { "running_jobs": nb_jobs, } return { "date": datetime.now().isoformat(), "cpu": cpu_stats, "memory": memory_stats, "jobs": job_stats, }
def psutil_cpu_load(self): cpu_load = psutil.getloadavg() l1 = "CPU Load".format(cpu_load[0]) l2 = "{0}/{1}/{2}".format(cpu_load[0], cpu_load[1], cpu_load[2]) return (l1, 0), (l2, 1)
def statistics(request, response): try: memory_total = psutil.virtual_memory().total memory_free = psutil.virtual_memory().available memory_used = memory_total - memory_free # actual memory usage in a cross platform fashion swap_total = psutil.swap_memory().total swap_free = psutil.swap_memory().free swap_used = psutil.swap_memory().used cpu_percent = int(CpuPercent.get()) load_average_percent = [ int(x / psutil.cpu_count() * 100) for x in psutil.getloadavg() ] memory_percent = int(psutil.virtual_memory().percent) swap_percent = int(psutil.swap_memory().percent) disk_usage_percent = int(psutil.disk_usage('/').percent) except psutil.Error as e: raise HTTPConflict(text="Psutil error detected: {}".format(e)) response.json({ "memory_total": memory_total, "memory_free": memory_free, "memory_used": memory_used, "swap_total": swap_total, "swap_free": swap_free, "swap_used": swap_used, "cpu_usage_percent": cpu_percent, "memory_usage_percent": memory_percent, "swap_usage_percent": swap_percent, "disk_usage_percent": disk_usage_percent, "load_average_percent": load_average_percent })
def _upDateCurState(self): self.stateBatch.agentStats = [] ## cpu self.cup_load.systemCpuLoad = psutil.getloadavg()[0] self.state.cpuLoad = self.cup_load self.stateBatch.agentStats.append(self.state)
def stats_payload(): try: import psutil except ImportError: return {} else: s = psutil.virtual_memory() loadavg = psutil.getloadavg() free = float(s.free) / 1048576.0 buffers = hasattr(s, 'buffers') and float(s.buffers) / 1048576.0 or 0.0 cached = hasattr(s, 'cached') and float(s.cached) / 1048576.0 or 0.0 total_free = free + buffers + cached payload = {} payload['mem'] = { 'total': float(s.total) / 1048576.0, # bytes -> megabytes 'free': free, 'buffers': buffers, 'cached': cached, 'total_free': total_free } payload['load'] = dict(zip(('one', 'five', 'fifteen'), loadavg)) return payload
def getSystemStats(): # Function to return a dictionary with the total and free space available # on the disk where we are storing files, as well as the current CPU and RAM # load result = {} # Get the percentage the disk is full total, used, free = shutil.disk_usage( os.path.abspath(os.path.dirname(os.path.abspath(__file__)))) result["disk_pct_free"] = round((free / total) * 100) result["disK_free_GB"] = round(free / (2**30)) # GB # Get CPU load (percent used in the last 1, 5, 15 min) Doesn't work on Windows if sys.platform != "win32": cpu_load = [x / psutil.cpu_count() * 100 for x in psutil.getloadavg()] result["cpu_load_pct"] = round(cpu_load[1]) else: result["cpu_load_pct"] = 0 # Get memory usage result["ram_used_pct"] = round(psutil.virtual_memory().percent) return result
def call_me(self, **_) -> Dict[str, object]: ''' Create CPU load summary string Args: all are ignored Returns: dict to update ``BarSeg`` properties ''' color = None try: load_avg = list( map(lambda x: x * 100 / psutil.cpu_count(), psutil.getloadavg())) except: return {'vis': False} if load_avg[0] > 100: color = "#ff5f5fff" elif load_avg[0] > 80: color = "#ffaf7fff" elif load_avg[0] > 60: color = "#ffff5fff" else: return {'vis': False} value = "|".join((f'{load:.0f}' for load in load_avg)) return {'magnitude': value, 'color': color}
def option2(): clear() # Getting loadover15 minutes load15 = psutil.getloadavg()[2] cpu_usage = (load15/os.cpu_count()) * 100 print("The CPU usage is : ", cpu_usage) input("Press Enter to return to menu.")
def _collect_system_info(self): 'collect cpuinfo, meminfo, mounts' log("Collecting system info") system = {} system['cpu'] = {} system['os'] = {} system['memory'] = {} system['disk'] = {} system['process'] = {} system['compiler'] = {} system['compiler']['make'] = run_cmd(['make', '--version'], env=self._env) system['compiler']['gcc'] = run_cmd(['gcc', '--version'], env=self._env) system['cpu']['information'] = get_cpu_info() system['cpu']['number'] = psutil.cpu_count() system['cpu']['times'] = psutil.cpu_times(percpu=False) system['cpu']['percent'] = psutil.cpu_times_percent(percpu=False) system['cpu']['stats'] = psutil.cpu_stats() system['cpu']['load_avg'] = psutil.getloadavg() system['os']['architecture'] = platform.architecture() system['os']['processor'] = platform.processor() system['os']['release'] = platform.release() system['os']['version'] = platform.version() system['os']['libc'] = platform.libc_ver() system['memory']['virtual'] = psutil.virtual_memory() system['memory']['swap'] = psutil.swap_memory() system['memory']['mounts'] = psutil.disk_partitions() system['disk']['usage'] = psutil.disk_usage('/') system['disk']['io'] = psutil.disk_io_counters(perdisk=False, nowrap=True) process = psutil.Process() system['process']['io'] = process.io_counters() system['process']['context_switches'] = process.num_ctx_switches() system['process']['cpu_times'] = process.cpu_times() system['process']['threads'] = process.num_threads() system['process']['cpu_percent'] = process.cpu_percent() system['process']['memory'] = process.memory_info() system['process']['memory_percent'] = process.memory_percent() # files to be uploaded and saved somewhere ''' with open('/proc/cpuinfo', 'r') as f: system['cpuinfo'] = f.read() with open('/proc/meminfo', 'r') as f: system['meminfo'] = f.read() with open('/proc/mounts', 'r') as f: system['mounts'] = f.read() ''' return system
def _refresh_mode(self): """Update cloud service for our current state, and get new wanted state""" if time.time() - self.last_mode_check < 5: return self.last_mode_check = time.time() if self.url is None: return try: logging.info(self.cam.disk_space) try: detector_lag = str( round( len(self.detector.image_cache) * self.detector.keep_sending_after_phash_diff, 1, )) except Exception as e: detector_lag = "NA" logging.warning(e) self._check_diskspace() client_state = { "mode": self.state["server"]["mode"], "exposure": round(self.cam.exposure, 2), "exposure_modifier": self.cam.exposure_modifier, "frame_no": self.cam.frame, "frame_rec": self.cam.recorded_frame, "disk_free_gb": self.disk_space.get("now", {}).get("freeGb", "NA"), "fps": round(self.cam.fps, 2), "camera_working": self.cam.working, "load": str(psutil.getloadavg()), "memory_used_%": psutil.virtual_memory().percent, "detector_lag": detector_lag, } values = { "token": self.token, "id": self.id, "state": json.dumps(client_state), } r = requests.post(self.url + "/state", data=values) new_state = r.json() self.mode_change = (self.state["server"]["mode"] != new_state["server"]["mode"]) if self.mode_change: logging.info("Running mode changed to: {}".format( new_state["server"]["mode"])) new_state["client"]["mode"] = new_state["server"]["mode"] try: self.cam.exposure_modifier = float( new_state["server"]["exposure_modifier"]) except KeyError: pass self.state = new_state except Exception as e: logging.error(e)
def print_header(procs_status, num_procs): """Print system-related info, above the process list.""" def get_dashes(perc): dashes = "|" * int((float(perc) / 10 * 4)) empty_dashes = " " * (40 - len(dashes)) return dashes, empty_dashes # cpu usage percs = psutil.cpu_percent(interval=0, percpu=True) for cpu_num, perc in enumerate(percs): dashes, empty_dashes = get_dashes(perc) print_line(" CPU%-2s [%s%s] %5s%%" % (cpu_num, dashes, empty_dashes, perc)) mem = psutil.virtual_memory() dashes, empty_dashes = get_dashes(mem.percent) line = " Mem [%s%s] %5s%% %6s / %s" % ( dashes, empty_dashes, mem.percent, str(int(mem.used / 1024 / 1024)) + "M", str(int(mem.total / 1024 / 1024)) + "M" ) print_line(line) # swap usage swap = psutil.swap_memory() dashes, empty_dashes = get_dashes(swap.percent) line = " Swap [%s%s] %5s%% %6s / %s" % ( dashes, empty_dashes, swap.percent, str(int(swap.used / 1024 / 1024)) + "M", str(int(swap.total / 1024 / 1024)) + "M" ) print_line(line) # processes number and status st = [] for x, y in procs_status.items(): if y: st.append("%s=%s" % (x, y)) st.sort(key=lambda x: x[:3] in ('run', 'sle'), reverse=1) print_line(" Processes: %s (%s)" % (num_procs, ', '.join(st))) # load average, uptime uptime = datetime.datetime.now() - \ datetime.datetime.fromtimestamp(psutil.boot_time()) av1, av2, av3 = psutil.getloadavg() line = " Load average: %.2f %.2f %.2f Uptime: %s" \ % (av1, av2, av3, str(uptime).split('.')[0]) print_line(line)