def input_measurement(self, consistency_check_on):
if self.status != False:
if not self.newDB_flag:
if self.table.dx != 2:
errMsg("Dimension do not match:\nRequired: %d Actual: %d\n" % ( 2, self.table.dx))
self.status=False
if self.status != False:
# determine local time for the local timezone
t1 = datetime.datetime(1970, 01, 01, 0, 0, 0) # 1970-01-01 00:0:0
tl = datetime.datetime.now()
tnow=(time.mktime(tl.timetuple())-time.mktime(t1.timetuple()))/24/3600
done = False
while not done:
fp=input_float('Please input actual measurement of \'%s\'\n\n' % self.name)
if self.newDB_flag:
done = True
else:
done = self.check_measurement_input([tnow, fp])
if self.newDB_flag:
tlminus1 = tl - datetime.timedelta(seconds=1)
tnowminus1=(time.mktime(tlminus1.timetuple())-time.mktime(t1.timetuple()))/24/3600
self.add_row( [tnowminus1, fp-ALPHA])
self.add_row( [tnow, fp])
else:
self.add_row( [tnow, fp])
else:
warnMsg("Input of measurement value abandoned due to previous errors!\n")
def send_request_to_google_analytics(utm_url, environ):
"""
// Make a tracking request to Google Analytics from this server.
// Copies the headers from the original request to the new one.
// If request containg utmdebug parameter, exceptions encountered
// communicating with Google Analytics are thown.
"""
http = httplib2.Http()
try:
resp, content = http.request(utm_url,
"GET",
headers={
'User-Agent':
environ.get('HTTP_USER_AGENT',
'Unknown'),
'Accepts-Language:':
environ.get("HTTP_ACCEPT_LANGUAGE",
'')
})
# dbgMsg("success")
except httplib2.HttpLib2Error, e:
errMsg("fail: %s" % utm_url)
if environ['GET'].get('utmdebug'):
raise Exception("Error opening: %s" % utm_url)
else:
pass
def checkTimeout(self, sTime, bTimeout):
# check timestamp timestr against current time and timeout
# return True if we have not timed out yet
try:
bYear = int(sTime[0:4])
bMonth = int(sTime[4:6])
bDay = int(sTime[6:8])
bHour = int(sTime[8:10])
bMinute = int(sTime[10:12])
bSecond = int(sTime[12:14])
bDaylight = time.localtime()[8]
bThen = int(
time.mktime((bYear, bMonth, bDay, bHour, bMinute, bSecond, 0,
0, bDaylight)))
bNow = int(time.time())
bTimeout = int(bTimeout) * 60
if bNow - bThen > bTimeout:
return False
return True
except Exception, e:
errMsg('cannot convert time [%s] to int [%s]' % (sTime, e))
return False
def check_strictly_increasing_new_row(self, vec):
if self.status != False:
last_row=self.table.last_row()
for j, el in enumerate(vec):
if isinstance(el, float) and isinstance(last_row[j], float) and self.table.strictly_increasing_check_mask[j]:
if last_row[j] >= el:
errMsg( "Entry [%d] of vector is not strictly increasing: '%s'" % ( j, el))
self.status=False
else:
warnMsg("Method not executed due to previous errors!\n")
def convert2float(self, vec):
vector=[]
for i, el in enumerate(vec):
try:
float_val=float(el)
vector.append(float_val)
except:
errMsg("Entry %d of vector is not of type float: '%s'" % (i, el))
self.status=False
return(vector)
def upgradePasswordHash(self, bUserID, sPass):
try:
rgoResult = self._libDB.query(
'UPDATE User SET sPassword=PASSWORD(%s) WHERE bID=%s AND sPassword=OLD_PASSWORD(%s)',
sPass, bUserID, sPass)
return True
except Exception, e:
errMsg('cannot upgrade password hash from mysql [%d] [%s] [%s]' %
(bUserID, sPass, e))
return False
def consistency_checks(self):
if self.consistency_checks_on:
self.check_dimension()
self.check_float()
self.check_strictly_increasing()
if not self.status:
errMsg("Exiting because of previous fatal errors\n")
sys.exit(1)
else:
self.dy=len(self.array)
self.dx=len(self.array[0])
def write_table(self):
if self.status != False:
try:
fn=self.wd+r'/'+self.write_table_name
f=open(fn, 'w')
for row in self.table.list:
f.writelines(row +'\n')
f.close()
except IOError:
errMsg('Cannot open for write %s' % fn)
else:
warnMsg("Method not executed due to previous errors!\n")
def check_strictly_increasing(self):
if self.status == True:
for i, row in enumerate(self.array):
if i>0:
for j, col in enumerate(row):
if j <= len(prev)-1 and isinstance(col, float) and isinstance(prev[j], float) and self.strictly_increasing_check_mask[j]:
if not col > prev[j]:
errMsg("Entry [%d][%d] of table '%s' is not strictly increasing: '%s'" % (i, j, self.name, col))
self.status=False
prev=row
else:
warnMsg("Method not executed due to previous errors!\n")
def add_column(self, column, strictly_increasing_flag):
if self.status != False:
fcolumn=self.convert2float(column)
if len(fcolumn) != self.table.dy:
errMsg("Dimension do not match:\nRequired: %d Actual: %d\n" % ( self.table.dy, len(fcolumn)))
self.status=False
if self.status:
self.table.add_column(fcolumn, strictly_increasing_flag)
self.update_consumption()
if messaging.debug:
self.table.print_table()
else:
warnMsg("Method not executed due to previous errors!\n")
def check_dimension(self):
if self.status == True:
i=0
for entry in self.array:
if len(entry) != self.dim:
errMsg("Line %d of table '%s' has not exactly %d entries: '%s'" % (i, self.name, self.dim, entry))
self.status=False
i+=1
if len(self.strictly_increasing_check_mask) != self.dim:
errMsg("strictly_increasing_check_mask of table '%s' has not exactly %d entries" % ( self.name, self.dim))
self.status=False
else:
warnMsg("Method not executed due to previous errors!\n")
def check_float(self):
if self.status == True:
i=0
for i, row in enumerate(self.array):
for j, col in enumerate(row):
try:
val=float(col)
self.array[i][j]=val
except:
errMsg("Entry [%d][%d] of table '%s' is not of type float: '%s'" % (i, j, self.name, col))
self.status=False
else:
warnMsg("Method not executed due to previous errors!\n")
def add_row(self, row):
if self.status != False:
frow=self.convert2float(row)
self.check_strictly_increasing_new_row(frow)
if len(frow) != self.table.dx:
errMsg("Dimension do not match:\nRequired: %d Actual: %d\n" % ( self.table.dx, len(frow)))
self.status=False
if self.status:
self.table.add_row(frow)
self.update_consumption()
if messaging.debug:
self.table.print_table()
else:
warnMsg("Method not executed due to previous errors!\n")
def hashPassword(self, sPass, fUseOldHash=False):
try:
# Call underlying password func for mysql
if not fUseOldHash:
rgoResult = self._libDB.query('SELECT PASSWORD(%s)', sPass)
else:
rgoResult = self._libDB.query('SELECT OLD_PASSWORD(%s)', sPass)
if len(rgoResult) != 0:
return (True, rgoResult[0][0])
return (False, '')
except Exception, e:
errMsg('cannot get password hash from mysql [%s] [%s]' %
(sPass, e))
return (False, '')
def read_table(self):
try:
fn=self.wd+r'/'+self.table_name
if os.stat(fn).st_size==0:
errMsg('File %s has size 0\n\n' % fn)
sys.exit(1)
f=open(fn, 'r')
list=f.readlines()
f.close()
list=remove_CR_LF_form_list(list)
except IOError:
errMsg('Cannot open for read %s' % fn)
self.status=True
self.table=float_table(list, self.name, 2)
self.update_consumption()
if messaging.debug:
self.table.print_table()
def hashObject(self, o):
try:
# return an md5 hash of the object serialized as a string
try:
import hashlib
m = hashlib.md5()
except ImportError:
import md5
m = md5.new()
m = md5.new()
m.update(pickle.dumps(o))
return m.hexdigest()
except Exception, e:
errMsg('cannot hash object [%s]' % e)
return ''
def logMsg(self, sMsg, sUser=''):
""" Log msg into database. """
try:
bUserID = 0
if sUser != '':
bUserID = self._dbUserList.getUser(sName=sUser).getID()
sTimestamp = time.strftime('%Y%m%d%H%M%S')
self._libDB.query(
'INSERT INTO log (timestamp,user_id,message) VALUES (%s,%s,%s)',
sTimestamp, bUserID, sMsg)
return True
except Exception, e:
errMsg('error logging message [%s]' % e)
raise Exception, 'System error while trying to log message.'
def query(self, sQuery, *rgsArgs):
self._oLock.acquire()
try:
# parse query to determine type
sType = 'select'
if sQuery[0:6] == 'INSERT':
sType = 'insert'
elif sQuery[0:6] == 'DELETE':
sType = 'delete'
elif sQuery[0:6] == 'UPDATE':
sType = 'update'
try:
if not self._oConnection:
self._oConnection = MySQLdb.connect(host=self._sHost,
user=self._sUser,
passwd=self._sPass,
db=self._sDB)
except MySQLdb.Error, (bError, sError):
errMsg('error while connecting to database -- %s' % sError)
raise Exception, sError
try:
try:
if not self._oCursor:
self._oCursor = self._oConnection.cursor()
except MySQLdb.Error, (bError, sError):
errMsg('error while creating cursor for database -- %s' %
sError)
raise Exception, sError
if len(rgsArgs) == 0:
self._oCursor.execute(sQuery)
else:
self._oCursor.execute(sQuery, rgsArgs)
rgoResult = self._oCursor.fetchall()
if len(rgoResult) == 0:
return ()
self._oConnection.commit()
return list(rgoResult)
def read_table(self):
try:
fn=self.wd+r'/'+self.table_name
if os.stat(fn).st_size==0:
if not self.newDB_flag:
errMsg('Data base file ''%s'' has size 0\n\n' % fn)
list=[]
self.init_flag=True
else:
f=open(fn, 'r')
list=f.readlines()
f.close()
list=remove_CR_LF_form_list(list)
except IOError:
errMsg('Cannot open for read %s' % fn)
self.status=True
self.table=float_table(list, self.name, 2)
self.update_consumption()
if messaging.debug:
self.table.print_table()
def send_request_to_google_analytics(utm_url, environ):
"""
// Make a tracking request to Google Analytics from this server.
// Copies the headers from the original request to the new one.
// If request containg utmdebug parameter, exceptions encountered
// communicating with Google Analytics are thown.
"""
http = httplib2.Http()
try:
resp, content = http.request(utm_url,
"GET",
headers={'User-Agent': environ.get('HTTP_USER_AGENT', 'Unknown'),
'Accepts-Language:': environ.get("HTTP_ACCEPT_LANGUAGE",'')}
)
# dbgMsg("success")
except HttpLib2Error, e:
errMsg("fail: %s" % utm_url)
if environ['GET'].get('utmdebug'):
raise Exception("Error opening: %s" % utm_url)
else:
pass
def check_working_directory (directory):
dbgMsg("checking working directory %s" % directory)
if not os.path.exists(directory):
errMsg("specified working directory \'%s\' does not exist!\n" % directory)
sys.exit(1)
if not os.path.isdir(directory):
errMsg("specified working directory \'%s\' is not a directory!\n" % directory)
sys.exit(1)
if not isWritable(directory):
errMsg("specified working directory \'%s\' is not writable!\n" % directory)
sys.exit()
return True
def check_database_file (directory, file_name):
fn = directory+r'/'+ file_name
if not os.path.isfile(fn):
errMsg("Specified data base file \'%s\' does not exist!\n\n" % fn)
sys.exit(1)
if not os.access(fn, os.R_OK):
errMsg("Specified data base file \'%s\' is not readable!\n\n" % fn)
sys.exit(1)
if os.stat(fn).st_size==0:
errMsg("Specified data base file \'%s\' has size of 0!\n\n" % fn)
sys.exit(1)
return True
def check_working_directory (directory):
dbgMsg("checking working directory %s" % directory)
if not os.path.exists(directory):
errMsg("Specified working directory \'%s\' does not exist!\n\nPlease create the data base with the command line option '-n'\n" % directory)
sys.exit(1)
if not os.path.isdir(directory):
errMsg("Specified working directory \'%s\' is not a directory!\n" % directory)
sys.exit(1)
if not isWritable(directory):
errMsg("Specified working directory \'%s\' is not writable!\n" % directory)
sys.exit()
return True
def check_add_graphs(args):
gi=1
#check correct number of arguments
if ( len(args)%3 != 0):
errMsg( 'Wrong number of arguments (not multiple of 3): %d\nExiting because of a fatal error!\n' % len(args))
errMsg('\nPassed arguments were:\n')
for i in args:
print i
sys.exit(1)
#check dimensions of arrays
for j in range(0, len(args), 3):
gi=gi+1
if ( len(args[j]) != len(args[j+1]) ):
errMsg( 'Dimensions of input arrays of graph %d do not match: %d versus %d\nExiting because of a fatal error!\n' % (gi, len(args[j]), len(args[j+1])))
sys.exit(1)
def check_database_file (directory, file_name, newDB):
fn = directory+r'/'+ file_name
if newDB:
print ("\nTrying to create a new data base: '%s'\n" % fn)
if not os.path.isfile(fn):
#create the specified data base file with size 0
with open(fn, "w") as f:
f.write("")
print ("\n\nCreated a new data base file: '%s'\n" % fn)
else:
errMsg("Specified data base file \'%s\' does already exist!\n\nCannot create a data base with the same name as an existing one!\n\nAborting!\n\n" % fn)
sys.exit(1)
else:
if not os.path.isfile(fn):
errMsg("Specified data base file \'%s\' does not exist!\n\nPlease create the data base with the command line option '-n'\n" % fn)
sys.exit(1)
if not os.access(fn, os.R_OK):
errMsg("Specified data base file \'%s\' is not readable!\n\n" % fn)
sys.exit(1)
if not newDB:
if os.stat(fn).st_size==0:
warnMsg("Specified data base file \'%s\' has size of 0!\n\n" % fn)
return True
class DBUtil:
def __init__(self, sHost, sUser, sPass, sDB):
self._oLock = threading.Lock()
self._sHost = sHost
self._sUser = sUser
self._sPass = sPass
self._sDB = sDB
self._oConnection = None
self._oCursor = None
# def __del__(self):
# try:
# if self._oCursor:
# self._oCursor.close()
# self._oCursor = None
# if self._oConnection:
# self._oConnection.close()
# self._oConnection = None
#
# except MySQLdb.Error, (bError, sError):
# errMsg('error while delecting database object -- %s' % sError)
# raise Exception, sError
def query(self, sQuery, *rgsArgs):
self._oLock.acquire()
try:
# parse query to determine type
sType = 'select'
if sQuery[0:6] == 'INSERT':
sType = 'insert'
elif sQuery[0:6] == 'DELETE':
sType = 'delete'
elif sQuery[0:6] == 'UPDATE':
sType = 'update'
try:
if not self._oConnection:
self._oConnection = MySQLdb.connect(host=self._sHost,
user=self._sUser,
passwd=self._sPass,
db=self._sDB)
except MySQLdb.Error, (bError, sError):
errMsg('error while connecting to database -- %s' % sError)
raise Exception, sError
try:
try:
if not self._oCursor:
self._oCursor = self._oConnection.cursor()
except MySQLdb.Error, (bError, sError):
errMsg('error while creating cursor for database -- %s' %
sError)
raise Exception, sError
if len(rgsArgs) == 0:
self._oCursor.execute(sQuery)
else:
self._oCursor.execute(sQuery, rgsArgs)
rgoResult = self._oCursor.fetchall()
if len(rgoResult) == 0:
return ()
self._oConnection.commit()
return list(rgoResult)
except MySQLdb.Error, (bError, sError):
errMsg('error while querying database [%s]' % sError)
if self._oCursor:
self._oCursor.close()
self._oCursor = None
if self._oConnection:
self._oConnection.close()
self._oConnection = None
raise Exception, 'error while querying database [%s]' % sError
rgoResult = self._oCursor.fetchall()
if len(rgoResult) == 0:
return ()
self._oConnection.commit()
return list(rgoResult)
except MySQLdb.Error, (bError, sError):
errMsg('error while querying database [%s]' % sError)
if self._oCursor:
self._oCursor.close()
self._oCursor = None
if self._oConnection:
self._oConnection.close()
self._oConnection = None
raise Exception, 'error while querying database [%s]' % sError
except Exception, e:
errMsg('error while querying database [%s]' % e)
if self._oCursor:
self._oCursor.close()
self._oCursor = None
if self._oConnection:
self._oConnection.close()
self._oConnection = None
raise Exception, 'error while querying database [%s]' % e
finally:
self._oLock.release()
def baz(self):
errMsg("this is an error message in bar")
def set_table_name(self, table_name):
self.table_name = table_name
fn = self.wd+r'/'+table_name
if not os.access(fn, os.R_OK):
errMsg("File \'%s\' is not readable!\n\n" % fn)
sys.exit(1)
def set_working_dir(self, name):
self.wd = name
if not os.path.isdir(self.wd):
errMsg("Directory \'%s\' does not exist!\n\n" % self.wd)
sys.exit(1)
def set_write_table_name(self, table_name):
self.write_table_name = table_name.replace(' ', '_')
fn = self.wd
if not os.access(fn, os.W_OK):
errMsg("Directory \'%s\' is not writable!\n\n" % fn)
sys.exit(1)