def cpu_usage(self, usage):
if usage == HostMetric.cpu_count:
return psutil.cpu_count()
elif usage == HostMetric.cpu_user:
return psutil.cpu_times_percent().user
else:
return psutil.cpu_times_percent().idle
def test_no_procfs_on_import(self, tb):
my_procfs = tempfile.mkdtemp()
with open(os.path.join(my_procfs, 'stat'), 'w') as f:
f.write('cpu 0 0 0 0 0 0 0 0 0 0\n')
f.write('cpu0 0 0 0 0 0 0 0 0 0 0\n')
f.write('cpu1 0 0 0 0 0 0 0 0 0 0\n')
try:
orig_open = open
def open_mock(name, *args, **kwargs):
if name.startswith('/proc'):
raise IOError(errno.ENOENT, 'rejecting access for test')
return orig_open(name, *args, **kwargs)
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
importlib.reload(psutil)
assert tb.called
self.assertRaises(IOError, psutil.cpu_times)
self.assertRaises(IOError, psutil.cpu_times, percpu=True)
self.assertRaises(IOError, psutil.cpu_percent)
self.assertRaises(IOError, psutil.cpu_percent, percpu=True)
self.assertRaises(IOError, psutil.cpu_times_percent)
self.assertRaises(
IOError, psutil.cpu_times_percent, percpu=True)
psutil.PROCFS_PATH = my_procfs
self.assertEqual(psutil.cpu_percent(), 0)
self.assertEqual(sum(psutil.cpu_times_percent()), 0)
# since we don't know the number of CPUs at import time,
# we awkwardly say there are none until the second call
per_cpu_percent = psutil.cpu_percent(percpu=True)
self.assertEqual(sum(per_cpu_percent), 0)
# ditto awkward length
per_cpu_times_percent = psutil.cpu_times_percent(percpu=True)
self.assertEqual(sum(map(sum, per_cpu_times_percent)), 0)
# much user, very busy
with open(os.path.join(my_procfs, 'stat'), 'w') as f:
f.write('cpu 1 0 0 0 0 0 0 0 0 0\n')
f.write('cpu0 1 0 0 0 0 0 0 0 0 0\n')
f.write('cpu1 1 0 0 0 0 0 0 0 0 0\n')
self.assertNotEqual(psutil.cpu_percent(), 0)
self.assertNotEqual(
sum(psutil.cpu_percent(percpu=True)), 0)
self.assertNotEqual(sum(psutil.cpu_times_percent()), 0)
self.assertNotEqual(
sum(map(sum, psutil.cpu_times_percent(percpu=True))), 0)
finally:
shutil.rmtree(my_procfs)
importlib.reload(psutil)
self.assertEqual(psutil.PROCFS_PATH, '/proc')
def main(argv):
opts, loop_opts = parse_args(argv)
if opts.root_setup:
return root_setup.root_setup()
def single_iteration():
try:
system_metrics.get_cpu_info()
system_metrics.get_disk_info()
system_metrics.get_mem_info()
system_metrics.get_net_info()
system_metrics.get_proc_info()
puppet_metrics.get_puppet_summary()
finally:
ts_mon.flush()
return True
# This returns a 0 value the first time it's called. Call it now and discard
# the return value.
psutil.cpu_times_percent()
# Wait a random amount of time before starting the loop in case sysmon is
# started at exactly the same time on all machines.
time.sleep(random.uniform(0, opts.interval))
loop_results = outer_loop.loop(
task=single_iteration,
sleep_timeout=lambda: opts.interval,
**loop_opts)
return 0 if loop_results.success else 1
def __init__(self, host_proc, event_prefix):
self.event_prefix = event_prefix
# Have to redirect this so we're not reading the container's /proc but the host's
psutil.PROCFS_PATH = host_proc
# Start the cpu_percent interval - this will return 0 the first time
psutil.cpu_times_percent()
def get(self, *args, **kwargs):
"""
provide details of cpu and memory usage
"""
context = {
'cpu': {
'user': psutil.cpu_times_percent().user,
'system': psutil.cpu_times_percent().system,
'idle': psutil.cpu_times_percent().idle,
'iowait': psutil.cpu_times_percent().iowait,
'usage': psutil.cpu_percent()
},
'memory': {
'percent': psutil.virtual_memory().percent,
'total': psutil.virtual_memory().total,
'available': psutil.virtual_memory().available,
'used': psutil.virtual_memory().used,
'free': psutil.virtual_memory().free,
'cached': psutil.virtual_memory().cached
}
}
templateRoot = options.TEMPLATE_ROOT
loader = Loader(templateRoot)
templateName = 'stats.html'
response = loader.load(templateName).generate(**context)
self.write(response)
self.finish()
def starting(self, sender, **kwargs):
psutil.cpu_times_percent()
psutil.cpu_percent()
_, _, my_id = self.vip.hello().get(timeout=3)
self.vip.pubsub.publish(peer='pubsub', topic='/platform',
message='available')
def __init__(self, name, init_config, agent_config):
super(Cpu, self).__init__(name, init_config, agent_config)
# psutil.cpu_percent and psutil.cpu_times_percent are called in
# __init__ because the first time these two functions are called with
# interval = 0.0 or None, it will return a meaningless 0.0 value
# which you are supposed to ignore.
psutil.cpu_percent(interval=None, percpu=False)
psutil.cpu_times_percent(interval=None, percpu=False)
def test_sys_per_cpu_times_percent_negative(self):
# see: https://github.com/giampaolo/psutil/issues/645
psutil.cpu_times_percent(percpu=True)
zero_times = [x._make([0 for x in range(len(x._fields))]) for x in psutil.cpu_times(percpu=True)]
with mock.patch("psutil.cpu_times", return_value=zero_times):
for cpu in psutil.cpu_times_percent(percpu=True):
for percent in cpu:
self._test_cpu_percent(percent, None, None)
def test_cpu_times_percent(self):
last = psutil.cpu_times_percent(interval=0.001)
for x in range(100):
new = psutil.cpu_times_percent(interval=None)
for percent in new:
self._test_cpu_percent(percent, last, new)
self._test_cpu_percent(sum(new), last, new)
last = new
def get_cup_info():
global fg
print "\033[31m%scpu状态信息%s\033[0m" %(fg*30,fg*30)
print "cpu 逻辑个数：%s个" % psutil.cpu_count()
print "cpu 物理个数：%s个" % psutil.cpu_count(logical=False)
print "cpu 用户空间占用百分比：%s" % (psutil.cpu_times_percent(interval=1).user)+"%"
print "cpu 内核空间占用百分比：%s" % (psutil.cpu_times_percent(interval=1).system)+"%"
print "cpu 空闲空间剩余百分比：%s" % (psutil.cpu_times_percent(interval=1).idle)+"%"
def test_per_cpu_times_percent(self):
last = psutil.cpu_times_percent(interval=0.001, percpu=True)
self.assertEqual(len(last), psutil.cpu_count())
for x in range(100):
new = psutil.cpu_times_percent(interval=None, percpu=True)
for cpu in new:
for percent in cpu:
self._test_cpu_percent(percent, last, new)
self._test_cpu_percent(sum(cpu), last, new)
last = new
def collect(self,obj_id,part_id,part_name,slot_id):
"""
Collector cpu stats
"""
try:
col_time = time.strftime('%Y-%m-%d %X')
collect_data_list = []
def publish(*args,**kwargs):
item_num = collect_metrics.metrics.get('cpu_hw').get(args[2])
if item_num is not None:
#9#print args
collect_data_list.append((args[0],args[1],item_num[0],args[3],item_num[1],col_time))
if not psutil:
log_format.logger.error('Unable to import psutil')
return None
cpu_count = psutil.cpu_count()
cpu_info = None
if part_name == 'cpu_total':
cpu_info = psutil.cpu_times_percent(percpu=False)
else:
#if need collect all cpu,should delete follow row.
return None
#
for i in range(cpu_count):
cpu = 'cpu' + str(i)
if cpu == part_name:
cpu_info = psutil.cpu_times_percent(percpu=True)[i]
if cpu_info is not None:
publish(obj_id,part_id,'user',cpu_info.user,precision=2)
publish(obj_id,part_id,'nice',cpu_info.nice,precision=2)
publish(obj_id,part_id,'system',cpu_info.system,precision=2)
publish(obj_id,part_id,'idle',cpu_info.idle,precision=2)
publish(obj_id,part_id,'iowait',cpu_info.iowait,precision=2)
publish(obj_id,part_id,'irq',cpu_info.irq,precision=2)
publish(obj_id,part_id,'softirq',cpu_info.softirq,precision=2)
publish(obj_id,part_id,'steal',cpu_info.steal,precision=2)
if part_name == 'cpu_total' and os.access('/proc/loadavg',os.R_OK):
fr = open('/proc/loadavg','r')
data = fr.read()
fr.close()
for line in data.splitlines():
try:
min1, min5, min15, procs, last_pid = line.split()
publish(obj_id,part_id,'load_average_1min',min1,precision=2)
publish(obj_id,part_id,'load_average_5min',min5,precision=2)
publish(obj_id,part_id,'load_average_15min',min15,precision=2)
break
except Exception,ex_in_for:
log_format.logger.error(str(ex_in_for.args))
insertdb.insertdb(collect_data_list)
return True
def cpu_times_percent(self):
ret = {}
ret['cpu_percent_user'] = psutil.cpu_times_percent().user
ret['cpu_percent_nice'] = psutil.cpu_times_percent().nice
ret['cpu_percent_system'] = psutil.cpu_times_percent().system
ret['cpu_percent_idle'] = psutil.cpu_times_percent().idle
ret['cpu_percent_iowait'] = psutil.cpu_times_percent().iowait
ret['cpu_percent_irq'] = psutil.cpu_times_percent().irq
ret['cpu_percent_softirq'] = psutil.cpu_times_percent().softirq
ret['cpu_percent_steal'] = psutil.cpu_times_percent().steal
ret['cpu_percent_guest'] = psutil.cpu_times_percent().guest
ret['cpu_percent_guest_nice'] = psutil.cpu_times_percent().guest_nice
return ret
def update(self):
times_percent = psutil.cpu_times_percent(percpu=True)
cpu = psutil.cpu_times_percent()
self.cpu.update(cpu.user, cpu.system, cpu.idle)
for i, c in enumerate(times_percent):
self.each_cpu[i].update(c.user, c.system, c.idle)
self.__update_memory(self.memory, psutil.virtual_memory())
self.__update_memory(self.swap, psutil.swap_memory())
self.loadavg.update()
self.uptime.update()
self.procs.update()
def collect_cpu(self):
cpu = psutil.cpu_times_percent()
results = {
'cpu.cores': psutil.cpu_count(),
'cpu.percent': (cpu.user + cpu.nice + cpu.system),
'cpu.user': cpu.user,
'cpu.nice': cpu.nice,
'cpu.system': cpu.system,
'cpu.idle': cpu.idle
}
if hasattr(cpu, "iowait"):
results['cpu.iowait'] = cpu.iowait
if hasattr(cpu, "irq"):
results['cpu.irq'] = cpu.irq
if hasattr(cpu, "softirq"):
results['cpu.softirq'] = cpu.softirq
if hasattr(cpu, "steal"):
results['cpu.steal'] = cpu.steal
if hasattr(cpu, "guest"):
results['cpu.guest'] = cpu.guest
if hasattr(cpu, "guestnice"):
results['cpu.guestnice'] = cpu.guestnice
return results
def init(interval):
global cpu
while 1:
load = psutil.cpu_times_percent()
cpu["user"] = int(load.user)
cpu["system"] = int(load.system)
time.sleep(interval)
def sysinfodash(self):
''' used for the dash '''
d = {}
# Cpu stuff
cpu = psutil.cpu_times_percent(interval=0.1, percpu=False)
cpu = cpu._asdict()
d['cpu'] = {'user': cpu['user'],
'system': cpu['system'],
'idle': cpu['idle']
}
# Virtual memory
vmem = psutil.virtual_memory()
vmem = vmem._asdict()
d['virtual'] = {'total': vmem['total'],
'percent': vmem['percent'],
'available': vmem['available']
}
d['localip'] = self.get_local_ip(dash=True)
d['externalip'] = self.get_external_ip(dash=True)
nw_psutil = psutil.net_io_counters()
dnw_psutil = nw_psutil._asdict()
d['network'] = dnw_psutil
d['uptime'] = self.uptime(dash=True)
d['user'] = self.get_user(dash=True)
return d
def index():
load_avg = os.getloadavg()
uptime = datetime.now() - datetime.fromtimestamp(psutil.get_boot_time())
disks = get_disks()
users = get_users()
netifs = get_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.NUM_CPUS,
"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 get_cpu():
times = psutil.cpu_times_percent(percpu=False)
return jsonify({
'user': times.user, 'nice': times.nice, 'system': times.system, 'idle': times.idle,
'iowait': times.iowait, 'irq': times.irq, 'softirq': times.softirq,
'steal': times.steal, 'guest': times.guest, 'guest_nice': times.guest_nice
})
def main():
hostname = getfqdn()
data = ''
for k, v in psutil.cpu_times_percent(interval=0.5)._asdict().iteritems():
data += '{0}.cpu.{1} value={2}\n'.format(hostname, k, v)
for k, v in psutil.virtual_memory()._asdict().iteritems():
data += '{0}.mem.{1} value={2}\n'.format(hostname, k, v)
for k, v in psutil.swap_memory()._asdict().iteritems():
data += '{0}.swap.{1} value={2}\n'.format(hostname, k, v)
du = { mp.mountpoint: psutil.disk_usage(mp.mountpoint).percent for mp in psutil.disk_partitions() }
for k, v in du.iteritems():
data += '{0}.du_percent.{1} value={2}\n'.format(hostname, k, v)
for k, v in psutil.disk_io_counters(perdisk=True).iteritems():
for m, p in v._asdict().iteritems():
data += '{0}.io.{1}.{2} value={3}\n'.format(hostname, k, m, p)
for k, v in psutil.net_io_counters(pernic=True).iteritems():
for m, p in v._asdict().iteritems():
data += '{0}.net.{1}.{2} value={3}\n'.format(hostname, k, m, p)
connections = map(lambda x: x.status.lower(), psutil.net_connections())
connections = map( lambda x: 'unknown_state' if x == 'none' else x, connections )
for conn in set(connections):
data += '{0}.netstat.{1} value={2}\n'.format(hostname, conn, connections.count(conn))
if DEBUG: print data
sendData(data)
def collect_cpu_stats():
times = psutil.cpu_times()
per_core_snapshot = psutil.cpu_times_percent(interval=1, percpu=True)
data = {
"system_cpu_times": {
"user": times.user,
"nice": times.nice,
"system": times.system,
"idle": times.idle,
"iowait": times.iowait,
"irq": times.irq,
"softirq": times.softirq,
"steal": times.steal,
"guest": times.guest,
"guest_nice": times.guest_nice
},
"percore_cpu_times": []
}
for cpu in per_core_snapshot:
data['percore_cpu_times'].append({
"user": cpu.user,
"nice": cpu.nice,
"system": cpu.system,
"idle": cpu.idle,
"iowait": cpu.iowait,
"irq": cpu.irq,
"softirq": cpu.softirq,
"steal": cpu.steal,
"guest": cpu.guest,
"guest_nice": cpu.guest_nice
})
return data
def __get_percpu(self):
"""Update and/or return the per CPU list using the psutil library."""
# Never update more than 1 time per cached_time
if self.timer_percpu.finished():
self.percpu_percent = []
for cpu_number, cputimes in enumerate(psutil.cpu_times_percent(interval=0.0, percpu=True)):
cpu = {'key': self.get_key(),
'cpu_number': cpu_number,
'total': round(100 - cputimes.idle, 1),
'user': cputimes.user,
'system': cputimes.system,
'idle': cputimes.idle}
# The following stats are for API purposes only
if hasattr(cputimes, 'nice'):
cpu['nice'] = cputimes.nice
if hasattr(cputimes, 'iowait'):
cpu['iowait'] = cputimes.iowait
if hasattr(cputimes, 'irq'):
cpu['irq'] = cputimes.irq
if hasattr(cputimes, 'softirq'):
cpu['softirq'] = cputimes.softirq
if hasattr(cputimes, 'steal'):
cpu['steal'] = cputimes.steal
if hasattr(cputimes, 'guest'):
cpu['guest'] = cputimes.guest
if hasattr(cputimes, 'guest_nice'):
cpu['guest_nice'] = cputimes.guest_nice
# Append new CPU to the list
self.percpu_percent.append(cpu)
# Reset timer for cache
self.timer_percpu = Timer(self.cached_time)
return self.percpu_percent
def cpustat(self):
tags="node:%s %s"%(self.nodename,self.tags)
val=int(psutil.cpu_percent())
measurement="cpu_perc"
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
val=int(psutil.virtual_memory()[1]/1024/1024)
measurement="mem_free_mb"
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
val=int(psutil.swap_memory()[3])
measurement="mem_virt_perc"
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
val=int(psutil.virtual_memory()[2])
measurement="mem_phy_perc"
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
res=psutil.cpu_times_percent()
names=["cputimeperc_user","cputimeperc_nice","cputimeperc_system","cputimeperc_idle","cputimeperc_iowait","cputimeperc_irq","cputimeperc_softirq","steal","guest","guest_nice"]
for i in range(len(names)):
if names[i].startswith("cputime"):
val=int(res[i])
measurement=names[i]
key="%s.%s"%(self.nodename,measurement)
self.measure(key,measurement,tags,val,aggrkey=measurement)
def cpu_load_stats():
cpu_load = psutil.cpu_times_percent(interval=1, percpu=False)
user_load = cpu_load.user
system_load = cpu_load.system
irq_load = cpu_load.irq
return (user_load, system_load, irq_load)
def get_new_row():
# get a new blank row and add a random brightness snowflake to a random column
row = get_blank_row()
cpu = psutil.cpu_times_percent(1)
tot_cpu = cpu.user + cpu.system
#print tot_cpu
# identify cpu usage bracket - 6 brackets, each 20% except very low and very high (10%)
bracket = round(tot_cpu/20)
#print bracket
# colour and number chance is proportional to cpu usage
# randomly decide how many cols will contain sth
if bracket < 1:
cols = randint(0,1)
elif bracket < 3:
cols = randint(1,bracket)
else:
cols = randint(bracket-2, bracket)
# determine r g b excess for each bracket
# 0 - very blue
# 1 - mostly green, some blue
# 2 - yellow
# 3 - orange
# 4 - red
# 5 - very red/purple
# corrections :
for x in range(cols):
corr = sample(range(0,40),3)*2
row[randint(0, width - 1)] = [rgb[bracket][0] + corr[0], rgb[bracket][1]+ corr[1], rgb[bracket][2] + corr[2]] # selects random col and sets brightness from 50 to 205
return row
def doCPU(lights):
cpu = psutil.cpu_times_percent()
u = cpu.user + cpu.nice
s = cpu.system + cpu.steal + cpu.guest_nice + cpu.guest
w = cpu.irq + cpu.iowait + cpu.softirq
i = cpu.idle
# Cumulative
ac = s
bc = ac + w
cc = bc + u
tot = cc + i
aIdx = cpuLEDRange.toLEDIndex(ac / 100)
bIdx = cpuLEDRange.toLEDIndex(bc / 100)
cIdx = cpuLEDRange.toLEDIndex(cc / 100)
for x in cpuLEDRange.range:
if x <= aIdx:
r = 30
elif x <= bIdx:
r = 0
elif x <= cIdx:
r = 250
# elif x < (tot * norm):
# r = 0
else:
r = 0
lights.set(x, r, 0, 0)
def _getSummary():
"""
:returns: a _CsvRow object
"""
timestamp = time.time()
loadAvg1, loadAvg5, loadAvg15 = os.getloadavg()
cpuTimesPct = psutil.cpu_times_percent(interval=0)
virtualMem = psutil.virtual_memory()
swapMem = psutil.swap_memory()
row = _CsvRow(
timestamp=timestamp,
loadAvg1=loadAvg1,
loadAvg5=loadAvg5,
loadAvg15=loadAvg15,
cpuUserPct=cpuTimesPct.user,
cpuSystemPct=cpuTimesPct.system,
cpuNicePct=cpuTimesPct.nice,
cpuIdlePct=cpuTimesPct.idle,
memTotalB=virtualMem.total,
memUsageB=virtualMem.total - virtualMem.available,
memAvailB=virtualMem.available,
memUsagePct=virtualMem.percent,
memBuffersB=virtualMem.buffers if hasattr(virtualMem, "buffers") else None,
memCachedB=virtualMem.cached if hasattr(virtualMem, "cached") else None,
swapTotalB=swapMem.total,
swapUsedB=swapMem.used,
swapFreeB=swapMem.free,
swapUsedPct=swapMem.percent,
swapInsB=swapMem.sin,
swapOutsB=swapMem.sout
)
return row
def collect_cpuinfo(self):
cpuinfo = psutil.cpu_times_percent(interval=1,percpu=False)
cpuset = {}
cpuset['user'] = cpuinfo.user
cpuset['system'] = cpuinfo.system
cpuset['idle'] = cpuinfo.idle
cpuset['iowait'] = cpuinfo.iowait
self.etcdser.setkey('/cpuinfo',cpuset)
output = subprocess.check_output(["cat /proc/cpuinfo"],shell=True)
output = output.decode('utf-8')
parts = output.split('\n')
info = []
idx = -1
for part in parts:
if not part == '':
key_val = re.split(':',part)
key = key_val[0].rstrip()
if key == 'processor':
info.append({})
idx += 1
val = key_val[1].lstrip()
if key=='processor' or key=='model name' or key=='core id' or key=='cpu MHz' or key=='cache size' or key=='physical id':
info[idx][key] = val
self.etcdser.setkey('/cpuconfig',info)
return
def probe(self):
times = psutil.cpu_times_percent()
items = sorted(times._asdict().items())
if self.extended == False:
showvals = ", ".join(["%.1f%% %s" % (v,n) for n,v in items if v != 0.0])
else:
showvals = ", ".join(["%.1f%% %s" % (v,n) for n,v in items])
summary = "CPU utilization is " + showvals
metrics = dict(times._asdict().items())
if self.userfailed is not None and times.user > self.userfailed:
return self.failed(summary, metrics)
if self.systemfailed is not None and times.system > self.systemfailed:
return self.failed(summary, metrics)
if self.iowaitfailed is not None and times.iowait > self.iowaitfailed:
return self.failed(summary, metrics)
if self.userdegraded is not None and times.user > self.userdegraded:
return self.degraded(summary, metrics)
if self.systemdegraded is not None and times.system > self.systemdegraded:
return self.degraded(summary, metrics)
if self.iowaitdegraded is not None and times.iowait > self.iowaitdegraded:
return self.degraded(summary, metrics)
if self.idlefailed is not None and times.idle < self.idlefailed:
return self.failed(summary, metrics)
if self.idledegraded is not None and times.idle < self.idledegraded:
return self.degraded(summary, metrics)
return self.healthy(summary, metrics)
def write_status(self):
historian_present = False
try:
ping = self.vip.ping('platform.historian', 'awake?').get(timeout=2)
historian_present = True
except Unreachable:
_log.warning('platform.historian unavailable no logging of data will occur.')
return
_log.debug('publishing data')
base_topic = 'datalogger/log/platform/status'
cpu = base_topic + '/cpu'
virtual_memory = base_topic + "/virtual_memory"
disk_partitions = base_topic + "/disk_partiions"
points = {}
for k, v in psutil.cpu_times_percent().__dict__.items():
points['times_percent/' + k] = {'Readings': v,
'Units': 'double'}
points['percent'] = {'Readings': psutil.cpu_percent(),
'Units': 'double'}
message = jsonapi.dumps(points)
self.vip.pubsub.publish(peer='pubsub',
topic=cpu,
message=points)
def _get_system_cpu_utilization(self,
observer: metrics.ValueObserver) -> None:
"""Observer callback for system CPU utilization
Args:
observer: the observer to update
"""
for cpu, times_percent in enumerate(
psutil.cpu_times_percent(percpu=True)):
for metric in self._config["system.cpu.utilization"]:
if hasattr(times_percent, metric):
self._system_cpu_utilization_labels["state"] = metric
self._system_cpu_utilization_labels["cpu"] = cpu + 1
observer.observe(
getattr(times_percent, metric) / 100,
self._system_cpu_utilization_labels,
)
def validate(self, X_test, Y_test, test_results, outputs, j, positives,
losses, accuracies, T):
"""
Compute the loss function on the validation data.
Also output a random example of a digit after every epoch
and the network's guess.
"""
loss = self.cost_function.fn(outputs, T) / len(T.T)
# Throttle code - DO NOT REMOVE THIS. Prevents system crashes.
if psutil.virtual_memory().percent > 95 or psutil.cpu_times_percent(
).idle < 5:
time.sleep(1)
losses.append(loss)
if self.type == 'sigmoid':
pass
else:
testi = random.choice(range(Y_test.shape[1]))
test = X_test.T[testi]
plt.imshow(test.reshape(28, 28), cmap='gray')
plt.show()
cls = int(test_results.T[testi])
print("Prediction: %d confidence=%0.2f" %
(cls, np.asarray(outputs).T[testi][cls] /
np.sum(outputs.T[testi])))
accpct = 100 * positives / X_test.shape[1]
accuracies.append(accpct)
if j % 10 == 9:
print(" Speed: %0.2f s/pass" % ((time.time() - self.tm) /
(j + 0.01)))
print(" Accuracy: %d/%d, %0.3f%%" %
(positives, X_test.shape[1], accpct))
plt.plot(np.log(losses), color='blue')
plt.title("Log loss")
plt.show()
plt.plot(accuracies, color='blue')
plt.title("Accuracy")
plt.show()
'''
def put_info(local_ip, local_prot):
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.bind((local_ip, local_prot))
serversocket.listen(20)
while True:
s, addr = serversocket.accept()
message = s.recv(1024).decode('utf-8')
#返回操作系统信息
if message == 'get_platform':
s.send(sys.platform.encode('utf-8'))
#返回打开文件信息
if message == 'get_openfiles':
openfiles_info = [
p.info for p in psutil.process_iter(['pid', 'open_files'])
]
openfiles_info_json = json.dumps(openfiles_info)
s.send(openfiles_info_json.encode('utf-8'))
#返回进程信息
if message == 'get_process':
process_info = [
p.info
for p in psutil.process_iter(['pid', 'username', 'name'])
]
process_info_json = json.dumps(process_info)
s.send(process_info_json.encode('utf-8'))
#返回内存信息
if message == 'get_memory':
mem_list = [[], []]
for x in psutil.virtual_memory():
mem_list[0].append(x)
for y in psutil.swap_memory():
mem_list[1].append(y)
mem_json = json.dumps(mem_list)
s.send(mem_json.encode('utf-8'))
#返回cpu信息
if message == 'get_cpu':
cpu_list = [[], [], []]
for x in psutil.cpu_times_percent(interval=1, percpu=False):
cpu_list[0].append(x)
cpu_list[1].append(psutil.cpu_count(logical=True))
for y in psutil.getloadavg():
cpu_list[2].append(y)
cpu_json = json.dumps(cpu_list)
s.send(cpu_json.encode('utf-8'))
def exec_combination(device, pipeline, pi_dict, f_input, combination):
'''
Execute the whole pipeline for the given function and combination of parameters.
Note that the order of the parameter values must be the same as in the ordered
dictionary function.params.keys().
'''
row_dict = pi_dict.copy()
base_f_c = 0
for f in pipeline:
params_list = list(f.params.keys())
params_dict = {}
params_data = {}
for param_i in range(len(params_list)):
p_value = combination[base_f_c + param_i]
params_dict[params_list[param_i]] = p_value
row_dict[f.data.name + '_' +
str(params_list[param_i])] = str(p_value)
params_data[str(params_list[param_i])] = str(p_value)
row_dict['cpu_idle'] = psutil.cpu_times_percent(interval=0.5).idle
row_dict['memory_available'] = psutil.virtual_memory().available
row_dict[f.data.name + '_start'] = time.time()
f_output_value = f.function(f_input.io_value, **params_dict)
row_dict[f.data.name + '_end'] = time.time()
base_f_c += len(f.params.keys())
f_output = MFAIO(
io_id='io_' +
MFAUtil.params_input_to_string(params_dict, f_input.data),
io_size=sys.getsizeof(f_output_value),
io_format=type(f_output_value),
io_value=f_output_value)
f.data.add_exec_sample(
device.device_id, f_input.data, f_output.data, params_data, {
'latency': (row_dict[f.data.name + '_end'] -
row_dict[f.data.name + '_start'])
})
f_input = f_output
row_dict['output'] = f_input.io_value
return row_dict
def server():
global cpu_times
def calculate(t1, t2):
t1_all = sum(t1)
t1_busy = t1_all - t1.idle
t2_all = sum(t2)
t2_busy = t2_all - t2.idle
# this usually indicates a float precision issue
if t2_busy <= t1_busy:
return 0.0
busy_delta = t2_busy - t1_busy
all_delta = t2_all - t1_all
busy_perc = (busy_delta / all_delta) * 100
return round(busy_perc, 1)
ret = {}
ret.update({
"mem_" + key: val
for key, val in psutil.virtual_memory().__dict__.iteritems()
})
ret.update({
"cpu_ptime_" + key: val
for key, val in psutil.cpu_times_percent().__dict__.iteritems()
})
if None not in cpu_times:
ret['cpu_percent'] = calculate(*cpu_times)
else:
ret['cpu_percent'] = 0
ret.update({
"diskio_" + key: val
for key, val in psutil.disk_io_counters().__dict__.iteritems()
})
ret.update({
"disk_" + key: val
for key, val in psutil.disk_usage('/').__dict__.iteritems()
})
users = psutil.get_users()
ret['user_count'] = len(users)
ret['user_info'] = [(u.name, u.host) for u in users]
return jsonify(**ret)
def _publish_stats(self):
"""
Publish the platform statistics to the local bus as well as to the
connected volttron central.
"""
vc_topic = None
local_topic = LOGGER(subtopic="platform/status/cpu")
_log.debug('Publishing platform cpu stats')
if self._platform_uuid:
vc_topic = LOGGER(
subtopic="platforms/{}/status/cpu".format(self._platform_uuid))
_log.debug('Stats will be published to: {}'.format(
vc_topic.format()))
else:
_log.debug('Platform uuid is not valid')
points = {}
for k, v in psutil.cpu_times_percent().__dict__.items():
points['times_percent/' + k] = {'Readings': v, 'Units': 'double'}
points['percent'] = {
'Readings': psutil.cpu_percent(),
'Units': 'double'
}
self.vip.pubsub.publish(peer='pubsub',
topic=local_topic.format(),
message=points)
# Handle from external platform
if vc_topic and self._agent_connected_to_vc:
self._agent_connected_to_vc.vip.pubsub.publish(
peer='pubsub', topic=vc_topic.format(), message=points)
# Handle if platform agent on same machine as vc.
elif vc_topic and \
self._my_discovery_address == self._vc_discovery_address:
self.vip.pubsub.publish(peer='pubsub',
topic=vc_topic.format(),
message=points)
else:
_log.info("status not written to volttron central.")
def load_initial(self):
print("Waiting for slaves to launch..")
self.cpu = psutil.cpu_times_percent(interval=0.01, percpu=False)
self.mem = psutil.virtual_memory()
self.cores_phys = psutil.cpu_count(logical=False)
self.cores_virt = psutil.cpu_count(logical=True)
self.stats = self.read_file("stats")
num_slaves = self.stats.get("num_slaves",0)
for slave_id in range(0, num_slaves):
self.slave_stats.append(self.read_file("slave_stats_%d" % slave_id))
# TODO frontend is using time.time() when we actually need time.clock(), plus perhaps the startup time/date
self.starttime = min([x["start_time"] for x in self.slave_stats])
self.nodes = {}
for metadata in glob.glob(self.workdir + "/metadata/node_*"):
self.load_node(metadata)
self.aggregate()
def cpu_times_percent():
c = statsd.StatsClient('localhost', 8125, prefix='system.cpu')
while True:
value = psutil.cpu_percent(interval=1)
c.gauge('system_wide.percent', value)
cpu_times_percent = psutil.cpu_times_percent(interval=1)
c.gauge('system_wide.times_percent.user', cpu_times_percent.user)
c.gauge('system_wide.times_percent.nice', cpu_times_percent.nice)
c.gauge('system_wide.times_percent.system', cpu_times_percent.system)
c.gauge('system_wide.times_percent.idle', cpu_times_percent.idle)
c.gauge('system_wide.times_percent.iowait', cpu_times_percent.iowait)
c.gauge('system_wide.times_percent.irq', cpu_times_percent.irq)
c.gauge('system_wide.times_percent.softirq', cpu_times_percent.softirq)
c.gauge('system_wide.times_percent.steal', cpu_times_percent.steal)
c.gauge('system_wide.times_percent.guest', cpu_times_percent.guest)
c.gauge('system_wide.times_percent.guest_nice',
cpu_times_percent.guest_nice)
time.sleep(10)
def get_cpu_usage(cls):
""" Discovers CPU usage on this node.
Returns:
A dictionary containing the idle, system and user percentages.
"""
cpu_stats = psutil.cpu_times_percent(percpu=False)
cpu_stats_dict = {
StatsKeys.CPU: {
StatsKeys.IDLE: cpu_stats.idle,
StatsKeys.SYSTEM: cpu_stats.system,
StatsKeys.USER: cpu_stats.user,
StatsKeys.COUNT: len(psutil.cpu_times(percpu=True))
}
}
logger.debug("CPU stats: {}".format(cpu_stats_dict))
return cpu_stats_dict
def cpu_times(self,
per_cpu=False,
percent=False) -> Union[CpuTimesResponse, CpuResponseList]:
"""
Get the CPU times stats.
:param per_cpu: Get per-CPU stats (default: False).
:param percent: Get the stats in percentage (default: False).
:return: :class:`platypush.message.response.system.CpuTimesResponse`
"""
import psutil
times = psutil.cpu_times_percent(percpu=per_cpu) if percent else \
psutil.cpu_times(percpu=per_cpu)
if per_cpu:
return CpuResponseList([
CpuTimesResponse(
user=t.user,
nice=t.nice,
system=t.system,
idle=t.idle,
iowait=t.iowait,
irq=t.irq,
softirq=t.softirq,
steal=t.steal,
guest=t.guest,
guest_nice=t.guest_nice,
) for t in times
])
return CpuTimesResponse(
user=times.user,
nice=times.nice,
system=times.system,
idle=times.idle,
iowait=times.iowait,
irq=times.irq,
softirq=times.softirq,
steal=times.steal,
guest=times.guest,
guest_nice=times.guest_nice,
)
def process_details(pid, py):
# print('in process_details N', os.getpid())
mem = py.memory_info()._asdict()
swap_memory = psutil.swap_memory()._asdict()
total_memory = float((swap_memory['total'] / (2 ** 30)))
used_vms_gib = mem['vms'] / 2 ** 30
cpu_percent = psutil.cpu_times_percent(interval=0.4, percpu=False)._asdict()
values = [mem['rss'] / 2 ** 10, mem['vms'] / 2 ** 10, mem['num_page_faults']]
values1 = [total_memory, used_vms_gib]
cpu_values = [cpu_percent['user'], cpu_percent['idle'],
cpu_percent['system'] + cpu_percent['interrupt'] + cpu_percent['dpc']]
file_size = [os.path.getsize((__file__)), psutil.disk_usage('C:').total]
result = {
f"Process ID: {pid}, RSS: {mem['rss']}, Virtual Memory: {mem['vms']}, Page Faults:{mem['num_page_faults']} "
f"CPU %: {cpu_percent['user']} Memory usage: {round(used_vms_gib, 4)} GiB out of {round(swap_memory['total'] / (2 ** 30), 4)} GiB, file size {file_size[0]} Bytes"}
print(f"Naive Implementation: {result}")
def main():
arg_qty = len(sys.argv) - 1
if (arg_qty != 1):
print("Please provide 1 mandatory argument\n")
use_help()
else:
stat_type = str(sys.argv[1])
if (stat_type == "cpu"):
cpu_stats = psutil.cpu_times_percent(interval=1, percpu=False)
print_cpu_stats(cpu_stats)
elif (stat_type == "mem"):
mem_virt = psutil.virtual_memory()
mem_swap = psutil.swap_memory()
print_mem_stats(mem_virt, mem_swap)
else:
print("Wrong argument\n")
use_help()
def echo_socket(ws):
print "connect"
while True:
try:
message = json.loads(ws.receive())
except:
print "json fail"
print "incoming!: ", message
if message.get("event", "") == "heartbeat":
cpu = psutil.cpu_times_percent(interval=1)
ram = psutil.virtual_memory().percent
data = {'cpu': cpu.user + cpu.system, 'ram': ram}
s = []
for service in services:
s.append({'name': service['service'], 'pid': 0})
data['services'] = s
ws.send(json.dumps({'event': "heartbeat", 'data': data}))
def render_GET(self, request):
# self.log_call(request)
import psutil
section = request.postpath and request.postpath.pop() or None
if not section:
data = {
'platform': platform.platform(),
'machine': platform.machine(),
'name': platform.node(),
'system': platform.system(),
'version': platform.version(),
'boot_time': psutil.boot_time()
}
elif section == 'cpu':
cpu_times_percent = psutil.cpu_times_percent()
data = {
'total': cpu_times_percent.user + cpu_times_percent.system,
'system': cpu_times_percent.system,
'user': cpu_times_percent.user,
'idle': cpu_times_percent.idle,
# 'total_per_cpu': psutil.cpu_percent(percpu=True),
}
elif section == 'memory':
vmem = psutil.virtual_memory()
data = {
'total': vmem.total,
'available': vmem.available,
'percent': vmem.percent,
'used': vmem.used,
'free': vmem.free,
}
elif section == 'disk':
disk = psutil.disk_usage(settings.PROJECT_ROOT)
data = {
'total': disk.total,
'used': disk.used,
'free': disk.free,
'percent': disk.percent,
}
else:
data = {}
self.write_headers(request)
return json.dumps(data)
def check(self, instance):
usage = psutil.cpu_times_percent(percpu=True)
tags = instance.get('tags', [])
for core_idx in range(len(usage)):
metric_tags = tags + ['core:{}'.format(core_idx)]
core_usage = usage[core_idx]
for attr in self.PSUTIL_USAGE_ATTRS:
try:
value = getattr(core_usage, attr)
self.gauge("system.cpu.{}".format(attr),
value,
tags=metric_tags)
except AttributeError:
if self.first_run:
self.log.debug(
'CPU usage attribute %s not available on this platform',
attr)
self.first_run = False
def cpu_info():
payload = []
times = psutil.cpu_times_percent(percpu=True, interval=1)
system, user, nice, idle = 0.0, 0.0, 0.0, 0.0
for i, cpu in enumerate(times):
system += cpu.system
user += cpu.user
nice += cpu.nice
idle += cpu.idle
payload.append(create_cpu_payload(f"core{i}", cpu))
num_cpu = float(len(times))
averages = Times(round(system / num_cpu, 1), round(user / num_cpu, 1),
round(nice / num_cpu, 1), round(idle / num_cpu, 1))
payload.append(create_cpu_payload('cpu', averages))
send_data_to_influx(payload)
def cpu_times_percent():
c = statsd.StatsClient(STATSD_HOST, 8125, prefix=PREFIX + 'system.cpu')
while True:
value = psutil.cpu_percent(interval=1)
c.gauge('system_wide.percent', value)
cpu_t_percent = psutil.cpu_times_percent(interval=1)
c.gauge('system_wide.times_percent.user', cpu_t_percent.user)
c.gauge('system_wide.times_percent.nice', cpu_t_percent.nice)
c.gauge('system_wide.times_percent.system', cpu_t_percent.system)
c.gauge('system_wide.times_percent.idle', cpu_t_percent.idle)
c.gauge('system_wide.times_percent.iowait', cpu_t_percent.iowait)
c.gauge('system_wide.times_percent.irq', cpu_t_percent.irq)
c.gauge('system_wide.times_percent.softirq', cpu_t_percent.softirq)
c.gauge('system_wide.times_percent.steal', cpu_t_percent.steal)
c.gauge('system_wide.times_percent.guest', cpu_t_percent.guest)
c.gauge('system_wide.times_percent.guest_nice',
cpu_t_percent.guest_nice)
time.sleep(GRANULARITY)
def _collect_and_write(self,
process,
writer,
ts=None,
iostat=None,
netstat=None):
import psutil
if ts is None:
ts = time.time()
cpu_percent = process.get_cpu_percent()
cpu_times = process.get_cpu_times()
mem_info = process.get_memory_info()
data = [
int(ts), process.pid, process.name, cpu_percent, cpu_times.user,
cpu_times.system,
process.get_memory_percent(), mem_info.rss, mem_info.vms
]
box_data = None
if iostat and netstat:
box_cpu = psutil.cpu_times_percent()
io = psutil.disk_io_counters()
netio = psutil.net_io_counters()
box_mem = psutil.phymem_usage()
box_data = [
box_cpu.user, box_cpu.system, box_cpu.idle,
io.read_bytes - iostat.read_bytes,
io.write_bytes - iostat.write_bytes,
netio.bytes_recv - netstat.bytes_recv,
netio.bytes_sent - netstat.bytes_sent,
box_mem.used, box_mem.free,
(psutil.used_phymem() - psutil.cached_phymem()), box_mem.total
]
else:
box_data = [0, 0, 0, 0, 0, 0, 0, 0, 0]
data.extend(box_data)
# write data
print >> writer, "\t".join([str(s) for s in data])
# process children
for child in process.get_children():
self._collect_and_write(child, writer, ts=ts)
pass
def update_device_info():
global drive_usage
global cpu_usage
global ram_usage
global swap_usage
global device_temp
# Get drive info
try:
# Get throttled info (raspi only)
reload_throttled_data()
# Get drive actual usage
#results = subprocess.check_output(["du","-sh","/mnt/hdd/mynode/"])
#drive_usage = results.split()[0]
# Get drive percent usage
results = subprocess.check_output(
"df -h /mnt/hdd | grep /dev | awk '{print $5}'", shell=True)
drive_usage = results
# Get RAM usage
ram_info = psutil.virtual_memory()
ram_usage = "{}%".format(ram_info.percent)
# Get Swap Usage
swap_info = psutil.swap_memory()
swap_usage = "{}%".format(swap_info.percent)
# Get CPU usage
#cpu_usage = "{}%".format(psutil.cpu_percent(interval=30.0))
cpu_info = psutil.cpu_times_percent(interval=30.0, percpu=False)
cpu_usage = "{}%".format(100.0 - cpu_info.idle)
# Get device temp
results = subprocess.check_output(
"cat /sys/class/thermal/thermal_zone0/temp", shell=True)
device_temp = int(results) / 1000
except Exception as e:
print("CAUGHT update_device_info EXCEPTION: " + str(e))
return
def m_agent():
#payload = []
_rd = redis.StrictRedis(host=YOUHOSTIP, port=6379, password='', db=0)
cpu_status = psutil.cpu_times_percent(interval=cpu_interval)
mem_status = psutil.virtual_memory()
net_addrs_status = psutil.net_if_addrs()
lstart = str(net_addrs_status).find('192.168.')
lend = str(net_addrs_status)[lstart:].find('\', netmask')
datadict = {
"Host": str(net_addrs_status)[lstart:lstart + lend],
"Mem_total": round(mem_status.total / 1024 / 1024 / 1024, 1),
"ts": int(time.time()),
"CPU_up": round(100 - cpu_status.idle, 1),
"Mem_up": mem_status.percent
}
_rd.hmset(endpoint, datadict)
_rd.expire(endpoint, refresh_interval)
def poll_system(self):
cputimes = psutil.cpu_times_percent(percpu=True)
for i, ct in enumerate(cputimes):
self.cpu_data[i].append(ct)
if len(self.cpu_data[i]) > self.max_history:
self.cpu_data[i] = self.cpu_data[i][-self.max_history:]
self.cpu_pct.append(int(psutil.cpu_percent()))
if len(self.cpu_pct) > self.max_history:
self.cpu_pct = self.cpu_pct[-self.max_history:]
vm = psutil.virtual_memory()
self.mem_pct.append(vm.used / vm.total)
if len(self.mem_pct) > self.max_history:
self.mem_pct = self.mem_pct[-self.max_history:]
self.net_conns.append(len(psutil.net_connections()))
if len(self.net_conns) > self.max_history:
self.net_conns = self.net_conns[-self.max_history:]
def get_host_stats(key):
return {
'key': key,
'type': 'host',
'payload': {
'platform': platform.platform(),
'hostname': platform.node(),
'machine': platform.machine(),
'version': platform.version(),
'cores': psutil.cpu_count(),
'cpu_stats': psutil.cpu_percent(interval=1, percpu=True),
'usage': psutil.cpu_times_percent().user,
'memory_total': psutil.virtual_memory().total,
'memory_used': psutil.virtual_memory().used,
'disk_total': psutil.disk_usage('/').total,
'disk_free': psutil.disk_usage('/').used,
'timestamp': datetime.datetime.now().isoformat(),
'processes': len(psutil.pids())
}
}
def refresh(self, system_info: SystemInfo) -> SystemInfo:
system_info.cpu_usage.cores = psutil.cpu_percent(percpu=True)
cpu_times_percent = psutil.cpu_times_percent()
system_info.cpu_usage.user = cpu_times_percent.user
system_info.cpu_usage.nice = cpu_times_percent.nice
system_info.cpu_usage.system = cpu_times_percent.system
system_info.cpu_usage.io_wait = cpu_times_percent.iowait
system_info.cpu_usage.irq = cpu_times_percent.irq
system_info.cpu_usage.soft_irq = cpu_times_percent.softirq
system_info.cpu_usage.steal = cpu_times_percent.steal
system_info.cpu_usage.guest = cpu_times_percent.guest
system_info.cpu_usage.guest_nice = cpu_times_percent.guest_nice
system_info.load_avg.load_avg_1, system_info.load_avg.load_avg_5, system_info.load_avg.load_avg_15 \
= psutil.getloadavg()
system_info.load_avg.cpu_count = psutil.cpu_count()
virtual_memory = psutil.virtual_memory()
system_info.mem_usage.total = virtual_memory.total
system_info.mem_usage.available = virtual_memory.available
system_info.mem_usage.percent = virtual_memory.percent
return system_info
def cpu_info():
logical_core_num = psutil.cpu_count()
physical_core_num = psutil.cpu_count(logical=False)
load_avg = os.getloadavg()
cpu_time_percent = psutil.cpu_times_percent()
else_percent = 0.0
for i in range(5, 10):
else_percent += cpu_time_percent[i]
try:
cpu_freq = psutil.cpu_freq()
except AttributeError:
cpu_freq = None
return render_template('cpu.html',
physical_core_num=physical_core_num,
logical_core_num=logical_core_num,
load_avg=load_avg,
cpu_time_percent=cpu_time_percent,
else_percent=else_percent,
cpu_freq=cpu_freq)
def web_statistics(driver):
# print cpu and memory stats
print(colored("CPU: ", 'blue'))
print(psutil.cpu_times_percent(interval=1, percpu=False))
print(colored("MEMORY: ", 'blue'))
print(psutil.virtual_memory())
""" Use Navigation Timing API to calculate the timings that matter the most """
navigationStart = driver.execute_script("return window.performance.timing.navigationStart")
responseStart = driver.execute_script("return window.performance.timing.responseStart")
domComplete = driver.execute_script("return window.performance.timing.domComplete")
''' Calculate the performance'''
backendPerformance_calc = (responseStart - navigationStart) / 1000
frontendPerformance_calc = (domComplete - responseStart) / 1000
print(colored("TTFB = Time to first byte in seconds: %s", 'green') % backendPerformance_calc)
print(colored("PLT = Page loading time in seconds: %s", 'green') % frontendPerformance_calc)
return (backendPerformance_calc, frontendPerformance_calc)
def cpu_times_percent(host, port, prefix):
prefix = '.'.join([prefix, 'system.cpu'])
c = statsd.StatsClient(host, port, prefix=prefix)
while True:
value = psutil.cpu_percent(interval=1)
c.gauge('system_wide.percent', value)
cpu_times_percent = psutil.cpu_times_percent(interval=1)
c.gauge('system_wide.times_percent.user', cpu_times_percent.user)
c.gauge('system_wide.times_percent.nice', cpu_times_percent.nice)
c.gauge('system_wide.times_percent.system', cpu_times_percent.system)
c.gauge('system_wide.times_percent.idle', cpu_times_percent.idle)
c.gauge('system_wide.times_percent.iowait', cpu_times_percent.iowait)
c.gauge('system_wide.times_percent.irq', cpu_times_percent.irq)
c.gauge('system_wide.times_percent.softirq', cpu_times_percent.softirq)
c.gauge('system_wide.times_percent.steal', cpu_times_percent.steal)
c.gauge('system_wide.times_percent.guest', cpu_times_percent.guest)
c.gauge('system_wide.times_percent.guest_nice',
cpu_times_percent.guest_nice)
time.sleep(10)
def check_active_jobs(active_jobs, available_cpus, timeout=1):
# The first thing done when checking jobs is to snapshot the CPU_USAGE
t = time.time()
CPU_USAGE[t] = psutil.cpu_times_percent(percpu=True)
MEMORY[t] = psutil.virtual_memory()
local_finished_jobs = []
for i, job in enumerate(active_jobs):
try:
retcode = job.proc.wait(timeout=timeout)
except TimeoutExpired:
retcode = None
continue
job.state = 1
job.endtime = time.time()
job.runtime = job.endtime - job.starttime
# Close the output file
job.outfile.close()
# Read back the last line of the output file which prints the internal execution time
with open(job.outfile.name, 'r') as _f:
job.exec_time = float(_f.readlines()[-1])
# Set the output file to just the name:
job.outfile = job.outfile.name
# Ensure the process is closed:
job.proc.communicate()
job.proc = None
# Return the CPU to available CPUs:
available_cpus.append(job.used_cpu)
# if the job is finished, move it from one list to the other:
local_finished_jobs.append(active_jobs.pop(i))
return active_jobs, local_finished_jobs
def gather_system_info(self):
disk_partitions = psutil.disk_partitions()
disk_usage = {}
for disk in disk_partitions:
disk_usage[disk.device] = self.to_dict(psutil.disk_usage(disk.mountpoint))
net_io_counters = {}
for name, nic in psutil.net_io_counters(pernic=True).items():
net_io_counters[name] = self.to_dict(nic)
if self.prev_info:
net_io_counters[name]['bytes_sent_sec'] = net_io_counters[name]['bytes_sent'] - self.prev_info['net_io'][name]['bytes_sent']
net_io_counters[name]['bytes_recv_sec'] = net_io_counters[name]['bytes_recv'] - self.prev_info['net_io'][name]['bytes_recv']
net_io_counters[name]['packets_sent_sec'] = net_io_counters[name]['packets_sent'] - self.prev_info['net_io'][name]['packets_sent']
net_io_counters[name]['packets_recv_sec'] = net_io_counters[name]['packets_recv'] - self.prev_info['net_io'][name]['packets_recv']
else:
net_io_counters[name]['bytes_sent_sec'] = 0
net_io_counters[name]['bytes_recv_sec'] = 0
net_io_counters[name]['packets_sent_sec'] = 0
net_io_counters[name]['packets_recv_sec'] = 0
info = {
'cpu_count': psutil.cpu_count(),
'cpu_count_physical': psutil.cpu_count(logical=False),
'cpu_percent': self.to_dict(psutil.cpu_percent(percpu=True)),
'cpu_times': self.to_dict(psutil.cpu_times()),
'cpu_times_percent': self.to_dict(psutil.cpu_times_percent()),
'memory_virtual': self.to_dict(psutil.virtual_memory()),
'memory_swap': self.to_dict(psutil.swap_memory()),
'disk_partitions': self.to_dict(disk_partitions),
'disk_usage': disk_usage,
'net_io': net_io_counters,
'users': self.to_dict(psutil.users()),
'boot_time': psutil.boot_time(),
'hostname': socket.gethostname(),
}
self.prev_info = info
return info
def _publish_stats(self):
"""
Publish the platform statistics to the bus.
"""
topic = LOGGER(subtopic="platform/status/cpu")
points = {}
for k, v in psutil.cpu_times_percent().__dict__.items():
points['times_percent/' + k] = {'Readings': v, 'Units': 'double'}
points['percent'] = {
'Readings': psutil.cpu_percent(),
'Units': 'double'
}
try:
self.vip.pubsub.publish('pubsub', topic.format(), message=points)
except Exception as e:
_log.warn("Failed to publish to topic {}".format(topic.format()))
def os_stats(update, context):
logger.info('command: [os_stats] started')
cpu = psutil.cpu_times_percent(interval=0.5)
memory = psutil.virtual_memory()
network_io = psutil.net_io_counters()
time.sleep(1)
network_io_new = psutil.net_io_counters()
net_send = network_io_new.bytes_sent - network_io.bytes_sent
net_recv = network_io_new.bytes_recv - network_io.bytes_recv
msg = SERVER_STATS_RESPONSE.format(os_name=platform.platform(),
user=cpu.user,
system=cpu.system,
idle=cpu.idle,
total=memory.total / 1024. / 1024.,
used=memory.used / 1024. / 1024.,
sent=net_send / 1024.,
recv=net_recv / 1024.)
context.bot.send_message(chat_id=update.message.chat_id,
text=msg,
parse_mode='markdown')
logger.info('command: [os_stats] finished')
