From e6575041387c49c337c981483c3b4a999bd78f7a Mon Sep 17 00:00:00 2001 From: Faiyaz Ahmed Date: Tue, 5 Dec 2006 21:46:56 +0000 Subject: [PATCH] * Byte limits are in KB when passed or requested via XMLRPC to NM. Bytes otherwise. --- bwmon.py | 67 ++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 41 insertions(+), 26 deletions(-) diff --git a/bwmon.py b/bwmon.py index 4a828a8..ed9cd7b 100755 --- a/bwmon.py +++ b/bwmon.py @@ -54,12 +54,12 @@ default_maxexemptrate = bwlimit.bwmax # 1.5 Mbit or 16.4 GB per day #default_avgexemptrate = 1500000 -# 5.4 Gbyte per day. 5.4 * 1024M * 1024G kbytes +# 5.4 Gbyte per day. 5.4 * 1024 k * 1024M * 1024G # 5.4 Gbyte per day max allowed transfered per recording period -default_ByteMax = 5662310 +default_ByteMax = 5798205850 default_ByteThresh = int(.8 * default_ByteMax) # 16.4 Gbyte per day max allowed transfered per recording period to I2 -default_ExemptByteMax = 17196646 +default_ExemptByteMax = 17609365914 default_ExemptByteThresh = int(.8 * default_ExemptByteMax) @@ -129,25 +129,38 @@ class Slice: vals = nm.query(self.name, [('nm_net_max_rate', self.maxrate), ('nm_net_max_exempt_rate', self.maxexemptrate), - ("nm_net_max_byte", self.ByteMax), - ("nm_net_max_exempt_byte", self.ExemptByteMax), - ("nm_net_max_thresh_byte", int( .8 * self.ByteMax)), - ("nm_net_max_thresh_exempt_byte", int(.8 * self.ExemptByteMax)), + ("nm_net_max_byte", int(self.ByteMax / 1024)), + ("nm_net_max_exempt_byte", int(self.ExemptByteMax / 1024)), + ("nm_net_max_thresh_byte", int( .8 * self.ByteMax / 1024)), + ("nm_net_max_thresh_exempt_byte", int(.8 * self.ExemptByteMax / 1024)), ("nm_net_avg_rate", 0), ("nm_net_avg_exempt_rate", 0)]) (self.maxrate, - self.maxexemptrate, - self.ByteMax, - self.ExemptByteMax, - self.ByteThresh, - self.ExemptByteThresh, - avgrate, - avgexemptrate) = vals - - if (avgrate != 0) or (avgexemptrate != 0): - self.ByteMax = avgrate * period + self.maxexemptrate, + ByteMax, + ExemptByteMax, + ByteThresh, + ExemptByteThresh, + avgrate, + avgexemptrate) = vals + + # The shitty bit. Gotta bias the limits so as not to overflow xmlrpc + self.ByteMax = ByteMax * 1024 + self.ByteThresh = ByteMax * 1024 + self.ExemptByteMax = ExemptByteMax * 1024 + self.ExemptByteThresh = ExemptByteThresh * 1024 + + # The hack here is that when i pass 0 to the xmlrpc request to NM, + # for rate limits and it comes back non zero, then screw the byte limits. + # Mult by the period and recompute the byte limits. The thought is + # If/when PLC switches to byte limits, the avgrates wont be used as + # slice attributes and will return as 0 + if (avgrate != 0): + self.ByteMax = avgrate * period self.ByteThresh = int(self.ByteMax * .8) + + if (avgexemptrate != 0): self.ExemptByteMax = avgexemptrate * period self.ExemptByteThresh = int(self.ExemptByteMax * .8) @@ -173,8 +186,10 @@ class Slice: if (self.maxrate != maxrate) or (self.maxexemptrate != maxexemptrate): print "%s reset to %s/%s" % \ (self.name, - bwlimit.format_tc_rate(self.maxrate), - bwlimit.format_tc_rate(self.maxexemptrate)) + #bwlimit.format_tc_rate(self.maxrate), + self.maxrate, + #bwlimit.format_tc_rate(self.maxexemptrate)) + self.maxexemptrate) bwlimit.set(xid = self.xid, maxrate = self.maxrate, maxexemptrate = self.maxexemptrate) def update(self, maxrate, maxexemptrate, bytes, exemptbytes): @@ -194,9 +209,9 @@ class Slice: 'date': time.asctime(time.gmtime()) + " GMT", 'period': format_period(period)} - if bytes >= (self.bytes + (self.ByteThresh * 1024)): + if bytes >= (self.bytes + self.ByteThresh): new_maxrate = \ - int(((self.ByteMax * 1024) - self.bytes + bytes)/(period - time.time() - self.time)) + int((self.ByteMax - self.bytes + bytes)/(period - time.time() - self.time)) else: new_maxrate = maxrate @@ -204,7 +219,7 @@ class Slice: params['class'] = "low bandwidth" params['bytes'] = format_bytes(bytes - self.bytes) params['maxrate'] = bwlimit.format_tc_rate(maxrate) - params['limit'] = format_bytes(int(self.ByteMax * 1024)) + params['limit'] = format_bytes(self.ByteMax) params['new_maxrate'] = bwlimit.format_tc_rate(new_maxrate) if verbose: @@ -217,9 +232,9 @@ class Slice: message += template % params print "%(slice)s %(class)s capped at %(new_maxrate)s " % params - if exemptbytes >= (self.exemptbytes + (self.ExemptByteThresh * 1024)): + if exemptbytes >= (self.exemptbytes + self.ExemptByteThresh): new_maxexemptrate = \ - int(((self.ExemptByteMax * 1024) - (self.bytes + bytes))/(period - (time.time() - self.time))) + int((self.ExemptByteMax - (self.bytes + bytes))/(period - (time.time() - self.time))) else: new_maxexemptrate = maxexemptrate @@ -227,8 +242,8 @@ class Slice: params['class'] = "high bandwidth" params['bytes'] = format_bytes(exemptbytes - self.exemptbytes) params['maxrate'] = bwlimit.format_tc_rate(maxexemptrate) - params['limit'] = format_bytes(self.ExemptByteMax * 1024) - params['new_maxrate'] = bwlimit.format_tc_rate(new_maxexemptrate) + params['limit'] = format_bytes(self.ExemptByteMax) + params['new_maxexemptrate'] = bwlimit.format_tc_rate(new_maxexemptrate) if verbose: print "%(slice)s %(class)s " \ -- 2.43.0