-
Notifications
You must be signed in to change notification settings - Fork 8
/
server_info.py
146 lines (121 loc) · 3.25 KB
/
server_info.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
import logging
import time
import psutil
import sys
import socket
__status = {}
__last_access = time.time()
__last_get = time.time()
__access_interval = 0
__get_interval = 2
__last_ct = psutil.cpu_times()
def get_status():
global __last_access
__last_access = time.time()
return __status
def refresh_status():
global __access_interval
try:
now = time.time()
__access_interval = now - __last_access
if __access_interval <= 60:
global __get_interval, __last_get
__get_interval = now - __last_get
__last_get = now
uptime()
cpu()
memory()
swap()
disk()
loads()
net()
except Exception as e:
logging.warning('Failed to get system status information: ' + str(e))
def uptime():
__status['uptime'] = time.time() - psutil.boot_time()
def cpu():
global __last_ct
cur_ct = psutil.cpu_times()
last_total = sum(__last_ct)
cur_total = sum(cur_ct)
total = cur_total - last_total
idle = cur_ct.idle - __last_ct.idle
if total <= 0:
percent = 0
else:
percent = (total - idle) / total * 100
__last_ct = cur_ct
__status['cpu'] = {
'percent': percent
}
def memory():
mem = psutil.virtual_memory()
__status['memory'] = {
'used': mem.used,
'total': mem.total
}
def swap():
swap_mem = psutil.swap_memory()
__status['swap'] = {
'used': swap_mem.used,
'total': swap_mem.total
}
def disk():
d = psutil.disk_usage('/')
__status['disk'] = {
'total': d.total,
'used': d.used
}
def loads():
__status['loads'] = psutil.getloadavg()
__last_net_io = psutil.net_io_counters()
def __get_net_tcp_udp_count():
conns = psutil.net_connections()
tcp_count = 0
udp_count = 0
for conn in conns:
if conn.type == 1:
tcp_count += 1
elif conn.type == 2:
udp_count += 1
return tcp_count, udp_count
def net():
global __last_net_io
cur_net_io = psutil.net_io_counters()
sent = cur_net_io.bytes_sent
recv = cur_net_io.bytes_recv
up = (sent - __last_net_io.bytes_sent) / __get_interval
down = (recv - __last_net_io.bytes_recv) / __get_interval
tcp_count, udp_count = __get_net_tcp_udp_count()
__status['net_io'] = {
'up': up,
'down': down
}
__status['net_traffic'] = {
'sent': sent,
'recv': recv
}
__status['tcp_count'] = tcp_count
__status['udp_count'] = udp_count
__last_net_io = cur_net_io
refresh_status()
def nodePy():
socket_path = '/tmp/node-python-sock'
client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
# connect to the unix local socket with a stream type
client.connect(socket_path)
# send an initial message (as bytes)
client.send(b'python connected')
# start a loop
while True:
# wait for a response and decode it from bytes
msg = client.recv(2048).decode('utf-8')
if msg == 'get_status':
client.send(str(get_status()).encode())
refresh_status()
elif msg == 'end':
# exit the loop
break
# close the connection
client.close()
nodePy()