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 test_getloadavg(self):
loadavg = psutil.getloadavg()
assert len(loadavg) == 3
for load in loadavg:
self.assertIsInstance(load, float)
self.assertGreaterEqual(load, 0.0)
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)
