tweak privatebridge to remove exception message when ovs is not installed - prints...

[nodemanager.git] / bwmon.py

diff --git a/bwmon.py b/bwmon.py
index aba96e3..f4c0133 100644 (file)
--- a/bwmon.py
+++ b/bwmon.py
@@ -14,55 +14,60 @@
 # Faiyaz Ahmed <faiyaza@cs.princeton.edu>
 # Copyright (C) 2004-2008 The Trustees of Princeton University
 #
 # Faiyaz Ahmed <faiyaza@cs.princeton.edu>
 # Copyright (C) 2004-2008 The Trustees of Princeton University
 #

-# $Id$
-#

 
 import os
 import sys
 import time
 import pickle
 import socket
 
 import os
 import sys
 import time
 import pickle
 import socket

-import logger

 import copy
 import threading
 import copy
 import threading

-import tools

 
 

-import bwlimit
+import plnode.bwlimit as bwlimit
+
+import logger
+import tools

 import database
 import database

+from config import Config
+
+priority = 20

 
 

-from sets import Set
+# Defaults
+# Set DEBUG to True if you don't want to send emails
+DEBUG = False
+# Set ENABLE to False to setup buckets, but not limit.
+ENABLE = True

 
 

-try:
-    sys.path.append("/etc/planetlab")
-    from plc_config import *
-except:
-    logger.log("bwmon:  Warning: Configuration file /etc/planetlab/plc_config.py not found")
-    PLC_NAME = "PlanetLab"
-    PLC_SLICE_PREFIX = "pl"
-    PLC_MAIL_SUPPORT_ADDRESS = "support@planet-lab.org"
-    PLC_MAIL_SLICE_ADDRESS = "SLICE@slices.planet-lab.org"
+DB_FILE = "/var/lib/nodemanager/bwmon.pickle"

 
 # Constants
 seconds_per_day = 24 * 60 * 60
 bits_per_byte = 8
 
 
 # Constants
 seconds_per_day = 24 * 60 * 60
 bits_per_byte = 8
 

-# Defaults
-debug = False
-verbose = False
-datafile = "/var/lib/misc/bwmon.dat"
-#nm = None
-
+dev_default = tools.get_default_if()

 # Burst to line rate (or node cap).  Set by NM. in KBit/s
 # Burst to line rate (or node cap).  Set by NM. in KBit/s

-default_MaxRate = int(bwlimit.get_bwcap() / 1000)
+default_MaxRate = int(bwlimit.get_bwcap(dev_default) / 1000)

 default_Maxi2Rate = int(bwlimit.bwmax / 1000)
 default_Maxi2Rate = int(bwlimit.bwmax / 1000)

-# Min rate 8 bits/s 
-default_MinRate = 0
-default_Mini2Rate = 0
-# 5.4 Gbyte per day. 5.4 * 1024 k * 1024M * 1024G 
+# 5.4 Gbyte per day. 5.4 * 1024 k * 1024M * 1024G

 # 5.4 Gbyte per day max allowed transfered per recording period
 # 5.4 Gbyte per day max allowed transfered per recording period

-default_MaxKByte = 5662310
+# 5.4 Gbytes per day is aprox 512k/s for 24hrs (approx because original math was wrong
+# but its better to keep a higher byte total and keep people happy than correct
+# the problem and piss people off.
+# default_MaxKByte = 5662310
+
+# -- 6/1/09
+# llp wants to double these, so we use the following
+# 1mbit * 24hrs * 60mins * 60secs = bits/day
+# 1000000 * 24 * 60 * 60 / (1024 * 8)
+default_MaxKByte = 10546875
+

 # 16.4 Gbyte per day max allowed transfered per recording period to I2
 # 16.4 Gbyte per day max allowed transfered per recording period to I2

-default_Maxi2KByte = 17196646
+# default_Maxi2KByte = 17196646
+
+# -- 6/1/09
+# 3Mb/s for 24hrs a day (30.17 gigs)
+default_Maxi2KByte = 31640625
+

 # Default share quanta
 default_Share = 1
 
 # Default share quanta
 default_Share = 1
 


@@ -130,19 +135,17 @@ def slicemail(slice, subject, body):
     '''
     Front end to sendmail.  Sends email to slice alias with given subject and body.
     '''
     '''
     Front end to sendmail.  Sends email to slice alias with given subject and body.
     '''

+    config = Config()
+    sendmail = os.popen("/usr/sbin/sendmail -N never -t -f%s" % config.PLC_MAIL_SUPPORT_ADDRESS, "w")

 
 

-    sendmail = os.popen("/usr/sbin/sendmail -N never -t -f%s" % PLC_MAIL_SUPPORT_ADDRESS, "w")
-
-    # PLC has a separate list for pl_mom messages
-    if PLC_MAIL_SUPPORT_ADDRESS == "support@planet-lab.org":
-        to = ["pl-mom@planet-lab.org"]
-    else:
-        to = [PLC_MAIL_SUPPORT_ADDRESS]
+    # Parsed from MyPLC config
+    to = [config.PLC_MAIL_MOM_LIST_ADDRESS]

 
     if slice is not None and slice != "root":
 
     if slice is not None and slice != "root":

-        to.append(PLC_MAIL_SLICE_ADDRESS.replace("SLICE", slice))
+        to.append(config.PLC_MAIL_SLICE_ADDRESS.replace("SLICE", slice))

 
 

-    header = {'from': "%s Support <%s>" % (PLC_NAME, PLC_MAIL_SUPPORT_ADDRESS),
+    header = {'from': "%s Support <%s>" % (config.PLC_NAME,
+                                           config.PLC_MAIL_SUPPORT_ADDRESS),

               'to': ", ".join(to),
               'version': sys.version.split(" ")[0],
               'subject': subject}
               'to': ", ".join(to),
               'version': sys.version.split(" ")[0],
               'subject': subject}


@@ -176,9 +179,9 @@ class Slice:
     i2bytes - high bandwidth bytes transmitted at the beginning of the recording period (for I2 -F)
     MaxKByte - total volume of data allowed
     ThreshKbyte - After thresh, cap node to (maxkbyte - bytes)/(time left in period)
     i2bytes - high bandwidth bytes transmitted at the beginning of the recording period (for I2 -F)
     MaxKByte - total volume of data allowed
     ThreshKbyte - After thresh, cap node to (maxkbyte - bytes)/(time left in period)

-    Maxi2KByte - same as MaxKByte, but for i2 
-    Threshi2Kbyte - same as Threshi2KByte, but for i2 
-    MaxRate - max_rate slice attribute. 
+    Maxi2KByte - same as MaxKByte, but for i2
+    Threshi2Kbyte - same as Threshi2KByte, but for i2
+    MaxRate - max_rate slice attribute.

     Maxi2Rate - max_exempt_rate slice attribute.
     Share - Used by Sirius to loan min rates
     Sharei2 - Used by Sirius to loan min rates for i2
     Maxi2Rate - max_exempt_rate slice attribute.
     Share - Used by Sirius to loan min rates
     Sharei2 - Used by Sirius to loan min rates for i2


@@ -193,22 +196,22 @@ class Slice:
         self.bytes = 0
         self.i2bytes = 0
         self.MaxRate = default_MaxRate
         self.bytes = 0
         self.i2bytes = 0
         self.MaxRate = default_MaxRate

-        self.MinRate = default_MinRate 
+        self.MinRate = bwlimit.bwmin / 1000

         self.Maxi2Rate = default_Maxi2Rate
         self.Maxi2Rate = default_Maxi2Rate

-        self.Mini2Rate = default_Mini2Rate
+        self.Mini2Rate = bwlimit.bwmin / 1000

         self.MaxKByte = default_MaxKByte
         self.MaxKByte = default_MaxKByte

-        self.ThreshKByte = (.8 * self.MaxKByte)
+        self.ThreshKByte = int(.8 * self.MaxKByte)

         self.Maxi2KByte = default_Maxi2KByte
         self.Maxi2KByte = default_Maxi2KByte

-        self.Threshi2KByte = (.8 * self.Maxi2KByte)
+        self.Threshi2KByte = int(.8 * self.Maxi2KByte)

         self.Share = default_Share
         self.Sharei2 = default_Share
         self.emailed = False
         self.capped = False
 
         self.Share = default_Share
         self.Sharei2 = default_Share
         self.emailed = False
         self.capped = False
 

-        self.updateSliceAttributes(rspec)
-        bwlimit.set(xid = self.xid, 
-                minrate = self.MinRate * 1000, 
-                maxrate = self.MaxRate * 1000, 
+        self.updateSliceTags(rspec)
+        bwlimit.set(xid = self.xid, dev = dev_default,
+                minrate = self.MinRate * 1000,
+                maxrate = self.MaxRate * 1000,

                 maxexemptrate = self.Maxi2Rate * 1000,
                 minexemptrate = self.Mini2Rate * 1000,
                 share = self.Share)
                 maxexemptrate = self.Maxi2Rate * 1000,
                 minexemptrate = self.Mini2Rate * 1000,
                 share = self.Share)


@@ -216,7 +219,7 @@ class Slice:
     def __repr__(self):
         return self.name
 
     def __repr__(self):
         return self.name
 

-    def updateSliceAttributes(self, rspec):
+    def updateSliceTags(self, rspec):

         '''
         Use respects from GetSlivers to PLC to populate slice object.  Also
         do some sanity checking.
         '''
         Use respects from GetSlivers to PLC to populate slice object.  Also
         do some sanity checking.


@@ -224,90 +227,99 @@ class Slice:
 
         # Sanity check plus policy decision for MinRate:
         # Minrate cant be greater than 25% of MaxRate or NodeCap.
 
         # Sanity check plus policy decision for MinRate:
         # Minrate cant be greater than 25% of MaxRate or NodeCap.

-        MinRate = int(rspec.get("net_min_rate", default_MinRate))
+        MinRate = int(rspec.get("net_min_rate", bwlimit.bwmin / 1000))

         if MinRate > int(.25 * default_MaxRate):
             MinRate = int(.25 * default_MaxRate)
         if MinRate != self.MinRate:
             self.MinRate = MinRate
         if MinRate > int(.25 * default_MaxRate):
             MinRate = int(.25 * default_MaxRate)
         if MinRate != self.MinRate:
             self.MinRate = MinRate

-            logger.log("bwmon:  Updating %s: Min Rate = %s" %(self.name, self.MinRate))
+            logger.log("bwmon: Updating %s: Min Rate = %s" %(self.name, self.MinRate))

 
 

-        MaxRate = int(rspec.get('net_max_rate', bwlimit.get_bwcap() / 1000))
+        MaxRate = int(rspec.get('net_max_rate', default_MaxRate))

         if MaxRate != self.MaxRate:
             self.MaxRate = MaxRate
         if MaxRate != self.MaxRate:
             self.MaxRate = MaxRate

-            logger.log("bwmon:  Updating %s: Max Rate = %s" %(self.name, self.MaxRate))
+            logger.log("bwmon: Updating %s: Max Rate = %s" %(self.name, self.MaxRate))

 
 

-        Mini2Rate = int(rspec.get('net_i2_min_rate', default_Mini2Rate))
+        Mini2Rate = int(rspec.get('net_i2_min_rate', bwlimit.bwmin / 1000))

         if Mini2Rate != self.Mini2Rate:
         if Mini2Rate != self.Mini2Rate:

-            self.Mini2Rate = Mini2Rate 
-            logger.log("bwmon:  Updating %s: Min i2 Rate = %s" %(self.name, self.Mini2Rate))
+            self.Mini2Rate = Mini2Rate
+            logger.log("bwmon: Updating %s: Min i2 Rate = %s" %(self.name, self.Mini2Rate))

 
 

-        Maxi2Rate = int(rspec.get('net_i2_max_rate', bwlimit.bwmax / 1000))
+        Maxi2Rate = int(rspec.get('net_i2_max_rate', default_Maxi2Rate))

         if Maxi2Rate != self.Maxi2Rate:
             self.Maxi2Rate = Maxi2Rate
         if Maxi2Rate != self.Maxi2Rate:
             self.Maxi2Rate = Maxi2Rate

-            logger.log("bwmon:  Updating %s: Max i2 Rate = %s" %(self.name, self.Maxi2Rate))
-                          
+            logger.log("bwmon: Updating %s: Max i2 Rate = %s" %(self.name, self.Maxi2Rate))
+

         MaxKByte = int(rspec.get('net_max_kbyte', default_MaxKByte))
         if MaxKByte != self.MaxKByte:
             self.MaxKByte = MaxKByte
         MaxKByte = int(rspec.get('net_max_kbyte', default_MaxKByte))
         if MaxKByte != self.MaxKByte:
             self.MaxKByte = MaxKByte

-            logger.log("bwmon:  Updating %s: Max KByte lim = %s" %(self.name, self.MaxKByte))
-                          
+            logger.log("bwmon: Updating %s: Max KByte lim = %s" %(self.name, self.MaxKByte))
+

         Maxi2KByte = int(rspec.get('net_i2_max_kbyte', default_Maxi2KByte))
         if Maxi2KByte != self.Maxi2KByte:
             self.Maxi2KByte = Maxi2KByte
         Maxi2KByte = int(rspec.get('net_i2_max_kbyte', default_Maxi2KByte))
         if Maxi2KByte != self.Maxi2KByte:
             self.Maxi2KByte = Maxi2KByte

-            logger.log("bwmon:  Updating %s: Max i2 KByte = %s" %(self.name, self.Maxi2KByte))
-                          
+            logger.log("bwmon: Updating %s: Max i2 KByte = %s" %(self.name, self.Maxi2KByte))
+

         ThreshKByte = int(rspec.get('net_thresh_kbyte', (MaxKByte * .8)))
         if ThreshKByte != self.ThreshKByte:
             self.ThreshKByte = ThreshKByte
         ThreshKByte = int(rspec.get('net_thresh_kbyte', (MaxKByte * .8)))
         if ThreshKByte != self.ThreshKByte:
             self.ThreshKByte = ThreshKByte

-            logger.log("bwmon:  Updating %s: Thresh KByte = %s" %(self.name, self.ThreshKByte))
-                          
+            logger.log("bwmon: Updating %s: Thresh KByte = %s" %(self.name, self.ThreshKByte))
+

         Threshi2KByte = int(rspec.get('net_i2_thresh_kbyte', (Maxi2KByte * .8)))
         Threshi2KByte = int(rspec.get('net_i2_thresh_kbyte', (Maxi2KByte * .8)))

-        if Threshi2KByte != self.Threshi2KByte:    
+        if Threshi2KByte != self.Threshi2KByte:

             self.Threshi2KByte = Threshi2KByte
             self.Threshi2KByte = Threshi2KByte

-            logger.log("bwmon:  Updating %s: i2 Thresh KByte = %s" %(self.name, self.Threshi2KByte))
- 
+            logger.log("bwmon: Updating %s: i2 Thresh KByte = %s" %(self.name, self.Threshi2KByte))
+

         Share = int(rspec.get('net_share', default_Share))
         if Share != self.Share:
             self.Share = Share
         Share = int(rspec.get('net_share', default_Share))
         if Share != self.Share:
             self.Share = Share

-            logger.log("bwmon:  Updating %s: Net Share = %s" %(self.name, self.Share))
+            logger.log("bwmon: Updating %s: Net Share = %s" %(self.name, self.Share))

 
         Sharei2 = int(rspec.get('net_i2_share', default_Share))
         if Sharei2 != self.Sharei2:
 
         Sharei2 = int(rspec.get('net_i2_share', default_Share))
         if Sharei2 != self.Sharei2:

-            self.Sharei2 = Sharei2 
-            logger.log("bwmon:  Updating %s: Net i2 Share = %s" %(self.name, self.i2Share))
+            self.Sharei2 = Sharei2
+            logger.log("bwmon: Updating %s: Net i2 Share = %s" %(self.name, self.i2Share))

 
 
 
 

-    def reset(self, runningmaxrate, runningmaxi2rate, usedbytes, usedi2bytes, rspec):
+    def reset(self, runningrates, rspec):

         """
         Begin a new recording period. Remove caps by restoring limits
         to their default values.
         """
         """
         Begin a new recording period. Remove caps by restoring limits
         to their default values.
         """

-        
+        # Cache share for later comparison
+        self.Share = runningrates.get('share', 1)
+

         # Query Node Manager for max rate overrides
         # Query Node Manager for max rate overrides

-        self.updateSliceAttributes(rspec)    
+        self.updateSliceTags(rspec)

 
         # Reset baseline time
         self.time = time.time()
 
         # Reset baseline byte coutns
 
         # Reset baseline time
         self.time = time.time()
 
         # Reset baseline byte coutns

-        self.bytes = usedbytes
-        self.i2bytes = usedi2bytes
+        self.bytes = runningrates.get('usedbytes', 0)
+        self.i2bytes = runningrates.get('usedi2bytes', 0)

 
 

-        # Reset email 
+        # Reset email

         self.emailed = False
         # Reset flag
         self.capped = False
         # Reset rates.
         self.emailed = False
         # Reset flag
         self.capped = False
         # Reset rates.

-        maxrate = self.MaxRate * 1000 
+        maxrate = self.MaxRate * 1000
+        minrate = self.MinRate * 1000

         maxi2rate = self.Maxi2Rate * 1000
         maxi2rate = self.Maxi2Rate * 1000

-        if (self.MaxRate != runningmaxrate) or (self.Maxi2Rate != runningmaxi2rate):
-            logger.log("bwmon:  %s reset to %s/%s" % \
-                  (self.name,
-                   bwlimit.format_tc_rate(maxrate),
-                   bwlimit.format_tc_rate(maxi2rate)))
-            bwlimit.set(xid = self.xid, 
-                minrate = self.MinRate * 1000, 
-                maxrate = self.MaxRate * 1000, 
+        mini2rate = self.Mini2Rate * 1000
+
+        if (maxrate != runningrates.get('maxrate', 0)) or \
+         (minrate != runningrates.get('maxrate', 0)) or \
+         (maxi2rate != runningrates.get('maxexemptrate', 0)) or \
+         (mini2rate != runningrates.get('minexemptrate', 0)) or \
+         (self.Share != runningrates.get('share', 0)):
+            logger.log("bwmon: %s reset to %s/%s" % \
+                           (self.name,
+                            bwlimit.format_tc_rate(maxrate),
+                            bwlimit.format_tc_rate(maxi2rate)))
+            bwlimit.set(xid = self.xid, dev = dev_default,
+                minrate = self.MinRate * 1000,
+                maxrate = self.MaxRate * 1000,

                 maxexemptrate = self.Maxi2Rate * 1000,
                 minexemptrate = self.Mini2Rate * 1000,
                 share = self.Share)
                 maxexemptrate = self.Maxi2Rate * 1000,
                 minexemptrate = self.Mini2Rate * 1000,
                 share = self.Share)


@@ -324,7 +336,7 @@ class Slice:
                   'date': time.asctime(time.gmtime()) + " GMT",
                   'period': format_period(period)}
 
                   'date': time.asctime(time.gmtime()) + " GMT",
                   'period': format_period(period)}
 

-        if new_maxrate != self.MaxRate:
+        if new_maxrate != (self.MaxRate * 1000):

             # Format template parameters for low bandwidth message
             params['class'] = "low bandwidth"
             params['bytes'] = format_bytes(usedbytes - self.bytes)
             # Format template parameters for low bandwidth message
             params['class'] = "low bandwidth"
             params['bytes'] = format_bytes(usedbytes - self.bytes)


@@ -333,46 +345,44 @@ class Slice:
 
             # Cap low bandwidth burst rate
             message += template % params
 
             # Cap low bandwidth burst rate
             message += template % params

-            logger.log("bwmon:   ** %(slice)s %(class)s capped at %(new_maxrate)s/s " % params)
+            logger.log("bwmon:  ** %(slice)s %(class)s capped at %(new_maxrate)s/s " % params)

 
 

-        if new_maxexemptrate != self.Maxi2Rate:
+        if new_maxexemptrate != (self.Maxi2Rate * 1000):

             # Format template parameters for high bandwidth message
             params['class'] = "high bandwidth"
             params['bytes'] = format_bytes(usedi2bytes - self.i2bytes)
             params['limit'] = format_bytes(self.Maxi2KByte * 1024)
             # Format template parameters for high bandwidth message
             params['class'] = "high bandwidth"
             params['bytes'] = format_bytes(usedi2bytes - self.i2bytes)
             params['limit'] = format_bytes(self.Maxi2KByte * 1024)

-            params['new_maxexemptrate'] = bwlimit.format_tc_rate(new_maxi2rate)
- 
+            params['new_maxrate'] = bwlimit.format_tc_rate(new_maxexemptrate)
+

             message += template % params
             message += template % params

-            logger.log("bwmon:   ** %(slice)s %(class)s capped at %(new_maxrate)s/s " % params)
-       
+            logger.log("bwmon:  ** %(slice)s %(class)s capped at %(new_maxrate)s/s " % params)
+

         # Notify slice
         # Notify slice

-        if message and self.emailed == False:
+        if self.emailed == False:

             subject = "pl_mom capped bandwidth of slice %(slice)s on %(hostname)s" % params
             subject = "pl_mom capped bandwidth of slice %(slice)s on %(hostname)s" % params

-            if debug:
-                logger.log("bwmon:  "+ subject)
-                logger.log("bwmon:  "+ message + (footer % params))
+            if DEBUG:
+                logger.log("bwmon: "+ subject)
+                logger.log("bwmon: "+ message + (footer % params))

             else:
                 self.emailed = True
             else:
                 self.emailed = True

+                logger.log("bwmon: Emailing %s" % self.name)

                 slicemail(self.name, subject, message + (footer % params))
 
 
                 slicemail(self.name, subject, message + (footer % params))
 
 

-    def update(self, runningmaxrate, runningmaxi2rate, usedbytes, usedi2bytes, rspec):
+    def update(self, runningrates, rspec):

         """
         Update byte counts and check if byte thresholds have been
         """
         Update byte counts and check if byte thresholds have been

-        exceeded. If exceeded, cap to  remaining bytes in limit over remaining in period.  
+        exceeded. If exceeded, cap to remaining bytes in limit over remaining time in period.

         Recalculate every time module runs.
         """
         Recalculate every time module runs.
         """

-    
+        # cache share for later comparison
+        runningrates['share'] = self.Share
+

         # Query Node Manager for max rate overrides
         # Query Node Manager for max rate overrides

-        self.updateSliceAttributes(rspec)    
-     
-        # Prepare message parameters from the template
-        #message = ""
-        #params = {'slice': self.name, 'hostname': socket.gethostname(),
-        #          'since': time.asctime(time.gmtime(self.time)) + " GMT",
-        #          'until': time.asctime(time.gmtime(self.time + period)) + " GMT",
-        #          'date': time.asctime(time.gmtime()) + " GMT",
-        #          'period': format_period(period)} 
+        self.updateSliceTags(rspec)
+
+        usedbytes = runningrates['usedbytes']
+        usedi2bytes = runningrates['usedi2bytes']

 
         # Check limits.
         if usedbytes >= (self.bytes + (self.ThreshKByte * 1024)):
 
         # Check limits.
         if usedbytes >= (self.bytes + (self.ThreshKByte * 1024)):


@@ -380,30 +390,18 @@ class Slice:
             maxbyte = self.MaxKByte * 1024
             bytesused = usedbytes - self.bytes
             timeused = int(time.time() - self.time)
             maxbyte = self.MaxKByte * 1024
             bytesused = usedbytes - self.bytes
             timeused = int(time.time() - self.time)

-            # Calcuate new rate.
+            # Calcuate new rate. in bit/s

             new_maxrate = int(((maxbyte - bytesused) * 8)/(period - timeused))
             # Never go under MinRate
             if new_maxrate < (self.MinRate * 1000):
                 new_maxrate = self.MinRate * 1000
             # State information.  I'm capped.
             new_maxrate = int(((maxbyte - bytesused) * 8)/(period - timeused))
             # Never go under MinRate
             if new_maxrate < (self.MinRate * 1000):
                 new_maxrate = self.MinRate * 1000
             # State information.  I'm capped.

-            self.capped = True
+            self.capped += True

         else:
             # Sanity Check
             new_maxrate = self.MaxRate * 1000
         else:
             # Sanity Check
             new_maxrate = self.MaxRate * 1000

-            self.capped = False
-
-        ## Format template parameters for low bandwidth message
-        #params['class'] = "low bandwidth"
-        #params['bytes'] = format_bytes(usedbytes - self.bytes)
-        #params['limit'] = format_bytes(self.MaxKByte * 1024)
-        #params['thresh'] = format_bytes(self.ThreshKByte * 1024)
-        #params['new_maxrate'] = bwlimit.format_tc_rate(new_maxrate)
-
-        # Cap low bandwidth burst rate
-        #if new_maxrate != runningmaxrate:
-        #    message += template % params
-        #    logger.log("bwmon:   ** %(slice)s %(class)s capped at %(new_maxrate)s/s " % params)
-    
+            self.capped += False
+

         if usedi2bytes >= (self.i2bytes + (self.Threshi2KByte * 1024)):
             maxi2byte = self.Maxi2KByte * 1024
             i2bytesused = usedi2bytes - self.i2bytes
         if usedi2bytes >= (self.i2bytes + (self.Threshi2KByte * 1024)):
             maxi2byte = self.Maxi2KByte * 1024
             i2bytesused = usedi2bytes - self.i2bytes


@@ -414,37 +412,31 @@ class Slice:
             if new_maxi2rate < (self.Mini2Rate * 1000):
                 new_maxi2rate = self.Mini2Rate * 1000
             # State information.  I'm capped.
             if new_maxi2rate < (self.Mini2Rate * 1000):
                 new_maxi2rate = self.Mini2Rate * 1000
             # State information.  I'm capped.

-            self.capped = True
+            self.capped += True

         else:
             # Sanity
             new_maxi2rate = self.Maxi2Rate * 1000
         else:
             # Sanity
             new_maxi2rate = self.Maxi2Rate * 1000

-            self.capped = False
-
-        # Format template parameters for high bandwidth message
-        #params['class'] = "high bandwidth"
-        #params['bytes'] = format_bytes(usedi2bytes - self.i2bytes)
-        #params['limit'] = format_bytes(self.Maxi2KByte * 1024)
-        #params['new_maxexemptrate'] = bwlimit.format_tc_rate(new_maxi2rate)
-
-        # Cap high bandwidth burst rate
-        #if new_maxi2rate != runningmaxi2rate:
-        #    message += template % params
-        #    logger.log("bwmon:  %(slice)s %(class)s capped at %(new_maxexemptrate)s/s" % params)
-
-        # Apply parameters
-        if new_maxrate != runningmaxrate or new_maxi2rate != runningmaxi2rate:
-            bwlimit.set(xid = self.xid, maxrate = new_maxrate, maxexemptrate = new_maxi2rate)
+            self.capped += False
+
+        # Check running values against newly calculated values so as not to run tc
+        # unnecessarily
+        if (runningrates['maxrate'] != new_maxrate) or \
+        (runningrates['minrate'] != self.MinRate * 1000) or \
+        (runningrates['maxexemptrate'] != new_maxi2rate) or \
+        ('minexemptrate' in runningrates and runningrates['minexemptrate'] != self.Mini2Rate * 1000) or \
+        (runningrates['share'] != self.Share):
+            # Apply parameters
+            bwlimit.set(xid = self.xid, dev = dev_default,
+                minrate = self.MinRate * 1000,
+                maxrate = new_maxrate,
+                minexemptrate = self.Mini2Rate * 1000,
+                maxexemptrate = new_maxi2rate,
+                share = self.Share)

 
         # Notify slice
 
         # Notify slice

-        if self.capped == True and self.emailed == False:
-            self.notify(newmaxrate, newmaxexemptrate, usedbytes, usedi2bytes)
-        #    subject = "pl_mom capped bandwidth of slice %(slice)s on %(hostname)s" % params
-        #    if debug:
-        #        logger.log("bwmon:  "+ subject)
-        #        logger.log("bwmon:  "+ message + (footer % params))
-        #    else:
-        #        self.emailed = True
-        #        slicemail(self.name, subject, message + (footer % params))
+        if self.capped == True:
+            self.notify(new_maxrate, new_maxi2rate, usedbytes, usedi2bytes)
+

 
 def gethtbs(root_xid, default_xid):
     """
 
 def gethtbs(root_xid, default_xid):
     """


@@ -452,12 +444,12 @@ def gethtbs(root_xid, default_xid):
     Turn off HTBs without names.
     """
     livehtbs = {}
     Turn off HTBs without names.
     """
     livehtbs = {}

-    for params in bwlimit.get():
+    for params in bwlimit.get(dev = dev_default):

         (xid, share,
          minrate, maxrate,
          minexemptrate, maxexemptrate,
          usedbytes, usedi2bytes) = params
         (xid, share,
          minrate, maxrate,
          minexemptrate, maxexemptrate,
          usedbytes, usedi2bytes) = params

-        
+

         name = bwlimit.get_slice(xid)
 
         if (name is None) \
         name = bwlimit.get_slice(xid)
 
         if (name is None) \


@@ -465,8 +457,8 @@ def gethtbs(root_xid, default_xid):
         and (xid != default_xid):
             # Orphaned (not associated with a slice) class
             name = "%d?" % xid
         and (xid != default_xid):
             # Orphaned (not associated with a slice) class
             name = "%d?" % xid

-            logger.log("bwmon:  Found orphaned HTB %s. Removing." %name)
-            bwlimit.off(xid)
+            logger.log("bwmon: Found orphaned HTB %s. Removing." %name)
+            bwlimit.off(xid, dev = dev_default)

 
         livehtbs[xid] = {'share': share,
             'minrate': minrate,
 
         livehtbs[xid] = {'share': share,
             'minrate': minrate,


@@ -474,46 +466,48 @@ def gethtbs(root_xid, default_xid):
             'maxexemptrate': maxexemptrate,
             'minexemptrate': minexemptrate,
             'usedbytes': usedbytes,
             'maxexemptrate': maxexemptrate,
             'minexemptrate': minexemptrate,
             'usedbytes': usedbytes,

-            'name': name, 
+            'name': name,

             'usedi2bytes': usedi2bytes}
 
     return livehtbs
 
 def sync(nmdbcopy):
     """
             'usedi2bytes': usedi2bytes}
 
     return livehtbs
 
 def sync(nmdbcopy):
     """

-    Syncs tc, db, and bwmon.dat.  Then, starts new slices, kills old ones, and updates byte accounts for each running slice.  Sends emails and caps those that went over their limit.
+    Syncs tc, db, and bwmon.pickle.
+    Then, starts new slices, kills old ones, and updates byte accounts for each running slice.
+    Sends emails and caps those that went over their limit.

     """
     # Defaults
     """
     # Defaults

-    global datafile, \
+    global DB_FILE, \

         period, \
         default_MaxRate, \
         default_Maxi2Rate, \
         period, \
         default_MaxRate, \
         default_Maxi2Rate, \

-        default_MinRate, \

         default_MaxKByte,\
         default_MaxKByte,\

-        default_ThreshKByte,\

         default_Maxi2KByte,\
         default_Maxi2KByte,\

-        default_Threshi2KByte,\
-        default_Share,\
-        verbose
+        default_Share, \
+        dev_default

 
     # All slices
     names = []
 
     # All slices
     names = []

-    # Incase the limits have changed. 
-    default_MaxRate = int(bwlimit.get_bwcap() / 1000)
+    # In case the limits have changed.
+    default_MaxRate = int(bwlimit.get_bwcap(dev_default) / 1000)

     default_Maxi2Rate = int(bwlimit.bwmax / 1000)
 
     # Incase default isn't set yet.
     if default_MaxRate == -1:
         default_MaxRate = 1000000
 
     default_Maxi2Rate = int(bwlimit.bwmax / 1000)
 
     # Incase default isn't set yet.
     if default_MaxRate == -1:
         default_MaxRate = 1000000
 

+    # xxx $Id$ 
+    # with svn we used to have a trick to detect upgrades of this file
+    # this has gone with the move to git, without any noticeable effect on operations though

     try:
     try:

-        f = open(datafile, "r+")
-        logger.log("bwmon:  Loading %s" % datafile)
+        f = open(DB_FILE, "r+")
+        logger.verbose("bwmon: Loading %s" % DB_FILE)

         (version, slices, deaddb) = pickle.load(f)
         f.close()
         # Check version of data file
         if version != "$Id$":
         (version, slices, deaddb) = pickle.load(f)
         f.close()
         # Check version of data file
         if version != "$Id$":

-            logger.log("bwmon:  Not using old version '%s' data file %s" % (version, datafile))
+            logger.log("bwmon: Not using old version '%s' data file %s" % (version, DB_FILE))

             raise Exception
     except Exception:
         version = "$Id$"
             raise Exception
     except Exception:
         version = "$Id$"


@@ -524,16 +518,16 @@ def sync(nmdbcopy):
     root_xid = bwlimit.get_xid("root")
     default_xid = bwlimit.get_xid("default")
 
     root_xid = bwlimit.get_xid("root")
     default_xid = bwlimit.get_xid("default")
 

-    # Since root is required for sanity, its not in the API/plc database, so pass {} 
+    # Since root is required for sanity, its not in the API/plc database, so pass {}

     # to use defaults.
     if root_xid not in slices.keys():
         slices[root_xid] = Slice(root_xid, "root", {})
     # to use defaults.
     if root_xid not in slices.keys():
         slices[root_xid] = Slice(root_xid, "root", {})

-        slices[root_xid].reset(0, 0, 0, 0, {})
-    
+        slices[root_xid].reset({}, {})
+

     # Used by bwlimit.  pass {} since there is no rspec (like above).
     if default_xid not in slices.keys():
         slices[default_xid] = Slice(default_xid, "default", {})
     # Used by bwlimit.  pass {} since there is no rspec (like above).
     if default_xid not in slices.keys():
         slices[default_xid] = Slice(default_xid, "default", {})

-        slices[default_xid].reset(0, 0, 0, 0, {})
+        slices[default_xid].reset({}, {})

 
     live = {}
     # Get running slivers that should be on this node (from plc). {xid: name}
 
     live = {}
     # Get running slivers that should be on this node (from plc). {xid: name}


@@ -541,40 +535,42 @@ def sync(nmdbcopy):
     for plcSliver in nmdbcopy.keys():
         live[bwlimit.get_xid(plcSliver)] = nmdbcopy[plcSliver]
 
     for plcSliver in nmdbcopy.keys():
         live[bwlimit.get_xid(plcSliver)] = nmdbcopy[plcSliver]
 

-    logger.log("bwmon:  Found %s instantiated slices" % live.keys().__len__())
-    logger.log("bwmon:  Found %s slices in dat file" % slices.values().__len__())
+    logger.verbose("bwmon: Found %s instantiated slices" % live.keys().__len__())
+    logger.verbose("bwmon: Found %s slices in dat file" % slices.values().__len__())

 
     # Get actual running values from tc.
     # Update slice totals and bandwidth. {xid: {values}}
     kernelhtbs = gethtbs(root_xid, default_xid)
 
     # Get actual running values from tc.
     # Update slice totals and bandwidth. {xid: {values}}
     kernelhtbs = gethtbs(root_xid, default_xid)

-    logger.log("bwmon:  Found %s running HTBs" % kernelhtbs.keys().__len__())
+    logger.verbose("bwmon: Found %s running HTBs" % kernelhtbs.keys().__len__())

 
     # The dat file has HTBs for slices, but the HTBs aren't running
 
     # The dat file has HTBs for slices, but the HTBs aren't running

-    nohtbslices =  Set(slices.keys()) - Set(kernelhtbs.keys())
-    logger.log( "bwmon:  Found %s slices in dat but not running." % nohtbslices.__len__() )
+    nohtbslices =  set(slices.keys()) - set(kernelhtbs.keys())
+    logger.verbose( "bwmon: Found %s slices in dat but not running." % nohtbslices.__len__())

     # Reset tc counts.
     for nohtbslice in nohtbslices:
     # Reset tc counts.
     for nohtbslice in nohtbslices:

-        if live.has_key(nohtbslice): 
-            slices[nohtbslice].reset( 0, 0, 0, 0, live[nohtbslice]['_rspec'] )
+        if live.has_key(nohtbslice):
+            slices[nohtbslice].reset( {}, live[nohtbslice]['_rspec'] )
+        else:
+            logger.log("bwmon: Removing abondoned slice %s from dat." % nohtbslice)
+            del slices[nohtbslice]

 
     # The dat file doesnt have HTB for the slice but kern has HTB
 
     # The dat file doesnt have HTB for the slice but kern has HTB

-    slicesnodat = Set(kernelhtbs.keys()) - Set(slices.keys())
-    logger.log( "bwmon: Found %s slices with HTBs but not in dat" % slicesnodat.__len__() )
+    slicesnodat = set(kernelhtbs.keys()) - set(slices.keys())
+    logger.verbose( "bwmon: Found %s slices with HTBs but not in dat" % slicesnodat.__len__())

     for slicenodat in slicesnodat:
     for slicenodat in slicesnodat:

-        # But slice is running 
-        if live.has_key(slicenodat): 
+        # But slice is running
+        if live.has_key(slicenodat):

             # init the slice.  which means start accounting over since kernel
             # htb was already there.
             # init the slice.  which means start accounting over since kernel
             # htb was already there.

-            slices[slicenodat] = Slice(slicenodat, 
-                live[slicenodat]['name'], 
+            slices[slicenodat] = Slice(slicenodat,
+                live[slicenodat]['name'],

                 live[slicenodat]['_rspec'])
                 live[slicenodat]['_rspec'])

-        else: bwlimit.off(slicenodat) # Abandoned.  it doesnt exist at PLC or the dat

 
     # Get new slices.
     # Slices in GetSlivers but not running HTBs
 
     # Get new slices.
     # Slices in GetSlivers but not running HTBs

-    newslicesxids = Set(live.keys()) - Set(kernelhtbs.keys())
-    logger.log("bwmon:  Found %s new slices" % newslicesxids.__len__())
-       
+    newslicesxids = set(live.keys()) - set(kernelhtbs.keys())
+    logger.verbose("bwmon: Found %s new slices" % newslicesxids.__len__())
+

     # Setup new slices
     for newslice in newslicesxids:
         # Delegated slices dont have xids (which are uids) since they haven't been
     # Setup new slices
     for newslice in newslicesxids:
         # Delegated slices dont have xids (which are uids) since they haven't been


@@ -582,11 +578,11 @@ def sync(nmdbcopy):
         if newslice != None and live[newslice].has_key('_rspec') == True:
             # Check to see if we recently deleted this slice.
             if live[newslice]['name'] not in deaddb.keys():
         if newslice != None and live[newslice].has_key('_rspec') == True:
             # Check to see if we recently deleted this slice.
             if live[newslice]['name'] not in deaddb.keys():

-                logger.log( "bwmon: New Slice %s" % live[newslice]['name'] )
+                logger.log( "bwmon: new slice %s" % live[newslice]['name'] )

                 # _rspec is the computed rspec:  NM retrieved data from PLC, computed loans
                 # and made a dict of computed values.
                 slices[newslice] = Slice(newslice, live[newslice]['name'], live[newslice]['_rspec'])
                 # _rspec is the computed rspec:  NM retrieved data from PLC, computed loans
                 # and made a dict of computed values.
                 slices[newslice] = Slice(newslice, live[newslice]['name'], live[newslice]['_rspec'])

-                slices[newslice].reset( 0, 0, 0, 0, live[newslice]['_rspec'] )
+                slices[newslice].reset( {}, live[newslice]['_rspec'] )

             # Double check time for dead slice in deaddb is within 24hr recording period.
             elif (time.time() <= (deaddb[live[newslice]['name']]['slice'].time + period)):
                 deadslice = deaddb[live[newslice]['name']]
             # Double check time for dead slice in deaddb is within 24hr recording period.
             elif (time.time() <= (deaddb[live[newslice]['name']]['slice'].time + period)):
                 deadslice = deaddb[live[newslice]['name']]


@@ -594,57 +590,59 @@ def sync(nmdbcopy):
                 slices[newslice] = deadslice['slice']
                 slices[newslice].xid = newslice
                 # Start the HTB
                 slices[newslice] = deadslice['slice']
                 slices[newslice].xid = newslice
                 # Start the HTB

-                slices[newslice].reset(deadslice['slice'].MaxRate,
-                                    deadslice['slice'].Maxi2Rate,
-                                    deadslice['htb']['usedbytes'],
-                                    deadslice['htb']['usedi2bytes'],
-                                    live[newslice]['_rspec'])
+                newvals = {"maxrate": deadslice['slice'].MaxRate * 1000,
+                            "minrate": deadslice['slice'].MinRate * 1000,
+                            "maxexemptrate": deadslice['slice'].Maxi2Rate * 1000,
+                            "usedbytes": deadslice['htb']['usedbytes'] * 1000,
+                            "usedi2bytes": deadslice['htb']['usedi2bytes'],
+                            "share":deadslice['htb']['share']}
+                slices[newslice].reset(newvals, live[newslice]['_rspec'])

                 # Bring up to date
                 # Bring up to date

-                slices[newslice].update(deadslice['slice'].MaxRate, 
-                                    deadslice['slice'].Maxi2Rate, 
-                                    deadslice['htb']['usedbytes'], 
-                                    deadslice['htb']['usedi2bytes'], 
-                                    live[newslice]['_rspec'])
+                slices[newslice].update(newvals, live[newslice]['_rspec'])

                 # Since the slice has been reinitialed, remove from dead database.
                 # Since the slice has been reinitialed, remove from dead database.

-                del deaddb[deadslice]
+                del deaddb[deadslice['slice'].name]
+                del newvals

         else:
         else:

-            logger.log("bwmon  Slice %s doesn't have xid.  Must be delegated."\
-                       "Skipping." % live[newslice]['name'])
+            logger.log("bwmon: Slice %s doesn't have xid.  Skipping." % live[newslice]['name'])

 
     # Move dead slices that exist in the pickle file, but
     # aren't instantiated by PLC into the dead dict until
     # recording period is over.  This is to avoid the case where a slice is dynamically created
     # and destroyed then recreated to get around byte limits.
 
     # Move dead slices that exist in the pickle file, but
     # aren't instantiated by PLC into the dead dict until
     # recording period is over.  This is to avoid the case where a slice is dynamically created
     # and destroyed then recreated to get around byte limits.

-    deadxids = Set(slices.keys()) - Set(live.keys())
-    logger.log("bwmon:  Found %s dead slices" % (deadxids.__len__() - 2))
+    deadxids = set(slices.keys()) - set(live.keys())
+    logger.verbose("bwmon: Found %s dead slices" % (deadxids.__len__() - 2))

     for deadxid in deadxids:
         if deadxid == root_xid or deadxid == default_xid:
             continue
     for deadxid in deadxids:
         if deadxid == root_xid or deadxid == default_xid:
             continue

-        logger.log("bwmon:  removing dead slice  %s " % deadxid)
-        if slices.has_key(deadxid):
+        logger.log("bwmon: removing dead slice %s " % deadxid)
+        if slices.has_key(deadxid) and kernelhtbs.has_key(deadxid):

             # add slice (by name) to deaddb
             # add slice (by name) to deaddb

+            logger.log("bwmon: Saving bandwidth totals for %s." % slices[deadxid].name)

             deaddb[slices[deadxid].name] = {'slice': slices[deadxid], 'htb': kernelhtbs[deadxid]}
             del slices[deadxid]
             deaddb[slices[deadxid].name] = {'slice': slices[deadxid], 'htb': kernelhtbs[deadxid]}
             del slices[deadxid]

-        if kernelhtbs.has_key(deadxid): 
-            bwlimit.off(deadxid)
-       
-       # Clean up deaddb
-       for (deadslice, deadhtb) in deaddb.iteritems():
-               if (time.time() >= (deadslice.time() + period)):
-                       logger.log("bwmon: Removing dead slice %s from dat." % deadslice.name)
-                       del deaddb[deadslice.name]
+        if kernelhtbs.has_key(deadxid):
+            logger.verbose("bwmon: Removing HTB for %s." % deadxid)
+            bwlimit.off(deadxid, dev = dev_default)
+
+    # Clean up deaddb
+    for deadslice in deaddb.keys():
+        if (time.time() >= (deaddb[deadslice]['slice'].time + period)):
+            logger.log("bwmon: Removing dead slice %s from dat." \
+                        % deaddb[deadslice]['slice'].name)
+            del deaddb[deadslice]

 
     # Get actual running values from tc since we've added and removed buckets.
     # Update slice totals and bandwidth. {xid: {values}}
     kernelhtbs = gethtbs(root_xid, default_xid)
 
     # Get actual running values from tc since we've added and removed buckets.
     # Update slice totals and bandwidth. {xid: {values}}
     kernelhtbs = gethtbs(root_xid, default_xid)

-    logger.log("bwmon:  now %s running HTBs" % kernelhtbs.keys().__len__())
+    logger.verbose("bwmon: now %s running HTBs" % kernelhtbs.keys().__len__())

 
 

+    # Update all byte limites on all slices

     for (xid, slice) in slices.iteritems():
         # Monitor only the specified slices
         if xid == root_xid or xid == default_xid: continue
         if names and name not in names:
             continue
     for (xid, slice) in slices.iteritems():
         # Monitor only the specified slices
         if xid == root_xid or xid == default_xid: continue
         if names and name not in names:
             continue

- 
+

         if (time.time() >= (slice.time + period)) or \
             (kernelhtbs[xid]['usedbytes'] < slice.bytes) or \
             (kernelhtbs[xid]['usedi2bytes'] < slice.i2bytes):
         if (time.time() >= (slice.time + period)) or \
             (kernelhtbs[xid]['usedbytes'] < slice.bytes) or \
             (kernelhtbs[xid]['usedi2bytes'] < slice.i2bytes):


@@ -652,41 +650,70 @@ def sync(nmdbcopy):
             # that the byte counters have overflowed (or, more
             # likely, the node was restarted or the HTB buckets
             # were re-initialized).
             # that the byte counters have overflowed (or, more
             # likely, the node was restarted or the HTB buckets
             # were re-initialized).

-            slice.reset(kernelhtbs[xid]['maxrate'], \
-                kernelhtbs[xid]['maxexemptrate'], \
-                kernelhtbs[xid]['usedbytes'], \
-                kernelhtbs[xid]['usedi2bytes'], \
-                live[xid]['_rspec'])
-        else:
-            if debug:  logger.log("bwmon: Updating slice %s" % slice.name)
+            slice.reset(kernelhtbs[xid], live[xid]['_rspec'])
+        elif ENABLE:
+            logger.verbose("bwmon: Updating slice %s" % slice.name)

             # Update byte counts
             # Update byte counts

-            slice.update(kernelhtbs[xid]['maxrate'], \
-                kernelhtbs[xid]['maxexemptrate'], \
-                kernelhtbs[xid]['usedbytes'], \
-                kernelhtbs[xid]['usedi2bytes'], \
-                live[xid]['_rspec'])
-
-    logger.log("bwmon:  Saving %s slices in %s" % (slices.keys().__len__(),datafile))
-    f = open(datafile, "w")
+            slice.update(kernelhtbs[xid], live[xid]['_rspec'])
+
+    logger.verbose("bwmon: Saving %s slices in %s" % (slices.keys().__len__(),DB_FILE))
+    f = open(DB_FILE, "w")

     pickle.dump((version, slices, deaddb), f)
     f.close()
 
     pickle.dump((version, slices, deaddb), f)
     f.close()
 

+# doesnt use generic default interface because this runs as its own thread.
+# changing the config variable will not have an effect since GetSlivers: pass
+def getDefaults(nmdbcopy):
+    '''
+    Get defaults from default slice's slice attributes.
+    '''
+    status = True
+    # default slice
+    dfltslice = nmdbcopy.get(Config().PLC_SLICE_PREFIX+"_default")
+    if dfltslice:
+        if dfltslice['rspec']['net_max_rate'] == -1:
+            allOff()
+            status = False
+    return status
+
+
+def allOff():
+    """
+    Turn off all slice HTBs
+    """
+    # Get/set special slice IDs
+    root_xid = bwlimit.get_xid("root")
+    default_xid = bwlimit.get_xid("default")
+    kernelhtbs = gethtbs(root_xid, default_xid)
+    if len(kernelhtbs):
+        logger.log("bwmon: Disabling all running HTBs.")
+        for htb in kernelhtbs.keys(): bwlimit.off(htb, dev = dev_default)
+
+

 lock = threading.Event()
 def run():
 lock = threading.Event()
 def run():

-    """When run as a thread, wait for event, lock db, deep copy it, release it, run bwmon.GetSlivers(), then go back to waiting."""
-    if debug:  logger.log("bwmon:  Thread started")
+    """
+    When run as a thread, wait for event, lock db, deep copy it, release it,
+    run bwmon.GetSlivers(), then go back to waiting.
+    """
+    logger.verbose("bwmon: Thread started")

     while True:
         lock.wait()
     while True:
         lock.wait()

-        if debug: logger.log("bwmon:  Event received.  Running.")
+        logger.verbose("bwmon: Event received.  Running.")

         database.db_lock.acquire()
         nmdbcopy = copy.deepcopy(database.db)
         database.db_lock.release()
         database.db_lock.acquire()
         nmdbcopy = copy.deepcopy(database.db)
         database.db_lock.release()

-        try:  sync(nmdbcopy)
-        except: logger.log_exc()
+        try:
+            if getDefaults(nmdbcopy) and len(bwlimit.tc("class show dev %s" % dev_default)) > 0:
+                # class show to check if net:InitNodeLimit:bwlimit.init has run.
+                sync(nmdbcopy)
+            else: logger.log("bwmon: BW limits DISABLED.")
+        except: logger.log_exc("bwmon failed")

         lock.clear()
 
 def start(*args):
     tools.as_daemon_thread(run)
 
 def GetSlivers(*args):
         lock.clear()
 
 def start(*args):
     tools.as_daemon_thread(run)
 
 def GetSlivers(*args):

+    logger.verbose ("bwmon: triggering dummy GetSlivers")

     pass
     pass