def __set_bases(self): """ Calculate base stats for I/O at start of the node. Used to calculate difference to get per/s stats. """ psutil.cpu_percent() psutil.cpu_percent(percpu=True) for interface in psutil.net_io_counters(True): netint = psutil.net_io_counters(True)[interface] total_bytes = netint.bytes_recv + netint.bytes_sent total_packages = netint.packets_sent + netint.packets_recv self.__bandwidth_base[interface] = total_bytes self.__msg_freq_base[interface] = total_packages dev_names = [] for disk in psutil.disk_partitions(): if all(['cdrom' not in disk.opts, 'sr' not in disk.device]): dev_names.append(disk.device) for key in psutil.disk_io_counters(True): if key in dev_names: disk = psutil.disk_io_counters(True)[key] self.__disk_read_base[key] = disk.read_bytes self.__disk_write_base[key] = disk.write_bytes
def api_net_per_io(interval=1): net_io_before = psutil.net_io_counters(pernic=True) sleep(interval) net_io_after = psutil.net_io_counters(pernic=True) nics = list() for nic_name in net_io_after: nic_after = net_io_after[nic_name] nic_before = net_io_before[nic_name] bytes_sent_per = nic_after.bytes_sent - nic_before.bytes_sent bytes_recv_per = nic_after.bytes_recv - nic_before.bytes_recv package_sent_per = nic_after.packets_sent - nic_before.packets_sent package_recv_per = nic_after.packets_recv - nic_before.packets_recv nics.append({ nic_name: { 'bytes_recv': bytes_recv_per / interval, 'bytes_sent': bytes_sent_per / interval, 'package_sent': int(package_sent_per / interval), 'package_recv': int(package_recv_per / interval), } }) return jsonify({ 'status': True, 'data': nics })
def Traccia_e_Invio_TS(): cpu_pc = psutil.cpu_percent()#variabile percentuale cpu occupata mem_usata = psutil.virtual_memory().percent #variabile memoria usata pacchetti_inv = psutil.net_io_counters().packets_sent #variabile pacchetti inviati pacchetti_ric = psutil.net_io_counters().packets_recv #variabile pacchetti ricevuti #invio al server tramite la api key personale e riempio i vari campi params = urllib.urlencode ({'field1': cpu_pc, 'field2': mem_usata, 'field3': pacchetti_inv,'field4':pacchetti_ric,'key':'7BNU1GRMMFADSQ9H'}) headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"} conn = httplib.HTTPConnection("api.thingspeak.com:80") #stampo nel terminale i valori e lo stato della risposta try: print (bcolors.BOLD+bcolors.WARNING+"Monitoraggio uso cpu e memoria libera della macchina virtuale " +(socket.gethostname()))+bcolors.ENDC+"\n"#nome della macchina --> modifica conn.request("POST", "/update", params, headers) response = conn.getresponse() print bcolors.BOLD+bcolors.OKBLUE+"Cpu occupata: "+bcolors.ENDC,cpu_pc, "%"+"\n" print bcolors.BOLD+bcolors.OKBLUE+"Memoria virtuale usata: "+bcolors.ENDC,mem_usata,"%"+"\n" print bcolors.BOLD+bcolors.OKBLUE+"Numero pacchetti inviati: "+bcolors.ENDC,pacchetti_inv,"\n" print bcolors.BOLD+bcolors.OKBLUE+"Numero pacchetti ricevuti: "+bcolors.ENDC,pacchetti_ric,"\n" print bcolors.BOLD+bcolors.OKBLUE+"Timestamp: "+bcolors.ENDC,strftime("%a, %d %b %Y %H:%M:%S", localtime()),"\n" print bcolors.BOLD+bcolors.OKBLUE+"Risposta del server: "+bcolors.ENDC,response.status, response.reason,"\n" data = response.read() conn.close() if response.reason==("OK"): print (bcolors.BOLD+bcolors.OKGREEN+"La richiesta è andata a buon fine!"+bcolors.ENDC),"\n\n" except: print bcolors.BOLD+bcolors.FAIL+"Connessione fallita, riprovare." +bcolors.ENDC
def __get_resource_stats(self): """ Get network and disk counters :return: tuple """ if not self.__counters_ts: self.__disk_counters = psutil.disk_io_counters() self.__net_counters = psutil.net_io_counters() self.__counters_ts = datetime.datetime.now() time.sleep(0.2) # small enough for human, big enough for machine now = datetime.datetime.now() interval = (now - self.__counters_ts).total_seconds() net = psutil.net_io_counters() tx_bytes = (net.bytes_sent - self.__net_counters.bytes_sent) / interval rx_bytes = (net.bytes_recv - self.__net_counters.bytes_recv) / interval self.__net_counters = net disk = psutil.disk_io_counters() dru = (disk.read_bytes - self.__disk_counters.read_bytes) / interval dwu = (disk.write_bytes - self.__disk_counters.write_bytes) / interval self.__disk_counters = disk self.__counters_ts = now return rx_bytes, tx_bytes, dru, dwu
def test(): log_info = {} total_start = time.time() interfaces = ['eth0'] bytes_recv_start = 0 bytes_sent_start = 0 for interface in interfaces: bytes_recv_start += psutil.net_io_counters(pernic=True)[interface].bytes_recv bytes_sent_start += psutil.net_io_counters(pernic=True)[interface].bytes_sent # test common urls print bytes_recv_start print bytes_sent_start for m in NetworkMonitor.Common_urls: log_info[m] = {} try: start = time.time() httpcode = 0 httpcode = NetworkMonitor.Opener.open(m).getcode() except urllib2.URLError,e: print 'here' print 'Exception:' print e #urlopen error timed out pass finally:
def network(): ip = get_my_ip() text = ip + '\n' text = text + '==================\n' total_network = psutil.net_io_counters() total_bytes_sent = '%.2f M' % (total_network[0]/1024.0/1024.0) total_bytes_recv = '%.2f M' % (total_network[1]/1024.0/1024.0) text = text + u"★总发送流量:%s 总接收流量:%s\n"%(total_bytes_sent,total_bytes_recv) text = text + u"★总发送数据包数:%s 总接收数据包数:%s\n"%(total_network[2],total_network[3]) network = psutil.net_io_counters(pernic=True) network_keys = network.keys() print for i in range(len(network_keys)): this_network = network.get(network_keys[i]) this_network_name = (network_keys[i]).decode('gbk') bytes_sent = this_network[0] bytes_recv = this_network[1] packets_sent = this_network[2] packets_recv = this_network[3] this_bytes_sent = '%.2f M' % (bytes_sent/1024.0/1024.0) this_bytes_recv = '%.2f M' % (bytes_recv/1024.0/1024.0) this_packets_sent = '%d' % (packets_sent) this_packets_recv = '%d' % (packets_recv) text = text + '==================\n' text = text +u'网卡:'+ this_network_name +'\n' text = text + u"发送流量:%s 接收流量:%s\n"%(this_bytes_sent,this_bytes_recv) text = text + u"发送数据包数:%s 接收数据包数:%s\n"%(this_packets_sent,this_packets_recv) sysinfo.label2.setText(sysinfo.tr(text))
def collect_network(self, stat): n = psutil.net_io_counters(pernic=False) stat['psutil_net'] = { 'bytes_sent':n.bytes_sent, 'bytes_recv':n.bytes_recv, 'packets_sent':n.packets_sent, 'packets_recv':n.packets_recv, 'errin':n.errin, 'errout':n.errout, 'dropin':n.dropin, 'dropout':n.dropout, } ns = psutil.net_io_counters(pernic=True) for k, n in ns.items(): if k == 'lo': # skip loopback continue stat['psutil_net-%s' % k] = { 'bytes_sent':n.bytes_sent, 'bytes_recv':n.bytes_recv, 'packets_sent':n.packets_sent, 'packets_recv':n.packets_recv, 'errin':n.errin, 'errout':n.errout, 'dropin':n.dropin, 'dropout':n.dropout, }
def Sysinfo(): Hostname = platform.node() Sys_version = platform.platform() Boot_Start = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(psutil.boot_time())) time.sleep(0.5) Cpu_usage = psutil.cpu_percent() RAM = int(psutil.virtual_memory().total/(1027*1024)) RAM_percent = psutil.virtual_memory().percent Swap = int(psutil.swap_memory().total/(1027*1024)) Swap_percent = psutil.swap_memory().percent Net_sent = psutil.net_io_counters().bytes_sent Net_recv = psutil.net_io_counters().bytes_recv Net_spkg = psutil.net_io_counters().packets_sent Net_rpkg = psutil.net_io_counters().packets_recv BFH = r'%' print " \033[1;32m主机名: %s\033[1;m" % Hostname print " \033[1;32m系统版本: %s\033[1;m" % Sys_version print " \033[1;32m开机时间:%s\033[1;m" % Boot_Start print " \033[1;32m当前CPU使用率:%s%s\033[1;m" % (Cpu_usage,BFH) print " \033[1;32m物理内存:%dM\t使用率:%s%s\033[1;m" % (RAM,RAM_percent,BFH) print " \033[1;32mSwap内存:%dM\t使用率:%s%s\033[1;m" % (Swap,Swap_percent,BFH) print " \033[1;32m发送:%d Byte\t发送包数:%d个\033[1;m" % (Net_sent,Net_spkg) print " \033[1;32m接收:%d Byte\t接收包数:%d个\033[1;m" % (Net_recv,Net_rpkg) for i in psutil.disk_partitions(): print " \033[1;32m盘符: %s 挂载点: %s 使用率: %s%s\033[1;m" % (i[0],i[1],psutil.disk_usage(i[1])[3],BFH) for key in psutil.net_if_addrs().keys(): print " \033[1;32m网卡: %s IP: %s\033[1;m" % (key,psutil.net_if_addrs()[key][0][1])
def get_net(self): allnetio = psutil.net_io_counters() # 获取网络总的IO信息 onenetio = psutil.net_io_counters(pernic=True) # 输出每个网络接口的IO信息 res = dict( allnetio=dict( bytes_sent=allnetio.bytes_sent, # 发送字节数 bytes_recv=allnetio.bytes_recv, # 接受字节数 packets_sent=allnetio.packets_sent, # 发送数据包数 packets_recv=allnetio.packets_recv, # 接受数据包数 errin=allnetio.errin, errout=allnetio.errout, dropin=allnetio.dropin, dropout=allnetio.dropout ), onenetio=[ dict( name=v[0], bytes_sent=v[1].bytes_sent, # 发送字节数 bytes_recv=v[1].bytes_recv, # 接受字节数 packets_sent=v[1].packets_sent, # 发送数据包数 packets_recv=v[1].packets_recv, # 接受数据包数 errin=v[1].errin, errout=v[1].errout, dropin=v[1].dropin, dropout=v[1].dropout ) for v in onenetio.iteritems() ] )
def NetworkUsageLinux(): theArray0 = [] theArray1 = [] en0 = psutil.net_io_counters(pernic=True).get('eth0') en1 = psutil.net_io_counters(pernic=True).get('wlan0') en0Dict = { 'mb_sent' :en0[0]/1024/1024, 'mb_recv' :en0[1]/1024/1024, 'packets_sent' :en0[2], 'packets_recv' :en0[3], 'errin' :en0[4], 'errout' :en0[5], 'dropin' :en0[6], 'dropout' :en0[7] } en1Dict = { 'mb_sent' :en1[0]/1024/1024, 'mb_recv' :en1[1]/1024/1024, 'packets_sent' :en1[2], 'packets_recv' :en1[3], 'errin' :en1[4], 'errout' :en1[5], 'dropin' :en1[6], 'dropout' :en1[7] } return en0Dict, en1Dict
def poll(interval): tot_before = psutil.net_io_counters() pnic_before = psutil.net_io_counters(pernic=True) time.sleep(interval) tot_after = psutil.net_io_counters() pnic_after = psutil.net_io_counters(pernic=True) return (tot_before, tot_after, pnic_before, pnic_after)
def netio_info(self): pernic_counters_before = psutil.net_io_counters(pernic=True) time.sleep(1) pernic_counters_after = psutil.net_io_counters(pernic=True) net_list = [ ] for iface in pernic_counters_before: after = pernic_counters_after[iface] before = pernic_counters_before[iface] net_list.append({ 'name': iface, 'total': { 'sent': { 'human': sizeof_fmt(after.bytes_sent), 'bytes': after.bytes_sent }, 'recv': { 'human': sizeof_fmt(after.bytes_recv), 'bytes': after.bytes_recv } }, 'per-sec': { 'sent': { 'human': sizeof_fmt((after.bytes_sent - before.bytes_sent)), 'bytes': (before.bytes_sent - after.bytes_sent) }, 'recv': { 'human': sizeof_fmt((after.bytes_recv - before.bytes_recv)), 'bytes': (before.bytes_recv - after.bytes_recv) } }, 'name': iface }) return net_list
def Inet_Info(device): rx = [float(psutil.net_io_counters(pernic=True)['eth0'].bytes_recv),float(psutil.net_io_counters(pernic=True)['eth0'].bytes_sent)] time.sleep(1) tx = [float(psutil.net_io_counters(pernic=True)['eth0'].bytes_recv),float(psutil.net_io_counters(pernic=True)['eth0'].bytes_sent)] speed_in = round((tx[0] - rx[0]) / 1024, 2) speed_out = round((tx[1] - rx[1]) /1024, 2) return str(speed_in),str(speed_out)
def test_net_io_counters(self): def check_ntuple(nt): self.assertEqual(nt[0], nt.bytes_sent) self.assertEqual(nt[1], nt.bytes_recv) self.assertEqual(nt[2], nt.packets_sent) self.assertEqual(nt[3], nt.packets_recv) self.assertEqual(nt[4], nt.errin) self.assertEqual(nt[5], nt.errout) self.assertEqual(nt[6], nt.dropin) self.assertEqual(nt[7], nt.dropout) assert nt.bytes_sent >= 0, nt assert nt.bytes_recv >= 0, nt assert nt.packets_sent >= 0, nt assert nt.packets_recv >= 0, nt assert nt.errin >= 0, nt assert nt.errout >= 0, nt assert nt.dropin >= 0, nt assert nt.dropout >= 0, nt ret = psutil.net_io_counters(pernic=False) check_ntuple(ret) ret = psutil.net_io_counters(pernic=True) self.assertNotEqual(ret, []) for key in ret: self.assertTrue(key) self.assertIsInstance(key, str) check_ntuple(ret[key])
def __nic_poll_stat(): """Retrieve raw stats within an interval window.""" pnic_before = psutil.net_io_counters(pernic=True) # sleep some time time.sleep(1) pnic_after = psutil.net_io_counters(pernic=True) return [pnic_before, pnic_after]
def pollForAttacks(): MAX_NET_USAGE = 400000 MAX_ATTACKS = 4 attack = 0 counter = 0 while attack <= MAX_ATTACKS: sleep(4) counter = counter + 1 # Check the cpu usage if cpu_percent(interval = 1) > 70: attack = attack + 1 # Check the net usage neti1 = net_io_counters()[1] neto1 = net_io_counters()[0] sleep(1) neti2 = net_io_counters()[1] neto2 = net_io_counters()[0] # Calculate the bytes per second net = ((neti2+neto2) - (neti1+neto1))/2 print 'neti1 = {0}'.format(neti1) print 'neto1 = {0}'.format(neto1) print 'neti2 = {0}'.format(neti2) print 'neto2 = {0}'.format(neto2) print 'net = {0}'.format(net) if net > MAX_NET_USAGE: attack = attack + 1 if counter > 25: attack = 0 counter = 0
def sysinfo(): boot_start = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(psutil.boot_time())) time.sleep(0.5) cpu_usage = psutil.cpu_percent() ram = int(psutil.virtual_memory().total / (1027 * 1024)) ram_percent = psutil.virtual_memory().percent swap = int(psutil.swap_memory().total / (1027 * 1024)) swap_percent = psutil.swap_memory().percent net_sent = psutil.net_io_counters().bytes_sent net_recv = psutil.net_io_counters().bytes_recv net_spkg = psutil.net_io_counters().packets_sent net_rpkg = psutil.net_io_counters().packets_recv sysinfo_string = "" if __name__ == "__main__": bfh = r'%' print(" \033[1;32m开机时间:%s\033[1;m" % boot_start) print(" \033[1;32m当前CPU使用率:%s%s\033[1;m" % (cpu_usage, bfh)) print(" \033[1;32m物理内存:%dM\t使用率:%s%s\033[1;m" % (ram, ram_percent, bfh)) print(" \033[1;32mSwap内存:%dM\t使用率:%s%s\033[1;m" % (swap, swap_percent, bfh)) print(" \033[1;32m发送:%d Byte\t发送包数:%d个\033[1;m" % (net_sent, net_spkg)) print(" \033[1;32m接收:%d Byte\t接收包数:%d个\033[1;m" % (net_recv, net_rpkg)) for i in psutil.disk_partitions(): print(" \033[1;32m盘符: %s 挂载点: %s 使用率: %s%s\033[1;m" % (i[0], i[1], psutil.disk_usage(i[1])[3], bfh)) sysinfo_string = '开机时间: ' + boot_start + '\n' sysinfo_string += '当前CPU使用率: ' + str(cpu_usage) + '%\n' sysinfo_string += '物理内存: ' + str(ram) + 'M\t使用率: ' + str(ram_percent) + '%\t' sysinfo_string += 'Swap内存: ' + str(swap) + 'M\t使用率: ' + str(swap_percent) + '%\n' return sysinfo_string else: file = open("sysinfo.log", "a") file.write("CPU:%s \tRAM:%s\tnet_recv:%d\tNet_sent:%d\r\n" % (cpu_usage, ram_percent, net_recv, net_sent)) file.flush() file.close()
def getSysInfo(id): # hostInfo=None # if hostAddr: # hostInfo = hostSysInfo(self.hostAddr) global version cpu_percent = psutil.cpu_percent(interval=None) mem_usage = psutil.virtual_memory().percent license_key = os.getenv('license_key') if NETWORK_INTERFACE in psutil.net_if_addrs(): ip = psutil.net_if_addrs()[NETWORK_INTERFACE][0].address mask = psutil.net_if_addrs()[NETWORK_INTERFACE][0].netmask mac = psutil.net_if_addrs()[NETWORK_INTERFACE][getMacAddressIndex()].address ipv6address = getIpv6Address() else: ip = None mask = None mac = None ipv6address = [] bytes_sent = psutil.net_io_counters().bytes_sent bytes_recv = psutil.net_io_counters().bytes_recv bytes_sent_avg = round(float(bytes_sent-lastNetIo["sent"])/HEARTBEAT_INTERVAL/1024,2) if bytes_sent-lastNetIo["sent"] > 0 else 0 #Kbytes/s bytes_recv_avg = round(float(bytes_recv-lastNetIo["recv"])/HEARTBEAT_INTERVAL/1024,2) if bytes_recv-lastNetIo["recv"] > 0 else 0 #Kbytes/s lastNetIo["sent"] = bytes_sent lastNetIo["recv"] = bytes_recv task_processes = getTaskProcessInfo() topTotal,processs = getProgress() probeInfo = dict(cpu = cpu_percent, memory = mem_usage,ipaddress=ip,device_type = 'soft',ipv6address=ipv6address,toptotal=topTotal,topprocess=processs,license_key=license_key,netmask=mask,macaddress=mac,arpNeighbors=arpNeighbors,bytesSent=bytes_sent_avg,bytesRecv=bytes_recv_avg,task_processes=task_processes) result = dict(clientId=id,type="heartbeat",time=time.time(),content=probeInfo) #result['currentVersion'] = gitutil.getCurrentVersion(config.APPLICATION_PATH).__str__() result['currentVersion'] = version return result
def get(self, *args): ans = {} ans.update(self.defaults) ans.update(dict(name=self.env.name, host=self.env.host, ram=psutil.virtual_memory().percent, cpu=psutil.cpu_percent(), sent=psutil.net_io_counters().bytes_sent, recv=psutil.net_io_counters().bytes_recv, disk_usage=list(map(lambda p: (p.mountpoint, psutil.disk_usage(p.mountpoint).percent), psutil.disk_partitions())), states=[], issues=[])) if ans['ram'] > 90: ans['issues'].append('High RAM usage') if ans['cpu'] > 90: ans['issues'].append('High CPU usage') for du in ans['disk_usage']: if du[1] > 90: ans['issues'].append('High HDD usage at ' + du[0]) for callback in HttpMonitor._callbacks: ans['states'].append(callback()) self.set_status(200) self.set_header('Access-Control-Allow-Origin', '*') self.set_header('Access-Control-Expose-Headers', 'Access-Control-Allow-Origin') self.set_header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept') self.set_header('Content-Type', 'application/json') self.write(json.dumps(ans, indent=2)) self.finish()
def networkInfo(): print 'Showing network status (M/s)...' while (True): nwBefore = psutil.net_io_counters() time.sleep(1) nwAfter = psutil.net_io_counters() setValue(float(nwAfter.bytes_recv - nwBefore.bytes_recv)/ float(1000000))
def get_net_iostat(nic=None): if not nic: if 'net_io_counters' in dir(ps): return ps.net_io_counters(pernic=False) return ps.network_io_counters(pernic=False) if 'net_io_counters' in dir(ps): return ps.net_io_counters(pernic=False) return ps.network_io_counters(pernic=True).get(nic)
def update_rrd(): total_in = psutil.net_io_counters()[1] total_out = psutil.net_io_counters()[0] starttime = int(time.time()) update = rrdtool.updatev('/usr/local/src/Flow.rrd','%s:%s:%s') % (str(starttime),str(total_in),str(total_out)) print update
def get_net_state(): tot_before = psutil.net_io_counters() # sleep some time time.sleep(interval) tot_after = psutil.net_io_counters() return {"net_send": bytes2human((tot_after.bytes_sent - tot_before.bytes_sent)/ interval), "net_recv": bytes2human((tot_after.bytes_recv - tot_before.bytes_recv)/ interval)}
def test_net_io_counters_no_nics(self): # Emulate a case where no NICs are installed, see: # https://github.com/giampaolo/psutil/issues/1062 with mock.patch('psutil._psplatform.net_io_counters', return_value={}) as m: self.assertIsNone(psutil.net_io_counters(pernic=False)) self.assertEqual(psutil.net_io_counters(pernic=True), {}) assert m.called
def update(self): """Get the latest system information.""" import psutil if self.type == 'disk_use_percent': self._state = psutil.disk_usage(self.argument).percent elif self.type == 'disk_use': self._state = round(psutil.disk_usage(self.argument).used / 1024**3, 1) elif self.type == 'disk_free': self._state = round(psutil.disk_usage(self.argument).free / 1024**3, 1) elif self.type == 'memory_use_percent': self._state = psutil.virtual_memory().percent elif self.type == 'memory_use': self._state = round((psutil.virtual_memory().total - psutil.virtual_memory().available) / 1024**2, 1) elif self.type == 'memory_free': self._state = round(psutil.virtual_memory().available / 1024**2, 1) elif self.type == 'swap_use_percent': self._state = psutil.swap_memory().percent elif self.type == 'swap_use': self._state = round(psutil.swap_memory().used / 1024**3, 1) elif self.type == 'swap_free': self._state = round(psutil.swap_memory().free / 1024**3, 1) elif self.type == 'processor_use': self._state = round(psutil.cpu_percent(interval=None)) elif self.type == 'process': if any(self.argument in l.name() for l in psutil.process_iter()): self._state = STATE_ON else: self._state = STATE_OFF elif self.type == 'network_out' or self.type == 'network_in': counters = psutil.net_io_counters(pernic=True) if self.argument in counters: counter = counters[self.argument][IO_COUNTER[self.type]] self._state = round(counter / 1024**2, 1) else: self._state = STATE_UNKNOWN elif self.type == 'packets_out' or self.type == 'packets_in': counters = psutil.net_io_counters(pernic=True) if self.argument in counters: self._state = counters[self.argument][IO_COUNTER[self.type]] else: self._state = STATE_UNKNOWN elif self.type == 'ipv4_address' or self.type == 'ipv6_address': addresses = psutil.net_if_addrs() if self.argument in addresses: self._state = addresses[self.argument][IF_ADDRS[self.type]][1] else: self._state = STATE_UNKNOWN elif self.type == 'last_boot': self._state = dt_util.as_local( dt_util.utc_from_timestamp(psutil.boot_time()) ).date().isoformat() elif self.type == 'since_last_boot': self._state = dt_util.utcnow() - dt_util.utc_from_timestamp( psutil.boot_time())
def net_use_now(self, interval=0.2): n = psutil.net_io_counters() old_net = n.bytes_sent + n.bytes_recv time.sleep(interval) n = psutil.net_io_counters() new_net = n.bytes_sent + n.bytes_recv dif_net = new_net - old_net use_rate = dif_net / interval return use_rate
def mode_bars(): while True: cpu = psutil.cpu_percent() mem = psutil.virtual_memory().percent netin = psutil.net_io_counters(pernic=False).bytes_recv / 1024 netout = psutil.net_io_counters(pernic=False).bytes_sent / 1024 frame = render_system_usage_bars(cpu, mem, netin, netout) write_frame(frame) sleep(0.3)
def get_net(self): # 网络流量 nw = ni.gateways()['default'][2][1] current_bytes = psutil.net_io_counters(pernic=True)[nw][1] time.sleep(60) previous, current_bytes = current_bytes, psutil.net_io_counters(pernic=True)[nw][1] # 网络连接数 connections = len(psutil.net_connections()) return connections
def poll(interval): """Retrieve raw stats within an interval window.""" tot_before = psutil.net_io_counters() pnic_before = psutil.net_io_counters(pernic=True) # sleep some time time.sleep(interval) tot_after = psutil.net_io_counters() pnic_after = psutil.net_io_counters(pernic=True) return (tot_before, tot_after, pnic_before, pnic_after)
def get_sys_info(): result = { "cpu_usage": psutil.cpu_percent(), "mem_usage": psutil.virtual_memory().percent, "net_in": psutil.net_io_counters().bytes_recv, "net_out": psutil.net_io_counters().bytes_sent, } return result
--verbose - Enables printed output for the developer. Example usage: python sysmon.py --output=stats.csv --interface=eno1 """) exit(1) info = { 'cpu_load' : 0, 'mem_free' : 0 } info['cpu_load'] = psutil.cpu_percent(interval=0.5) # Grab 0.5 sec worth of sample time info['mem_free'] = psutil.virtual_memory().free # .percent is also a thing info['disk_free'] = psutil.disk_usage(args['partition']).free / (1024.0 ** 3) # Convert to gigabyte packet_info = psutil.net_io_counters(pernic=True)[args['interface']] info['packets_sent'] = packet_info.bytes_sent info['packets_recv'] = packet_info.bytes_recv if args['verbose']: print(json.dumps(info, indent=4)) if args['output']: birth = False if not os.path.isfile(args['output']): birth = True with open(args['output'], 'a') as output: if birth: output.write(','.join(["snapshot_time"]+[str(x[0]) for x in sorted(info.items(), key=lambda kv: kv[0])])+'\n') # Join the JSON struct into a CSV line (Sorted by keys so they stay the same) # Separator str(value) key,val sorting key=[key,val][0] <- aka key and not value
def mon(): global last_info_m_time, last_info_m_usage global last_info_c_time, last_info_c_usage global last_info_n_time, last_info_n_usage global last_info_d_time, last_info_d_usage global format info_time = time.time() # 1.- Check Memory meminfo = psutil.virtual_memory() info_m_usage = meminfo[2] info_delta = math.fabs(info_m_usage - last_info_m_usage) if info_delta >= delta: data = { "type": "memory", "timestamp": info_time, "timedelta": info_time - last_info_m_time, "usagepercent": last_info_m_usage, "usageabsolute": meminfo[0] - meminfo[1] } print_record(format, data) last_info_m_time = info_time last_info_m_usage = info_m_usage # 2.- Check CPU cpuinfo = psutil.cpu_percent() info_c_usage = cpuinfo info_delta = math.fabs(info_c_usage - last_info_c_usage) if info_delta >= delta: info_ncores = multiprocessing.cpu_count() info_cpufreq = 0.0 proc = subprocess.Popen(["cat", "/proc/cpuinfo"], stdout=subprocess.PIPE) out, err = proc.communicate() for line in out.split("\n"): if "cpu MHz" in line: info_cpufreq = info_cpufreq + float(line.split(":")[1]) info_cpufreq = info_cpufreq / info_ncores # CPU freq * time * CPU usage * # cores data = { "type": "compute", "timestamp": info_time, "cpufreq": info_cpufreq, "timedelta": info_time - last_info_c_time, "usagepercent": last_info_c_usage, "usageabsolute": info_cpufreq * (info_time - last_info_c_time) * last_info_c_usage * info_ncores, "ncores": info_ncores } print_record(format, data) last_info_c_time = info_time last_info_c_usage = info_c_usage # 3.- Check Network netinfo = psutil.net_io_counters() info_n_usage = (netinfo.bytes_sent + netinfo.bytes_recv) / (1024 * 1024) info_delta = 100 * math.fabs(info_n_usage - last_info_n_usage) / (last_info_n_usage + 1) if info_delta >= delta: data = { "type": "network", "timestamp": info_time, "timedelta": info_time - last_info_n_time, "usageabsolute": last_info_n_usage } print_record(format, data) last_info_n_time = info_time last_info_n_usage = info_n_usage # 4.- Check Disk diskinfo = psutil.disk_io_counters() info_d_usage = (diskinfo.read_bytes + diskinfo.write_bytes) / (1024 * 1024) info_delta = 100 * math.fabs(info_d_usage - last_info_d_usage) / (last_info_d_usage + 1) if info_delta >= delta: data = { "type": "disk", "timestamp": info_time, "timedelta": info_time - last_info_d_time, "usageabsolute": last_info_d_usage } print_record(format, data) last_info_d_time = info_time last_info_d_usage = info_d_usage # 5.- Set next checking... threading.Timer(rrate, mon).start()
elif _.endswith('sniffer.py'): servers.append([ basename(_)[:-3], Popen([ 'python', _, '--filter', 'not port 9999', '--interfac', 'eth0', '--logs', 'db', '--docker' ]) ]) while True: try: _servers = {} logs.info([ 'system', { 'type': 'network', 'bytes_sent': net_io_counters().bytes_sent, 'bytes_recv': net_io_counters().bytes_recv, 'packets_sent': net_io_counters().packets_sent, 'packets_recv': net_io_counters().packets_recv } ]) for _ in servers: _servers[_[0]] = { 'memory': Process(_[1].pid).memory_percent(), 'cpu': Process(_[1].pid).cpu_percent() } logs.info(['system', _servers]) stdout.flush() except BaseException: pass sleep(20)
import psutil print(psutil.cpu_count()) print(psutil.cpu_count(logical=False)) print(psutil.virtual_memory()) print(psutil.swap_memory()) print(psutil.disk_partitions()) print(psutil.disk_usage('/')) print(psutil.disk_io_counters()) print(psutil.net_io_counters()) print(psutil.net_if_addrs()) print(psutil.net_if_stats()) print(psutil.net_connections()) print(psutil.pids()) p = psutil.Process(4) print(p.name())
def update(self): """Get the latest system information.""" import psutil if self.type == 'disk_use_percent': self._state = psutil.disk_usage(self.argument).percent elif self.type == 'disk_use': self._state = round( psutil.disk_usage(self.argument).used / 1024**3, 1) elif self.type == 'disk_free': self._state = round( psutil.disk_usage(self.argument).free / 1024**3, 1) elif self.type == 'memory_use_percent': self._state = psutil.virtual_memory().percent elif self.type == 'memory_use': virtual_memory = psutil.virtual_memory() self._state = round( (virtual_memory.total - virtual_memory.available) / 1024**2, 1) elif self.type == 'memory_free': self._state = round(psutil.virtual_memory().available / 1024**2, 1) elif self.type == 'swap_use_percent': self._state = psutil.swap_memory().percent elif self.type == 'swap_use': self._state = round(psutil.swap_memory().used / 1024**2, 1) elif self.type == 'swap_free': self._state = round(psutil.swap_memory().free / 1024**2, 1) elif self.type == 'processor_use': self._state = round(psutil.cpu_percent(interval=None)) elif self.type == 'process': for proc in psutil.process_iter(): try: if self.argument == proc.name(): self._state = STATE_ON return except psutil.NoSuchProcess as err: _LOGGER.warning( "Failed to load process with id: %s, old name: %s", err.pid, err.name) self._state = STATE_OFF elif self.type == 'network_out' or self.type == 'network_in': counters = psutil.net_io_counters(pernic=True) if self.argument in counters: counter = counters[self.argument][IO_COUNTER[self.type]] self._state = round(counter / 1024**2, 1) else: self._state = None elif self.type == 'packets_out' or self.type == 'packets_in': counters = psutil.net_io_counters(pernic=True) if self.argument in counters: self._state = counters[self.argument][IO_COUNTER[self.type]] else: self._state = None elif self.type == 'ipv4_address' or self.type == 'ipv6_address': addresses = psutil.net_if_addrs() if self.argument in addresses: for addr in addresses[self.argument]: if addr.family == IF_ADDRS_FAMILY[self.type]: self._state = addr.address else: self._state = None elif self.type == 'last_boot': self._state = dt_util.as_local( dt_util.utc_from_timestamp(psutil.boot_time())).isoformat() elif self.type == 'load_1m': self._state = os.getloadavg()[0] elif self.type == 'load_5m': self._state = os.getloadavg()[1] elif self.type == 'load_15m': self._state = os.getloadavg()[2]
def monitor_host(profile): host_stats = {} timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S') print "host monitor starts: " + str(timestamp) first = False if host_info["time"] == 0.0: first = True # cpu_percent host_stats["cpu_percent"] = psutil.cpu_percent(interval=0.5) tm = time.time() # cpu_times user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice = psutil.cpu_times( ) if first == False: host_stats["user_time"] = str( (user - host_info["user_time"]) / (tm - host_info["time"])) host_stats["nice_time"] = str( (nice - host_info["nice_time"]) / (tm - host_info["time"])) host_stats["system_time"] = str( (system - host_info["system_time"]) / (tm - host_info["time"])) host_stats["idle_time"] = str( (idle - host_info["idle_time"]) / (tm - host_info["time"])) host_stats["iowait_time"] = str( (iowait - host_info["iowait_time"]) / (tm - host_info["time"])) host_stats["irq_time"] = str( (irq - host_info["irq_time"]) / (tm - host_info["time"])) host_stats["softirq_time"] = str( (softirq - host_info["softirq_time"]) / (tm - host_info["time"])) host_stats["steal_time"] = str( (steal - host_info["steal_time"]) / (tm - host_info["time"])) host_stats["guest_time"] = str( (guest - host_info["guest_time"]) / (tm - host_info["time"])) host_stats["guest_nice_time"] = str( (guest_nice - host_info["guest_nice_time"]) / (tm - host_info["time"])) host_info["user_time"] = user host_info["nice_time"] = nice host_info["system_time"] = system host_info["idle_time"] = idle host_info["iowait_time"] = iowait host_info["irq_time"] = irq host_info["softirq_time"] = softirq host_info["steal_time"] = steal host_info["guest_time"] = guest host_info["guest_nice_time"] = guest_nice # mem_percent, total_mem, used_mem, available_mem total_mem, available_mem, mem_percent, used_mem, free_mem, \ active_mem, inactive_mem, buffers_mem, cached_mem = psutil.virtual_memory() host_stats["mem_percent"] = str(mem_percent) host_stats["total_mem"] = str(total_mem / (1024. * 1024.)) host_stats["available_mem"] = str(available_mem / (1024. * 1024.)) host_stats["used_mem"] = str(used_mem / (1024. * 1024.)) host_stats["free_mem"] = str(free_mem / (1024. * 1024.)) host_stats["active_mem"] = str(active_mem / (1024. * 1024.)) host_stats["inactive_mem"] = str(inactive_mem / (1024. * 1024.)) host_stats["buffers_mem"] = str(buffers_mem / (1024. * 1024.)) host_stats["cached_mem"] = str(cached_mem / (1024. * 1024.)) read_count, write_count, read_bytes, write_bytes, read_time, write_time = psutil.disk_io_counters( ) if first == False: host_stats["read_count"] = str( (read_count * 1.0 - host_info["read_count"]) / (tm - host_info["time"])) host_stats["read_bytes"] = str( (read_bytes * 1.0 - host_info["read_bytes"]) / (tm - host_info["time"])) host_stats["write_count"] = str( (write_count * 1.0 - host_info["write_count"]) / (tm - host_info["time"])) host_stats["write_bytes"] = str( (write_bytes * 1.0 - host_info["write_bytes"]) / (tm - host_info["time"])) host_info["read_count"] = read_count * 1.0 host_info["read_bytes"] = read_bytes * 1.0 host_info["write_count"] = write_count * 1.0 host_info["write_bytes"] = write_bytes * 1.0 if first == False: database.host_info(timestamp, host_stats) interfaces = psutil.net_io_counters(pernic=True) for interface in interfaces: host_nets = {} if interface == profile["inbound"] or interface == profile["outbound"]: bytes_sent, bytes_recv, packets_sent, packets_recv, \ errin, errout, dropin, dropout = interfaces[interface] if interface in host_nic: host_nets["interface"] = interface host_nets["packets_recv"] = str(((packets_recv - host_nic[interface]["packets_recv"]) * 1.0) \ / (tm - host_info["time"])) host_nets["bytes_recv"] = str(((bytes_recv - host_nic[interface]["bytes_recv"]) * 1.0) \ / (tm - host_info["time"])) host_nets["packets_sent"] = str(((packets_sent - host_nic[interface]["packets_sent"]) * 1.0) \ / (tm - host_info["time"])) host_nets["bytes_sent"] = str(((bytes_sent - host_nic[interface]["bytes_sent"]) * 1.0) \ / (tm - host_info["time"])) else: host_nic[interface] = {} host_nic[interface]["packets_recv"] = packets_recv host_nic[interface]["bytes_recv"] = bytes_recv host_nic[interface]["packets_sent"] = packets_sent host_nic[interface]["bytes_sent"] = bytes_sent if "interface" in host_nets: database.host_net(timestamp, host_nets) elif "vnet" in interface: bytes_sent, bytes_recv, packets_sent, packets_recv, \ errin, errout, dropin, dropout = interfaces[interface] if interface in host_nic: host_nets["interface"] = interface host_nets["packets_recv"] = str(((packets_recv - host_nic[interface]["packets_recv"]) * 1.0) \ / (tm - host_info["time"])) host_nets["bytes_recv"] = str(((bytes_recv - host_nic[interface]["bytes_recv"]) * 1.0) \ / (tm - host_info["time"])) host_nets["packets_sent"] = str(((packets_sent - host_nic[interface]["packets_sent"]) * 1.0) \ / (tm - host_info["time"])) host_nets["bytes_sent"] = str(((bytes_sent - host_nic[interface]["bytes_sent"]) * 1.0) \ / (tm - host_info["time"])) else: host_nic[interface] = {} host_nic[interface]["packets_recv"] = packets_recv host_nic[interface]["bytes_recv"] = bytes_recv host_nic[interface]["packets_sent"] = packets_sent host_nic[interface]["bytes_sent"] = bytes_sent if "interface" in host_nets: database.host_net(timestamp, host_nets) elif "tap" in interface: bytes_sent, bytes_recv, packets_sent, packets_recv, \ errin, errout, dropin, dropout = interfaces[interface] if interface in host_nic: host_nets["interface"] = interface host_nets["packets_recv"] = str(((packets_recv - host_nic[interface]["packets_recv"]) * 1.0) \ / (tm - host_info["time"])) host_nets["bytes_recv"] = str(((bytes_recv - host_nic[interface]["bytes_recv"]) * 1.0) \ / (tm - host_info["time"])) host_nets["packets_sent"] = str(((packets_sent - host_nic[interface]["packets_sent"]) * 1.0) \ / (tm - host_info["time"])) host_nets["bytes_sent"] = str(((bytes_sent - host_nic[interface]["bytes_sent"]) * 1.0) \ / (tm - host_info["time"])) else: host_nic[interface] = {} host_nic[interface]["packets_recv"] = packets_recv host_nic[interface]["bytes_recv"] = bytes_recv host_nic[interface]["packets_sent"] = packets_sent host_nic[interface]["bytes_sent"] = bytes_sent if "interface" in host_nets: database.host_net(timestamp, host_nets) host_info["time"] = tm return
""" 监控代码:监控服务器的内存、cpu、网络、磁盘等。与租车系统部署到一起。 """ from datetime import datetime from time import sleep import psutil print(psutil.cpu_percent()) # 获取cpu信息 print(psutil.virtual_memory()) # 获取虚拟内存 print(psutil.virtual_memory().percent) # 虚拟内存百分比 print(psutil.disk_usage("E:/")) # 租车系统所在的磁盘 print(psutil.disk_usage("E:/").percent) # 租车系统所在的磁盘的百分百 print(psutil.net_io_counters()) # 网络 print(psutil.net_io_counters().bytes_sent) # 发送的字节数 print(psutil.net_io_counters().bytes_recv) # 接收的字节数 # 达到类似serveragent的效果,在性能测试期间,获取cpu、内存的趋势 # 死循环,每隔3s读一次,把读的结果写到文件中,测试结束后分析文件,试用excel等生成图表。 # 时间戳 CPU% 内存% 磁盘% 发送字节数 接收字节数 with open("E:/资源占用情况.txt", encoding='utf-8', mode='a') as file: file.write("时间戳\tcpu%\t内存%\t磁盘%\t发送字节数\t接收字节数") while True: print("监控中。。。。。。。。。。。。。。。。") # strftime 当前时间转字符串 file.write( datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S") + "\t") file.write(str(psutil.cpu_percent()) + "%\t") file.write(str(psutil.disk_usage("E:/").percent) + "%\t") file.write(str(psutil.net_io_counters().bytes_sent) + "%\t") file.write(str(psutil.net_io_counters().bytes_recv) + "%\t")
def recebidos(): return conversor(psutil.net_io_counters().bytes_recv)
def enviados(): return conversor(psutil.net_io_counters().bytes_sent)
def heroku_usage(): if HEROKU_API is None and HEROKU_APP_NAME is None: return False, "You do not use heroku, bruh!" user_id = Heroku.account().id headers = { "User-Agent": choice(some_random_headers), "Authorization": f"Bearer {heroku_api}", "Accept": "application/vnd.heroku+json; version=3.account-quotas", } her_url = f"https://api.heroku.com/accounts/{user_id}/actions/get-quota" r = requests.get(her_url, headers=headers) if r.status_code != 200: return ( True, f"**ERROR**\n`{r.reason}`", ) result = r.json() quota = result["account_quota"] quota_used = result["quota_used"] remaining_quota = quota - quota_used percentage = math.floor(remaining_quota / quota * 100) minutes_remaining = remaining_quota / 60 hours = math.floor(minutes_remaining / 60) minutes = math.floor(minutes_remaining % 60) App = result["apps"] try: App[0]["quota_used"] except IndexError: AppQuotaUsed = 0 AppPercentage = 0 else: AppQuotaUsed = App[0]["quota_used"] / 60 AppPercentage = math.floor(App[0]["quota_used"] * 100 / quota) AppHours = math.floor(AppQuotaUsed / 60) AppMinutes = math.floor(AppQuotaUsed % 60) total, used, free = shutil.disk_usage(".") cpuUsage = psutil.cpu_percent() memory = psutil.virtual_memory().percent disk = psutil.disk_usage("/").percent upload = humanbytes(psutil.net_io_counters().bytes_sent) down = humanbytes(psutil.net_io_counters().bytes_recv) TOTAL = humanbytes(total) USED = humanbytes(used) FREE = humanbytes(free) return True, get_string("usage").format( Var.HEROKU_APP_NAME, AppHours, AppMinutes, AppPercentage, hours, minutes, percentage, TOTAL, USED, FREE, upload, down, cpuUsage, memory, disk, )
def get_interface_node(): if_children = [make_if_nodes(x) for x in list(ps.net_io_counters(pernic=True).keys())] return ParentNode('interface', children=if_children)
def _update_widgets(self, widgets): interfaces = [ i for i in netifaces.interfaces() if not i.startswith(self._exclude) ] del widgets[:] counters = psutil.net_io_counters(pernic=True) now = time.time() timediff = now - (self._lastcheck if self._lastcheck else now) if timediff <= 0: timediff = 1 self._lastcheck = now for interface in interfaces: if self._graphlen > 0: if interface not in self._graphdata: self._graphdata[interface] = { "rx": [0] * self._graphlen, "tx": [0] * self._graphlen } if not interface: interface = "lo" state = "down" if len(self.get_addresses(interface)) > 0: state = "up" elif bumblebee.util.asbool(self.parameter("hide_down", True)): continue if len(self._states["exclude"] ) > 0 and state in self._states["exclude"]: continue if len(self._states["include"] ) > 0 and state not in self._states["include"]: continue data = { "rx": counters[interface].bytes_recv, "tx": counters[interface].bytes_sent, } name = "traffic-{}".format(interface) if self._showname: self.create_widget(widgets, name, interface) for direction in ["rx", "tx"]: name = "traffic.{}-{}".format(direction, interface) widget = self.create_widget( widgets, name, attributes={"theme.minwidth": self.get_minwidth_str()}) prev = self._prev.get(name, 0) bspeed = (int(data[direction]) - int(prev)) / timediff speed = bumblebee.util.bytefmt(bspeed, self._format) txtspeed = '{0}/s'.format(speed) if self._graphlen > 0: # skip first value returned by psutil, because it is # giant and ruins the grapth ratio until it gets pushed # out of saved list if self._first_run is True: self._first_run = False else: self._graphdata[interface][ direction] = self._graphdata[interface][direction][ 1:] self._graphdata[interface][direction].append(bspeed) txtspeed = "{}{}".format( bumblebee.output.bgraph( self._graphdata[interface][direction]), txtspeed) widget.full_text(txtspeed) self._prev[name] = data[direction]
def netload(): netrcv = int((psutil.net_io_counters().bytes_recv) / 1000000) netsent = int((psutil.net_io_counters().bytes_sent) / 1000000) return (netrcv, netsent)
# sdiskpart(device="E:\\", mountpoint="E:\\", fstype="NTFS", opts="rw,fixed"), # sdiskpart(device="F:\\", mountpoint="F:\\", fstype="NTFS", opts="rw,fixed")] print(psutil.disk_usage("/")) # 磁盘使用情况 # sdiskusage(total=500090007552, used=204505022464, free=295584985088, percent=40.9) print(psutil.disk_io_counters()) # 磁盘IO # sdiskio( # read_count=4929858, write_count=8759548, # read_bytes=321037917184, write_bytes=347494014976, # read_time=4129, write_time=4759) # psutil可以获取网络接口和网络连接信息 print() print(psutil.net_io_counters()) # 获取网络读写字节/包的个数 # snetio(bytes_sent=68468541570, bytes_recv=121054712924, # packets_sent=112391551, packets_recv=133056843, # errin=0, errout=15, dropin=0, dropout=0) print() print(psutil.net_if_addrs() )# 获取网络接口信息 print() print(psutil.net_if_stats()) # 获取网络接口状态 # 要获取当前网络连接信息, 使用net_connections() print() print(psutil.net_connections()) # 通过psutil可以获取到所有进程的详细信息 print()
def update(self): """Update network stats using the input method. Stats is a list of dict (one dict per interface) """ # Init new stats stats = self.get_init_value() if self.input_method == 'local': # Update stats using the standard system lib # Grab network interface stat using the psutil net_io_counter method try: netiocounters = psutil.net_io_counters(pernic=True) except UnicodeDecodeError as e: logger.debug( 'Can not get network interface counters ({})'.format(e)) return self.stats # Grab interface's status (issue #765) # Grab interface's speed (issue #718) netstatus = {} try: netstatus = psutil.net_if_stats() except OSError as e: # see psutil #797/glances #1106 logger.debug( 'Can not get network interface status ({})'.format(e)) # Previous network interface stats are stored in the network_old variable if not hasattr(self, 'network_old'): # First call, we init the network_old var try: self.network_old = netiocounters except (IOError, UnboundLocalError): pass return self.stats # By storing time data we enable Rx/s and Tx/s calculations in the # XML/RPC API, which would otherwise be overly difficult work # for users of the API time_since_update = getTimeSinceLastUpdate('net') # Loop over interfaces network_new = netiocounters for net in network_new: # Do not take hidden interface into account # or KeyError: 'eth0' when interface is not connected #1348 if self.is_hide(net) or net not in netstatus: continue try: cumulative_rx = network_new[net].bytes_recv cumulative_tx = network_new[net].bytes_sent cumulative_cx = cumulative_rx + cumulative_tx rx = cumulative_rx - self.network_old[net].bytes_recv tx = cumulative_tx - self.network_old[net].bytes_sent cx = rx + tx netstat = { 'interface_name': n(net), 'time_since_update': time_since_update, 'cumulative_rx': cumulative_rx, 'rx': rx, 'cumulative_tx': cumulative_tx, 'tx': tx, 'cumulative_cx': cumulative_cx, 'cx': cx, # Interface status 'is_up': netstatus[net].isup, # Interface speed in Mbps, convert it to bps # Can be always 0 on some OSes 'speed': netstatus[net].speed * 1048576, # Set the key for the dict 'key': self.get_key() } except KeyError: continue else: # Append the interface stats to the list stats.append(netstat) # Save stats to compute next bitrate self.network_old = network_new elif self.input_method == 'snmp': # Update stats using SNMP # SNMP bulk command to get all network interface in one shot try: netiocounters = self.get_stats_snmp( snmp_oid=snmp_oid[self.short_system_name], bulk=True) except KeyError: netiocounters = self.get_stats_snmp( snmp_oid=snmp_oid['default'], bulk=True) # Previous network interface stats are stored in the network_old variable if not hasattr(self, 'network_old'): # First call, we init the network_old var try: self.network_old = netiocounters except (IOError, UnboundLocalError): pass else: # See description in the 'local' block time_since_update = getTimeSinceLastUpdate('net') # Loop over interfaces network_new = netiocounters for net in network_new: # Do not take hidden interface into account if self.is_hide(net): continue try: # Windows: a tips is needed to convert HEX to TXT # http://blogs.technet.com/b/networking/archive/2009/12/18/how-to-query-the-list-of-network-interfaces-using-snmp-via-the-ifdescr-counter.aspx if self.short_system_name == 'windows': try: interface_name = str( base64.b16decode(net[2:-2].upper())) except TypeError: interface_name = net else: interface_name = net cumulative_rx = float( network_new[net]['cumulative_rx']) cumulative_tx = float( network_new[net]['cumulative_tx']) cumulative_cx = cumulative_rx + cumulative_tx rx = cumulative_rx - float( self.network_old[net]['cumulative_rx']) tx = cumulative_tx - float( self.network_old[net]['cumulative_tx']) cx = rx + tx netstat = { 'interface_name': interface_name, 'time_since_update': time_since_update, 'cumulative_rx': cumulative_rx, 'rx': rx, 'cumulative_tx': cumulative_tx, 'tx': tx, 'cumulative_cx': cumulative_cx, 'cx': cx } except KeyError: continue else: netstat['key'] = self.get_key() stats.append(netstat) # Save stats to compute next bitrate self.network_old = network_new # Update the stats self.stats = stats return self.stats
def update(self): self.if_addrs = psutil.net_if_addrs() self.net_io = psutil.net_io_counters()
async def info(request): """HTTP Method to retun node state to caller""" log.debug("info request") app = request.app answer = {} # copy relevant entries from state dictionary to response node = {} node['id'] = request.app['id'] node['type'] = request.app['node_type'] node['start_time'] = app["start_time"] #unixTimeToUTC(app['start_time']) node['state'] = app['node_state'] node['node_number'] = app['node_number'] node['node_count'] = app['node_count'] answer["node"] = node # psutil info # see: http://pythonhosted.org/psutil/ for description of different fields cpu = {} cpu["percent"] = psutil.cpu_percent() cpu["cores"] = psutil.cpu_count() answer["cpu"] = cpu diskio = psutil.disk_io_counters() disk_stats = {} disk_stats["read_count"] = diskio.read_count disk_stats["read_time"] = diskio.read_time disk_stats["read_bytes"] = diskio.read_bytes disk_stats["write_count"] = diskio.write_count disk_stats["write_time"] = diskio.write_time disk_stats["write_bytes"] = diskio.write_bytes answer["diskio"] = disk_stats netio = psutil.net_io_counters() net_stats = {} net_stats["bytes_sent"] = netio.bytes_sent net_stats["bytes_sent"] = netio.bytes_recv net_stats["packets_sent"] = netio.packets_sent net_stats["packets_recv"] = netio.packets_recv net_stats["errin"] = netio.errin net_stats["errout"] = netio.errout net_stats["dropin"] = netio.dropin net_stats["dropout"] = netio.dropout answer["netio"] = net_stats mem_stats = {} svmem = psutil.virtual_memory() mem_stats["phys_total"] = svmem.total mem_stats["phys_available"] = svmem.available sswap = psutil.swap_memory() mem_stats["swap_total"] = sswap.total mem_stats["swap_used"] = sswap.used mem_stats["swap_free"] = sswap.free mem_stats["percent"] = sswap.percent answer["memory"] = mem_stats disk_stats = {} sdiskusage = psutil.disk_usage('/') disk_stats["total"] = sdiskusage.total disk_stats["used"] = sdiskusage.used disk_stats["free"] = sdiskusage.free disk_stats["percent"] = sdiskusage.percent answer["disk"] = disk_stats answer["log_stats"] = app["log_count"] answer["req_count"] = app["req_count"] answer["s3_stats"] = app["s3_stats"] mc_stats = {} if "meta_cache" in app: mc = app["meta_cache"] # only DN nodes have this mc_stats["count"] = len(mc) mc_stats["dirty_count"] = mc.dirtyCount mc_stats["utililization_per"] = mc.cacheUtilizationPercent mc_stats["mem_used"] = mc.memUsed mc_stats["mem_target"] = mc.memTarget answer["meta_cache_stats"] = mc_stats cc_stats = {} if "chunk_cache" in app: cc = app["chunk_cache"] # only DN nodes have this cc_stats["count"] = len(cc) cc_stats["dirty_count"] = cc.dirtyCount cc_stats["utililization_per"] = cc.cacheUtilizationPercent cc_stats["mem_used"] = cc.memUsed cc_stats["mem_target"] = cc.memTarget answer["chunk_cache_stats"] = cc_stats dc_stats = {} if "domain_cache" in app: dc = app["domain_cache"] # only DN nodes have this dc_stats["count"] = len(dc) dc_stats["dirty_count"] = dc.dirtyCount dc_stats["utililization_per"] = dc.cacheUtilizationPercent dc_stats["mem_used"] = dc.memUsed dc_stats["mem_target"] = dc.memTarget answer["domain_cache_stats"] = dc_stats resp = await jsonResponse(request, answer) log.response(request, resp=resp) return resp
else: options = {"org": organization, "type": deviceType, "id": deviceId, "auth-method": authMethod, "auth-token": authToken} client = wiotp.sdk.device.DeviceClient(options) client.commandCallback = commandProcessor client.connect() except Exception as e: print(str(e)) sys.exit(1) print("(Press Ctrl+C to disconnect)") # Take initial reading psutil.cpu_percent(percpu=False) ioBefore_ts = time.time() ioBefore = psutil.net_io_counters() while True: time.sleep(interval) ioAfter_ts = time.time() ioAfter = psutil.net_io_counters() # Calculate the time taken between IO checks ioDuration = ioAfter_ts - ioBefore_ts data = { 'name' : deviceName, 'cpu' : psutil.cpu_percent(percpu=False), 'mem' : psutil.virtual_memory().percent, 'network': { 'up': round( (ioAfter.bytes_sent - ioBefore.bytes_sent) / (ioDuration*1024), 2 ),
def get(config): """Get all network information""" netInfo = {} interfaces = config.get('agent', "interfaces").split(",") for intf in interfaces: nicInfo = netInfo.setdefault(intf, {}) vlan_range = config.get(intf, "vlans") vlan_min = config.get(intf, "vlan_min") vlan_max = config.get(intf, "vlan_max") switch_port = config.get(intf, "port") switch = config.get(intf, "switch") shared_interface = config.get(intf, "shared") if config.has_option(intf, 'isAlias'): nicInfo['isAlias'] = config.get(intf, 'isAlias') if config.has_option(intf, "ips"): nicInfo['ipv4-floatingip-pool'] = config.get(intf, "ips") nicInfo['vlan_range'] = vlan_range nicInfo['min_bandwidth'] = int(vlan_min) nicInfo['max_bandwidth'] = int(vlan_max) nicInfo['switch_port'] = str(switch_port).replace('/', '_') nicInfo['switch'] = str(switch) nicInfo['shared'] = str2bool(shared_interface) nicInfo['vlans'] = {} # TODO. It should calculate available capacity, depending on installed vlans. # Currently we set it same as max_bandwidth. nicInfo['available_bandwidth'] = int(vlan_max) # TODO # TODO. It should also calculate reservable capacity depending on installed vlans; # Currently we set it to max available; nicInfo['reservable_bandwidth'] = int(vlan_max) # TODO print netInfo tmpifAddr = psutil.net_if_addrs() tmpifStats = psutil.net_if_stats() tmpIOCount = psutil.net_io_counters(pernic=True) foundInterfaces = [] for nic, addrs in tmpifAddr.items(): # TODO: Check with configuration of which vlans are provisioned; # Currently it is a hack. if it is a vlan, I assume it is provisioned by orchestrator; nicSplit = nic.split('.') nicInfo = netInfo.setdefault(nicSplit[0], {'vlans': {}}) if len(nicSplit) == 2: nicInfo = nicInfo['vlans'].setdefault(nic, {}) nicInfo['provisioned'] = True nicInfo['vlanid'] = nicSplit[1] else: nicInfo['provisioned'] = False foundInterfaces.append(nic) for vals in addrs: familyInfo = nicInfo.setdefault(str(vals.family), {}) # vals - family=2, address='127.0.0.1', netmask='255.0.0.0', broadcast=None, ptp=None # For family more information look here: http://lxr.free-electrons.com/source/include/linux/socket.h#L160 familyInfo["family"] = vals.family familyInfo["address"] = vals.address familyInfo["netmask"] = vals.netmask if int(vals.family) in [2, 10] and vals.address and vals.netmask: try: ipwithnetmask = ipaddress.ip_interface( u"%s/%s" % (vals.address, vals.netmask)) if isinstance(ipwithnetmask, ipaddress.IPv4Interface): familyInfo["ipv4-address"] = str(ipwithnetmask) elif isinstance(ipwithnetmask, ipaddress.IPv6Interface): familyInfo["ipv6-address"] = str(ipwithnetmask) else: print "This type was not understood by the system. Type: %s and value: %s" % ( type(ipwithnetmask), str(ipwithnetmask)) except ValueError as ex: print 'Got an exception %s' % ex elif int(vals.family) in [17]: familyInfo["mac-address"] = vals.address familyInfo["broadcast"] = vals.broadcast familyInfo["ptp"] = vals.ptp # tmpifStats - snicstats(isup=True, duplex=0, speed=0, mtu=1500) if vals.family == 2: familyInfo["UP"] = tmpifStats[nic].isup familyInfo["duplex"] = tmpifStats[nic].duplex familyInfo["speed"] = tmpifStats[nic].speed familyInfo["MTU"] = tmpifStats[nic].mtu # tmpIOCount - (bytes_sent=13839798, bytes_recv=690754706, packets_sent=151186, # packets_recv=630590, errin=0, errout=0, dropin=0, dropout=0) familyInfo["bytes_sent"] = tmpIOCount[nic].bytes_sent familyInfo["bytes_received"] = tmpIOCount[nic].bytes_recv familyInfo["packets_sent"] = tmpIOCount[nic].packets_sent familyInfo["packets_recv"] = tmpIOCount[nic].packets_recv familyInfo["errin"] = tmpIOCount[nic].errin familyInfo["errout"] = tmpIOCount[nic].errout familyInfo["dropin"] = tmpIOCount[nic].dropin familyInfo["dropout"] = tmpIOCount[nic].dropout # Additional info which is not provided by psutil so far... # More detail information about all types here: # http://lxr.free-electrons.qcom/source/include/uapi/linux/if_arp.h nicType = externalCommand('cat /sys/class/net/' + nic + "/type") familyInfo["Type"] = nicType[0].strip() txQueueLen = externalCommand('cat /sys/class/net/' + nic + "/tx_queue_len") familyInfo["txqueuelen"] = txQueueLen[0].strip() # Check in the end which interfaces where defined in config but not available... outputForFE = {"interfaces": {}, "routes": []} for intfName, intfDict in netInfo.iteritems(): if intfName.split('.')[0] not in foundInterfaces: print 'This interface was defined in configuration, but not available. Will not add it to final output' print intfName, intfDict else: outputForFE["interfaces"][intfName] = intfDict # Get Routing Information outputForFE["routes"] = getRoutes(config) return outputForFE
old_errout = None old_dropin = None old_dropout = None old_dt = None first = True while True: LOGGER.debug("waiting 10s...") time.sleep(10) client = TelegrafUnixSocketClient(SOCKET_PATH) try: client.connect() except Exception: LOGGER.warning("can't connect to %s, wait 10s and try again...", SOCKET_PATH) continue stats = psutil.net_io_counters(pernic=False) new_dt = datetime.now() new_bytes_sent = stats.bytes_sent new_bytes_recv = stats.bytes_recv new_packets_sent = stats.packets_sent new_packets_recv = stats.packets_recv new_errin = stats.errin new_errout = stats.errout new_dropin = stats.dropin new_dropout = stats.dropout if first: first = False else: delta = (new_dt - old_dt).total_seconds() bytes_sent_per_second = (new_bytes_sent - old_bytes_sent) / delta
def net_out(): netOut = size( psutil.net_io_counters(pernic=True, nowrap=True)[eth_interface].bytes_sent) return netOut
def net_in(): netIn = size( psutil.net_io_counters(pernic=True, nowrap=True)[eth_interface].bytes_recv) return netIn
def test_net_io_counters(self): # Duplicate of test_system.py. Keep it anyway. for ifname, _ in psutil.net_io_counters(pernic=True).items(): self.assertIsInstance(ifname, str)
import psutil import time addr = psutil.net_if_addrs() ifaceList = addr.keys() index = 0 cardList = [] for iface in ifaceList: net = iface ip = addr[iface][0][1] try: ipcheck = ip.split(".")[3] status = "<span style='color:#00d600'>Up</span>" cardList.append(iface) except: status = "<span style='color:red'>Down</span>" # print(iface) byte = psutil.net_io_counters(pernic=True) # print(byte) i = 0 for card in cardList: print(str(i)+"||"+card + "||"+str((byte[card][0]/8/1024-int(byte[card][0]/8/1024)))+"||"+str((byte[card][1]/8/1024/1000))+"|||") i = i+1
def update_counters(self, interface): import psutil self.pnic_before = self.pnic counters = psutil.net_io_counters(pernic=True) self.pnic = counters[interface] if interface in counters else None
from smtplib import SMTP_SSL from email.header import Header from datetime import datetime from email import encoders from email.mime.base import MIMEBase from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText import psutil import socket from hurry.filesize import size # the remote ip address. When remote connected, I shall be able to curl to www.google.com from China. nic = 'eth0' byte_send = psutil.net_io_counters(pernic=True)[nic][0] byte_recv = psutil.net_io_counters(pernic=True)[nic][1] #send_traffic = size(byte_send) # recv_traffic = size(byte_recv) def format_bytes(size): # 2**10 = 1024 power = 2**10 n = 0 power_labels = {0: '', 1: 'kilo', 2: 'mega', 3: 'giga', 4: 'tera'} while size > power: size /= power n += 1 return size, power_labels[n] + 'bytes'
def update(self): """Get the latest system information.""" if self.type == "disk_use_percent": self._state = psutil.disk_usage(self.argument).percent elif self.type == "disk_use": self._state = round( psutil.disk_usage(self.argument).used / 1024**3, 1) elif self.type == "disk_free": self._state = round( psutil.disk_usage(self.argument).free / 1024**3, 1) elif self.type == "memory_use_percent": self._state = psutil.virtual_memory().percent elif self.type == "memory_use": virtual_memory = psutil.virtual_memory() self._state = round( (virtual_memory.total - virtual_memory.available) / 1024**2, 1) elif self.type == "memory_free": self._state = round(psutil.virtual_memory().available / 1024**2, 1) elif self.type == "swap_use_percent": self._state = psutil.swap_memory().percent elif self.type == "swap_use": self._state = round(psutil.swap_memory().used / 1024**2, 1) elif self.type == "swap_free": self._state = round(psutil.swap_memory().free / 1024**2, 1) elif self.type == "processor_use": self._state = round(psutil.cpu_percent(interval=None)) elif self.type == "processor_temperature": self._state = self.read_cpu_temperature() elif self.type == "process": for proc in psutil.process_iter(): try: if self.argument == proc.name(): self._state = STATE_ON return except psutil.NoSuchProcess as err: _LOGGER.warning( "Failed to load process with id: %s, old name: %s", err.pid, err.name, ) self._state = STATE_OFF elif self.type == "network_out" or self.type == "network_in": counters = psutil.net_io_counters(pernic=True) if self.argument in counters: counter = counters[self.argument][IO_COUNTER[self.type]] self._state = round(counter / 1024**2, 1) else: self._state = None elif self.type == "packets_out" or self.type == "packets_in": counters = psutil.net_io_counters(pernic=True) if self.argument in counters: self._state = counters[self.argument][IO_COUNTER[self.type]] else: self._state = None elif (self.type == "throughput_network_out" or self.type == "throughput_network_in"): counters = psutil.net_io_counters(pernic=True) if self.argument in counters: counter = counters[self.argument][IO_COUNTER[self.type]] now = dt_util.utcnow() if self._last_value and self._last_value < counter: self._state = round( (counter - self._last_value) / 1000**2 / (now - self._last_update_time).seconds, 3, ) else: self._state = None self._last_update_time = now self._last_value = counter else: self._state = None elif self.type == "ipv4_address" or self.type == "ipv6_address": addresses = psutil.net_if_addrs() if self.argument in addresses: for addr in addresses[self.argument]: if addr.family == IF_ADDRS_FAMILY[self.type]: self._state = addr.address else: self._state = None elif self.type == "last_boot": self._state = dt_util.as_local( dt_util.utc_from_timestamp(psutil.boot_time())).isoformat() elif self.type == "load_1m": self._state = round(os.getloadavg()[0], 2) elif self.type == "load_5m": self._state = round(os.getloadavg()[1], 2) elif self.type == "load_15m": self._state = round(os.getloadavg()[2], 2)
def net_stats(): netStats = psutil.net_io_counters(pernic=True, nowrap=True)[eth_interface] return netStats
# cpu使用率 print(psutil.cpu_percent(interval=0.5)) # 获取每个核心的使用率 print(psutil.cpu_percent(interval=0.5, percpu=True)) # 获取内存信息 # 内存整体信息 print(psutil.virtual_memory()) # 内存使用率 print(psutil.virtual_memory().percent) # 获取硬盘信息 # 硬盘分区信息 print(psutil.disk_partitions()) # 指定目录磁盘信息 print(psutil.disk_usage("/")) # 硬盘使用率 print(psutil.disk_usage("/").percent) # 获取网络信息 # 收到的数据包数量 print(psutil.net_io_counters().bytes_recv) # 发送的数据包数量 print(psutil.net_io_counters().bytes_sent) # 获取开机时间 print(psutil.boot_time()) # 1970年到现在的秒数 # 获取活动用户 print(psutil.users())
def _get_stats(): libvirt = util_libvirt.get_libvirt() conn = libvirt.open('qemu:///system') # What's special about this node? retval = { 'is_etcd_master': config.NODE_IS_ETCD_MASTER, 'is_hypervisor': config.NODE_IS_HYPERVISOR, 'is_network_node': config.NODE_IS_NETWORK_NODE, } # CPU info present_cpus, _, available_cpus = conn.getCPUMap() retval.update({ 'cpu_max': present_cpus, 'cpu_available': available_cpus, }) retval['cpu_max_per_instance'] = conn.getMaxVcpus(None) # This is disabled as data we don't currently use # for i in range(present_cpus): # per_cpu_stats = conn.getCPUStats(i) # for key in per_cpu_stats: # retval['cpu_core%d_%s' % (i, key)] = per_cpu_stats[key] try: load_1, load_5, load_15 = psutil.getloadavg() retval.update({ 'cpu_load_1': load_1, 'cpu_load_5': load_5, 'cpu_load_15': load_15, }) except Exception as e: util_general.ignore_exception('load average', e) # System memory info, converting bytes to mb stats = psutil.virtual_memory() retval.update({ 'memory_max': stats.total // 1024 // 1024, 'memory_available': stats.available // 1024 // 1024 }) # libvirt memory info, converting kb to mb memory_status = conn.getMemoryStats( libvirt.VIR_NODE_MEMORY_STATS_ALL_CELLS) retval.update({ 'memory_max_libvirt': memory_status['total'] // 1024, 'memory_available_libvirt': memory_status['free'] // 1024, }) # Kernel Shared Memory (KSM) information ksm_details = {} for ent in os.listdir('/sys/kernel/mm/ksm'): with open('/sys/kernel/mm/ksm/%s' % ent) as f: ksm_details['memory_ksm_%s' % ent] = int(f.read().rstrip()) retval.update(ksm_details) # Disk info. There could be more than one filesystem here, so we track # all of the paths we're fond of. fsids = [] minimum = -1 total = 0 used = 0 for path in ['', 'blobs', 'image_cache', 'instances', 'uploads']: # We need to make the paths we check if they don't exist, otherwise # they wont be included in the metrics and things get confused. fullpath = os.path.join(config.STORAGE_PATH, path) os.makedirs(fullpath, exist_ok=True) s = os.statvfs(fullpath) free = s.f_frsize * s.f_bavail if s.f_fsid not in fsids: total += s.f_frsize * s.f_blocks used += s.f_frsize * (s.f_blocks - s.f_bfree) if minimum == -1 or free < minimum: minimum = free if path == '': path = 'sfroot' retval['disk_free_%s' % path] = free retval.update({ 'disk_total': total, 'disk_free': minimum, 'disk_used': used }) disk_counters = psutil.disk_io_counters() retval.update({ 'disk_read_bytes': disk_counters.read_bytes, 'disk_write_bytes': disk_counters.write_bytes, }) # Network info net_counters = psutil.net_io_counters() retval.update({ 'network_read_bytes': net_counters.bytes_recv, 'network_write_bytes': net_counters.bytes_sent, }) # Virtual machine consumption info total_instances = 0 total_active_instances = 0 total_instance_max_memory = 0 total_instance_actual_memory = 0 total_instance_vcpus = 0 total_instance_cpu_time = 0 for guest in conn.listAllDomains(): try: active = guest.isActive() == 1 if active: _, maxmem, mem, cpus, cpu_time = guest.info() except libvirt.libvirtError as e: LOG.debug('During resource calc ignored libvirt error: %s' % e) active = False if active: total_instances += 1 total_active_instances += 1 total_instance_max_memory += maxmem total_instance_actual_memory += mem total_instance_vcpus += cpus total_instance_cpu_time += cpu_time # Queue health statistics node_queue_processing, node_queue_waiting = etcd.get_queue_length( config.NODE_NAME) retval.update({ 'cpu_total_instance_vcpus': total_instance_vcpus, 'cpu_total_instance_cpu_time': total_instance_cpu_time, 'memory_total_instance_max': total_instance_max_memory // 1024, 'memory_total_instance_actual': total_instance_actual_memory // 1024, 'instances_total': total_instances, 'instances_active': total_active_instances, 'node_queue_processing': node_queue_processing, 'node_queue_waiting': node_queue_waiting, }) if config.NODE_IS_NETWORK_NODE: network_queue_processing, network_queue_waiting = etcd.get_queue_length( 'networknode') retval.update({ 'network_queue_processing': network_queue_processing, 'network_queue_waiting': network_queue_waiting, }) return retval