# Faiyaz Ahmed <faiyaza@cs.princeton.edu>
# Copyright (C) 2004-2006 The Trustees of Princeton University
#
-# $Id: bwmon.py,v 1.20 2007/01/10 16:51:04 faiyaza Exp $
+# $Id: bwmon.py,v 1.1.2.4 2007/02/27 23:30:05 faiyaza Exp $
#
import os
import sys
import time
import pickle
-import database
import socket
#import xmlrpclib
# Defaults
debug = False
-verbose = 0
+verbose = False
datafile = "/var/lib/misc/bwmon.dat"
#nm = None
-# Burst to line rate (or node cap). Set by NM.
-default_MaxRate = bwlimit.get_bwcap()
-default_Maxi2Rate = bwlimit.bwmax
+# Burst to line rate (or node cap). Set by NM. in KBit/s
+default_MaxRate = int(bwlimit.get_bwcap() / 1000)
+default_Maxi2Rate = int(bwlimit.bwmax / 1000)
# Min rate 8 bits/s
default_MinRate = 0
default_Mini2Rate = 0
self.bytes = 0
self.i2bytes = 0
self.MaxRate = default_MaxRate
- self.MinRate = default_MinRate
+ self.MinRate = default_MinRate
self.Maxi2Rate = default_Maxi2Rate
self.Mini2Rate = default_Mini2Rate
self.MaxKByte = default_MaxKByte
self.updateSliceAttributes(data)
bwlimit.set(xid = self.xid,
- minrate = self.MinRate,
- maxrate = self.MaxRate,
- maxexemptrate = self.Maxi2Rate,
- minexemptrate = self.Mini2Rate,
+ minrate = self.MinRate * 1000,
+ maxrate = self.MaxRate * 1000,
+ maxexemptrate = self.Maxi2Rate * 1000,
+ minexemptrate = self.Mini2Rate * 1000,
share = self.Share)
def __repr__(self):
return self.name
- @database.synchronized
def updateSliceAttributes(self, data):
+ # Incase the limits have changed.
+ if (self.MaxRate != default_MaxRate) or \
+ (self.Maxi2Rate != default_Maxi2Rate):
+ self.MaxRate = int(bwlimit.get_bwcap() / 1000)
+ self.Maxi2Rate = int(bwlimit.bwmax / 1000)
+
+ # Get attributes
for sliver in data['slivers']:
if sliver['name'] == self.name:
for attribute in sliver['attributes']:
if attribute['name'] == 'net_min_rate':
- self.MinRate = attribute['value']
- logger.log("bwmon: Updating %s. Min Rate - %s" \
+ logger.log("bwmon: Updating %s. Min Rate = %s" \
%(self.name, self.MinRate))
+ # To ensure min does not go above 25% of nodecap.
+ if int(attribute['value']) > int(.25 * default_MaxRate):
+ self.MinRate = int(.25 * default_MaxRate)
+ else:
+ self.MinRate = int(attribute['value'])
elif attribute['name'] == 'net_max_rate':
- self.MaxRate = attribute['value']
- logger.log("bwmon: Updating %s. Max Rate - %s" \
+ self.MaxRate = int(attribute['value'])
+ logger.log("bwmon: Updating %s. Max Rate = %s" \
%(self.name, self.MaxRate))
elif attribute['name'] == 'net_i2_min_rate':
- self.Mini2Rate = attribute['value']
- logger.log("bwmon: Updating %s. Min i2 Rate - %s" \
+ self.Mini2Rate = int(attribute['value'])
+ logger.log("bwmon: Updating %s. Min i2 Rate = %s" \
%(self.name, self.Mini2Rate))
elif attribute['name'] == 'net_i2_max_rate':
- self.Maxi2Rate = attribute['value']
- logger.log("bwmon: Updating %s. Max i2 Rate - %s" \
+ self.Maxi2Rate = int(attribute['value'])
+ logger.log("bwmon: Updating %s. Max i2 Rate = %s" \
%(self.name, self.Maxi2Rate))
elif attribute['name'] == 'net_max_kbyte':
- self.MaxKByte = attribute['value']
- logger.log("bwmon: Updating %s. Max KByte lim - %s" \
+ self.MaxKByte = int(attribute['value'])
+ logger.log("bwmon: Updating %s. Max KByte lim = %s" \
%(self.name, self.MaxKByte))
elif attribute['name'] == 'net_i2_max_kbyte':
- self.Maxi2KByte = attribute['value']
- logger.log("bwmon: Updating %s. Max i2 KByte - %s" \
+ self.Maxi2KByte = int(attribute['value'])
+ logger.log("bwmon: Updating %s. Max i2 KByte = %s" \
%(self.name, self.Maxi2KByte))
elif attribute['name'] == 'net_thresh_kbyte':
- self.ThreshKByte = attribute['value']
- logger.log("bwmon: Updating %s. Thresh KByte - %s" \
+ self.ThreshKByte = int(attribute['value'])
+ logger.log("bwmon: Updating %s. Thresh KByte = %s" \
%(self.name, self.ThreshKByte))
elif attribute['name'] == 'net_i2_thresh_kbyte':
- self.Threshi2KByte = attribute['value']
- logger.log("bwmon: Updating %s. i2 Thresh KByte - %s" \
+ self.Threshi2KByte = int(attribute['value'])
+ logger.log("bwmon: Updating %s. i2 Thresh KByte = %s" \
%(self.name, self.Threshi2KByte))
elif attribute['name'] == 'net_share':
- self.Share = attribute['value']
- logger.log("bwmon: Updating %s. Net Share - %s" \
+ self.Share = int(attribute['value'])
+ logger.log("bwmon: Updating %s. Net Share = %s" \
%(self.name, self.Share))
elif attribute['name'] == 'net_i2_share':
- self.Sharei2 = attribute['value']
- logger.log("bwmon: Updating %s. Net i2 Share - %s" \
+ self.Sharei2 = int(attribute['value'])
+ logger.log("bwmon: Updating %s. Net i2 Share = %s" \
%(self.name, self.i2Share))
# Reset email
self.emailed = False
-
+ maxrate = self.MaxRate * 1000
+ maxi2rate = self.Maxi2Rate * 1000
# Reset rates.
if (self.MaxRate != runningmaxrate) or (self.Maxi2Rate != runningmaxi2rate):
logger.log("bwmon: %s reset to %s/%s" % \
(self.name,
- bwlimit.format_tc_rate(self.MaxRate),
- bwlimit.format_tc_rate(self.Maxi2Rate)))
+ bwlimit.format_tc_rate(maxrate),
+ bwlimit.format_tc_rate(maxi2rate)))
bwlimit.set(xid = self.xid,
- minrate = self.MinRate,
- maxrate = self.MaxRate,
- maxexemptrate = self.Maxi2Rate,
- minexemptrate = self.Mini2Rate,
+ minrate = self.MinRate * 1000,
+ maxrate = self.MaxRate * 1000,
+ maxexemptrate = self.Maxi2Rate * 1000,
+ minexemptrate = self.Mini2Rate * 1000,
share = self.Share)
def update(self, runningmaxrate, runningmaxi2rate, usedbytes, usedi2bytes, data):
'period': format_period(period)}
if usedbytes >= (self.bytes + (self.ThreshKByte * 1024)):
+ sum = self.bytes + (self.ThreshKBytes * 1024)
maxbyte = self.MaxKByte * 1024
- bytesused = bytes - self.bytes
+ bytesused = usedbytes - self.bytes
timeused = int(time.time() - self.time)
new_maxrate = int(((maxbyte - bytesused) * 8)/(period - timeused))
- if new_maxrate < self.MinRate:
- new_maxrate = self.MinRate
+ if new_maxrate < (self.MinRate * 1000):
+ new_maxrate = self.MinRate * 1000
else:
- new_maxrate = self.MaxRate
+ new_maxrate = self.MaxRate * 1000
# Format template parameters for low bandwidth message
params['class'] = "low bandwidth"
params['bytes'] = format_bytes(usedbytes - self.bytes)
- params['maxrate'] = bwlimit.format_tc_rate(runningmaxrate)
params['limit'] = format_bytes(self.MaxKByte * 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)
+ logger.log("bwmon: ** %(slice)s %(class)s capped at %(new_maxrate)s/s " % params)
if usedi2bytes >= (self.i2bytes + (self.Threshi2KByte * 1024)):
maxi2byte = self.Maxi2KByte * 1024
- i2bytesused = i2bytes - self.i2bytes
+ i2bytesused = usedi2bytes - self.i2bytes
timeused = int(time.time() - self.time)
new_maxi2rate = int(((maxi2byte - i2bytesused) * 8)/(period - timeused))
- if new_maxi2rate < self.Mini2Rate:
- new_maxi2rate = self.Mini2Rate
+ if new_maxi2rate < (self.Mini2Rate * 1000):
+ new_maxi2rate = self.Mini2Rate * 1000
else:
- new_maxi2rate = self.Maxi2Rate
+ new_maxi2rate = self.Maxi2Rate * 1000
# Format template parameters for high bandwidth message
params['class'] = "high bandwidth"
params['bytes'] = format_bytes(usedi2bytes - self.i2bytes)
- params['maxrate'] = bwlimit.format_tc_rate(runningmaxi2rate)
params['limit'] = format_bytes(self.Maxi2KByte * 1024)
params['new_maxexemptrate'] = bwlimit.format_tc_rate(new_maxi2rate)
default_Share,\
verbose
- verbose = True
# All slices
names = []
+ # Incase the limits have changed.
+ default_MaxRate = int(bwlimit.get_bwcap() / 1000)
+ default_Maxi2Rate = int(bwlimit.bwmax / 1000)
+
+ # Incase default isn't set yet.
+ if default_MaxRate == -1:
+ default_MaxRate = 1000000
+
try:
f = open(datafile, "r+")
- if verbose:
- logger.log("bwmon: Loading %s" % datafile)
+ logger.log("bwmon: Loading %s" % datafile)
(version, slices) = pickle.load(f)
f.close()
# Check version of data file
- if version != "$Id: bwmon.py,v 1.20 2007/01/10 16:51:04 faiyaza Exp $":
+ if version != "$Id: bwmon.py,v 1.1.2.4 2007/02/27 23:30:05 faiyaza Exp $":
logger.log("bwmon: Not using old version '%s' data file %s" % (version, datafile))
raise Exception
except Exception:
- version = "$Id: bwmon.py,v 1.20 2007/01/10 16:51:04 faiyaza Exp $"
+ version = "$Id: bwmon.py,v 1.1.2.4 2007/02/27 23:30:05 faiyaza Exp $"
slices = {}
# Get/set special slice IDs
live[bwlimit.get_xid(sliver['name'])] = sliver['name']
# Setup new slices.
+ # live.xids - runing.xids = new.xids
newslicesxids = Set(live.keys()) - Set(slices.keys())
for newslicexid in newslicesxids:
- logger.log("bwmon: New Slice %s" % live[newslicexid])
- slices[newslicexid] = Slice(newslicexid, live[newslicexid], data)
- slices[newslicexid].reset(0, 0, 0, 0, data)
-
+ if newslicexid != None:
+ logger.log("bwmon: New Slice %s" % live[newslicexid])
+ slices[newslicexid] = Slice(newslicexid, live[newslicexid], data)
+ slices[newslicexid].reset(0, 0, 0, 0, data)
+ else:
+ logger.log("bwmon Slice %s doesn't have xid. Must be delegated. Skipping." % live[newslicexid])
# Get actual running values from tc.
# Update slice totals and bandwidth.
for params in bwlimit.get():
else:
# Just in case. Probably (hopefully) this will never happen.
# New slice, initialize state
- if verbose:
- logger.log("bwmon: New Slice %s" % name)
+ logger.log("bwmon: New Slice %s" % name)
slice = slices[xid] = Slice(xid, name, data)
slice.reset(maxrate, maxexemptrate, usedbytes, usedi2bytes, data)
# Delete dead slices
dead = Set(slices.keys()) - Set(live.keys())
for xid in dead:
+ if xid == root_xid or xid == default_xid:
+ continue
del slices[xid]
bwlimit.off(xid)
git://git.onelab.eu / nodemanager.git / blobdiff