Debian Codegraph @

gmond/python_modules/network/traffic1.py

raw
1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3
4 import sys
5 import os
6 import threading
7 import time
8
9 descriptors = list()
10 Desc_Skel = {}
11 _Worker_Thread = None
12 _Lock = threading.Lock() # synchronization lock
13
14 Debug = False
15
16
17 def dprint(f, *v):
18 if Debug:
19 print >> sys.stderr, "DEBUG: " + f % v
20
21
22 class UpdateTrafficThread(threading.Thread):
23
24 __slots__ = ('proc_file')
25
26 def __init__(self, params):
27 threading.Thread.__init__(self)
28 self.running = False
29 self.shuttingdown = False
30 self.refresh_rate = 10
31 if "refresh_rate" in params:
32 self.refresh_rate = int(params["refresh_rate"])
33
34 self.target_device = params["target_device"]
35 self.metric = {}
36
37 self.proc_file = "/proc/net/dev"
38 self.stats_tab = {
39 "recv_bytes" : 0,
40 "recv_pkts" : 1,
41 "recv_errs" : 2,
42 "recv_drops" : 3,
43 "trans_bytes" : 8,
44 "trans_pkts" : 9,
45 "trans_errs" : 10,
46 "trans_drops" : 11,
47 }
48 self.stats = {}
49 self.stats_prev = {}
50
51 def shutdown(self):
52 self.shuttingdown = True
53 if not self.running:
54 return
55 self.join()
56
57 def run(self):
58 self.running = True
59
60 while not self.shuttingdown:
61 _Lock.acquire()
62 self.update_metric()
63 _Lock.release()
64 time.sleep(self.refresh_rate)
65
66 self.running = False
67
68 def update_metric(self):
69 f = open(self.proc_file, "r")
70 for l in f:
71 a = l.split(":")
72 dev = a[0].lstrip()
73 if dev != self.target_device:
74 continue
75
76 dprint("%s", ">>update_metric")
77 self.stats = {}
78 _stats = a[1].split()
79 for name, index in self.stats_tab.iteritems():
80 self.stats[name + '_' + self.target_device] = int(_stats[index])
81 self.stats["time"] = time.time()
82 dprint("%s", self.stats)
83
84 if "time" in self.stats_prev:
85 dprint("%s: %d = %d - %d", "DO DIFF", self.stats["time"] - self.stats_prev["time"], self.stats["time"], self.stats_prev["time"])
86 d = self.stats["time"] - self.stats_prev["time"]
87 for name, cur in self.stats.iteritems():
88 self.metric[name] = float(cur - self.stats_prev[name]) / d
89
90 self.stats_prev = self.stats.copy()
91 break
92
93 return
94
95 def metric_of(self, name):
96 val = 0
97 if name in self.metric:
98 _Lock.acquire()
99 val = self.metric[name]
100 _Lock.release()
101 return val
102
103
104 def metric_init(params):
105 global Desc_Skel, _Worker_Thread, Debug
106
107 print '[traffic1] Received the following parameters'
108 print params
109
110 Desc_Skel = {
111 'name' : 'XXX',
112 'call_back' : metric_of,
113 'time_max' : 60,
114 'value_type' : 'float',
115 'format' : '%.3f',
116 'units' : 'XXX',
117 'slope' : 'both',
118 'description' : 'XXX',
119 'groups' : 'network',
120 }
121
122 if "refresh_rate" not in params:
123 params["refresh_rate"] = 10
124 if "debug" in params:
125 Debug = params["debug"]
126 dprint("%s", "Debug mode on")
127 if "target_device" not in params:
128 params["target_device"] = "lo"
129 target_device = params["target_device"]
130
131 _Worker_Thread = UpdateTrafficThread(params)
132 _Worker_Thread.start()
133
134 # IP:HOSTNAME
135 if "spoof_host" in params:
136 Desc_Skel["spoof_host"] = params["spoof_host"]
137
138 descriptors.append(create_desc(Desc_Skel, {
139 "name" : "recv_bytes_" + target_device,
140 "units" : "bytes/sec",
141 "description" : "received bytes per sec",
142 }))
143 descriptors.append(create_desc(Desc_Skel, {
144 "name" : "recv_pkts_" + target_device,
145 "units" : "pkts/sec",
146 "description" : "received packets per sec",
147 }))
148 descriptors.append(create_desc(Desc_Skel, {
149 "name" : "recv_errs_" + target_device,
150 "units" : "pkts/sec",
151 "description" : "received error packets per sec",
152 }))
153
154 descriptors.append(create_desc(Desc_Skel, {
155 "name" : "trans_bytes_" + target_device,
156 "units" : "bytes/sec",
157 "description" : "transmitted bytes per sec",
158 }))
159 descriptors.append(create_desc(Desc_Skel, {
160 "name" : "trans_pkts_" + target_device,
161 "units" : "pkts/sec",
162 "description" : "transmitted packets per sec",
163 }))
164 descriptors.append(create_desc(Desc_Skel, {
165 "name" : "trans_errs_" + target_device,
166 "units" : "pkts/sec",
167 "description" : "transmitted error packets per sec",
168 }))
169
170 return descriptors
171
172
173 def create_desc(skel, prop):
174 d = skel.copy()
175 for k, v in prop.iteritems():
176 d[k] = v
177 return d
178
179
180 def metric_of(name):
181 return _Worker_Thread.metric_of(name)
182
183
184 def metric_cleanup():
185 _Worker_Thread.shutdown()
186
187
188 if __name__ == '__main__':
189 try:
190 params = {
191 "target_device": "eth0",
192 "debug" : True,
193 }
194 metric_init(params)
195 while True:
196 for d in descriptors:
197 v = d['call_back'](d['name'])
198 print ('value for %s is ' + d['format']) % (d['name'], v)
199 time.sleep(5)
200 except KeyboardInterrupt:
201 time.sleep(0.2)
202 os._exit(1)
203 except StandardError:
204 print sys.exc_info()[0]
205 os._exit(1)