* Byte limits are in KB when passed or requested via XMLRPC to NM. Bytes otherwise.

diff --git a/bwmon.py b/bwmon.py
index 4a828a8..ed9cd7b 100755 (executable)
--- 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 " \