class DAQClient(ComponentName):
"""DAQ component
id - internal client ID
name - component name
num - component instance number
host - component host name
port - component port number
mbeanPort - component's MBean server port number
connectors - list of Connectors
client - XML-RPC client
deadCount - number of sequential failed pings
cmdOrder - order in which start/stop commands are issued
"""
# next component ID
#
ID = UniqueID()
# internal state indicating that the client hasn't answered
# some number of pings but has not been declared dead
#
STATE_MISSING = 'MIA'
# internal state indicating that the client is
# no longer responding to pings
#
STATE_DEAD = RunSet.STATE_DEAD
def __init__(self,
name,
num,
host,
port,
mbeanPort,
connectors,
quiet=False):
"""
DAQClient constructor
name - component name
num - component instance number
host - component host name
port - component port number
mbeanPort - component MBean port number
connectors - list of Connectors
"""
super(DAQClient, self).__init__(name, num)
self.__id = DAQClient.ID.next()
self.__host = host
self.__port = port
self.__mbeanPort = mbeanPort
self.__connectors = connectors
self.__deadCount = 0
self.__cmdOrder = None
self.__log = self.createLogger(quiet=quiet)
self.__client = self.createClient(host, port)
try:
self.__mbean = self.createMBeanClient(host, mbeanPort)
except:
self.__mbean = None
def __str__(self):
"String description"
if self.__port <= 0:
hpStr = ''
else:
hpStr = ' at %s:%d' % (self.__host, self.__port)
if self.__mbeanPort <= 0:
mbeanStr = ''
else:
mbeanStr = ' M#%d' % self.__mbeanPort
extraStr = ''
if self.__connectors and len(self.__connectors) > 0:
first = True
for c in self.__connectors:
if first:
extraStr += ' [' + str(c)
first = False
else:
extraStr += ' ' + str(c)
extraStr += ']'
return "ID#%d %s%s%s%s" % \
(self.__id, self.fullName(), hpStr, mbeanStr, extraStr)
def checkBeanField(self, bean, field):
if self.__mbean is not None:
self.__mbean.checkBeanField(bean, field)
def close(self):
self.__log.close()
def commitSubrun(self, subrunNum, latestTime):
"Start marking events with the subrun number"
try:
return self.__client.xmlrpc.commitSubrun(subrunNum, latestTime)
except:
self.__log.error(exc_string())
return None
def configure(self, configName=None):
"Configure this component"
try:
if not configName:
return self.__client.xmlrpc.configure()
else:
return self.__client.xmlrpc.configure(configName)
except:
self.__log.error(exc_string())
return None
def connect(self, connList=None):
"Connect this component with other components in a runset"
if not connList:
return self.__client.xmlrpc.connect()
cl = []
for conn in connList:
cl.append(conn.map())
return self.__client.xmlrpc.connect(cl)
def connectors(self):
return self.__connectors[:]
def createClient(self, host, port):
return RPCClient(host, port)
def createLogger(self, quiet):
return CnCLogger(quiet=quiet)
def createMBeanClient(self, host, mbeanPort):
return MBeanClient(self.fullName(), host, mbeanPort)
def events(self, subrunNumber):
"Get the number of events in the specified subrun"
try:
evts = self.__client.xmlrpc.getEvents(subrunNumber)
if type(evts) == str:
evts = long(evts[:-1])
return evts
except:
self.__log.error(exc_string())
return None
def forcedStop(self):
"Force component to stop running"
try:
return self.__client.xmlrpc.forcedStop()
except:
self.__log.error(exc_string())
return None
def getBeanFields(self, bean):
if self.__mbean is None:
return []
return self.__mbean.getBeanFields(bean)
def getBeanNames(self):
if self.__mbean is None:
return []
return self.__mbean.getBeanNames()
def getMultiBeanFields(self, name, fieldList):
if self.__mbean is None:
return {}
return self.__mbean.getAttributes(name, fieldList)
def getNonstoppedConnectorsString(self):
"""
Return string describing states of all connectors
which have not yet stopped
"""
try:
connStates = self.__client.xmlrpc.listConnectorStates()
except:
self.__log.error(exc_string())
connStates = []
csStr = None
for cs in connStates:
if cs["state"] == 'idle':
continue
if csStr is None:
csStr = '['
else:
csStr += ', '
csStr += '%s:%s' % (cs["type"], cs["state"])
if csStr is None:
csStr = ''
else:
csStr += ']'
return csStr
def getSingleBeanField(self, name, field):
if self.__mbean is None:
return None
return self.__mbean.get(name, field)
def host(self):
return self.__host
def id(self):
return self.__id
def isSource(self):
"Is this component a source of data?"
# XXX Hack for stringHubs which are sources but which confuse
# things by also reading requests from the eventBuilder
if self.isHub():
return True
for conn in self.__connectors:
if conn.isInput():
return False
return True
def listConnectorStates(self):
return self.__client.xmlrpc.listConnectorStates()
def logTo(self, logIP, logPort, liveIP, livePort):
"Send log messages to the specified host and port"
self.__log.openLog(logIP, logPort, liveIP, livePort)
if logIP is None:
logIP = ''
if logPort is None:
logPort = 0
if liveIP is None:
liveIP = ''
if livePort is None:
livePort = 0
self.__client.xmlrpc.logTo(logIP, logPort, liveIP, livePort)
infoStr = self.__client.xmlrpc.getVersionInfo()
self.__log.debug(
("Version info: %(filename)s %(revision)s" +
" %(date)s %(time)s %(author)s %(release)s" + " %(repo_rev)s") %
get_version_info(infoStr))
def map(self):
return {
"id": self.__id,
"compName": self.name(),
"compNum": self.num(),
"host": self.__host,
"rpcPort": self.__port,
"mbeanPort": self.__mbeanPort
}
def mbeanPort(self):
return self.__mbeanPort
def monitor(self):
"Return the monitoring value"
return self.state()
def order(self):
return self.__cmdOrder
def port(self):
return self.__port
def prepareSubrun(self, subrunNum):
"Start marking events as bogus in preparation for subrun"
try:
return self.__client.xmlrpc.prepareSubrun(subrunNum)
except:
self.__log.error(exc_string())
return None
def reset(self):
"Reset component back to the idle state"
self.__log.closeLog()
return self.__client.xmlrpc.reset()
def resetLogging(self):
"Reset component back to the idle state"
self.__log.resetLog()
return self.__client.xmlrpc.resetLogging()
def setOrder(self, orderNum):
self.__cmdOrder = orderNum
def startRun(self, runNum):
"Start component processing DAQ data"
try:
return self.__client.xmlrpc.startRun(runNum)
except:
self.__log.error(exc_string())
return None
def startSubrun(self, data):
"Send subrun data to stringHubs"
try:
return self.__client.xmlrpc.startSubrun(data)
except:
self.__log.error(exc_string())
return None
def state(self):
"Get current state"
try:
state = self.__client.xmlrpc.getState()
except socket.error:
state = None
except:
self.__log.error(exc_string())
state = None
if not state:
self.__deadCount += 1
if self.__deadCount < 3:
state = DAQClient.STATE_MISSING
else:
state = DAQClient.STATE_DEAD
return state
def stopRun(self):
"Stop component processing DAQ data"
try:
return self.__client.xmlrpc.stopRun()
except:
self.__log.error(exc_string())
return None
def terminate(self):
"Terminate component"
state = self.state()
if state != "idle" and state != "ready" and \
state != self.STATE_MISSING and state != self.STATE_DEAD:
raise DAQClientException("%s state is %s" % (self, state))
self.__log.closeFinal()
try:
self.__client.xmlrpc.terminate()
except:
# ignore termination exceptions
pass
def writeContent(self, trans=None):
#
# this servlet creates and stores a new Transfer
#
globalSetVars = self._globalSetVars
store = globalSetVars['store']
account = self.transaction.request().field('account','')
index = self.transaction.request().field('index',0)
page = self.transaction.request().field('page','Main')
#
# test for errors and consistency
#
if not self.transaction.request().field('name',''):
self.transaction.response().sendRedirect(string.split(self.transaction.request().environ()['HTTP_REFERER'],'?')[0] + '?id=%s&index=%s&error=Bitte einen Zahlungsempfänger angeben' % (account,index))
elif (DateTime.DateTimeFrom(self.transaction.request().field('date',DateTime.now())).year > (DateTime.now().year + 2)) or \
(DateTime.DateTimeFrom(self.transaction.request().field('date',DateTime.now())).year < (DateTime.now().year - 5)):
self.transaction.response().sendRedirect(string.split(self.transaction.request().environ()['HTTP_REFERER'],'?')[0] + '?id=%s&index=%s&error=das Buchungsdatum scheint nicht korrekt zu sein' % (account,index))
elif float(string.replace(self.transaction.request().field('Haben','0,0'),',','.')) < 0.0:
self.transaction.response().sendRedirect(string.split(self.transaction.request().environ()['HTTP_REFERER'],'?')[0] + '?id=%s&index=%s&error=das Haben darf nicht negativ sein' % (account,index))
elif float(string.replace(self.transaction.request().field('Soll','0,0'),',','.')) < 0.0:
self.transaction.response().sendRedirect(string.split(self.transaction.request().environ()['HTTP_REFERER'],'?')[0] + '?id=%s&index=%s&error=das Soll darf nicht negativ sein' % (account,index))
elif (float(string.replace(self.transaction.request().field('Soll','0,0'),',','.')) == 0.0) and (float(string.replace(self.transaction.request().field('Haben','0,0'),',','.')) == 0.0):
self.transaction.response().sendRedirect(string.split(self.transaction.request().environ()['HTTP_REFERER'],'?')[0] + '?id=%s&index=%s&error=Haben oder Soll müssen einen Wert haben' % (account,index))
elif (float(string.replace(self.transaction.request().field('Soll','0,0'),',','.')) != 0.0) and (float(string.replace(self.transaction.request().field('Haben','0,0'),',','.')) != 0.0):
self.transaction.response().sendRedirect(string.split(self.transaction.request().environ()['HTTP_REFERER'],'?')[0] + '?id=%s&index=%s&error=entweder Haben oder Soll darf einen Wert haben' % (account,index))
else:
#
konto = self.transaction.request().field('konto','')
if not konto:
bookingObjects = store.fetchObjectsOfClass('Prices','WHERE BKZ="%s"' % self.transaction.request().field('bkz',''))
attrs = bookingObjects[0].allAttrs(0)
konto = attrs['Konto']
#
# create transfer object
#
transfer = Transfers()
transfer.setTAID(self.getSite() + DateTime.now().strftime("%Y%m%d%H%M%S") + "%04d" % UniqueID.next())
transfer.setTransferID(account + "_" + self.transaction.request().field('bkz',''))
transfer.setImportWho(self.transaction.request().field('name',''))
transfer.setImportBeschreibung(string.strip(self.transaction.request().field('description','') + ' ' + self.transaction.request().field('notice','')))
transfer.setBeschreibung(string.strip(self.transaction.request().field('description','') + ' ' + self.transaction.request().field('notice','')))
transfer.setWho(self.transaction.request().field('name',''))
if account < konto:
transfer.setHaben(float(string.replace(self.transaction.request().field('Haben','0,0'),',','.')))
transfer.setSoll(float(string.replace(self.transaction.request().field('Soll','0,0'),',','.')))
transfer.setKonto1(account)
transfer.setKonto2(konto)
else:
transfer.setHaben(float(string.replace(self.transaction.request().field('Soll','0,0'),',','.')))
transfer.setSoll(float(string.replace(self.transaction.request().field('Haben','0,0'),',','.')))
transfer.setKonto1(konto)
transfer.setKonto2(account)
transfer.setChangedBy(self.transaction.session().value('authenticated_user',''))
transfer.setChangedAt(DateTime.now())
transfer.setJahr(DateTime.DateTimeFrom(self.transaction.request().field('date',DateTime.now())).year)
transfer.setDatum(DateTime.DateTimeFrom(self.transaction.request().field('date',DateTime.now())))
transfer.setBKZ(self.transaction.request().field('bkz',''))
transfer.setChangedOn(self.getSite())
#
# calculate the rest
#
#
# store transfer in database
#
store.addObject(transfer)
try:
store.saveChanges()
except OperationalError,x:
store.discardEverything()
errorCode,errorText = x
#
# back to error page
#
self.transaction.response().sendRedirect('Error?problem=Daten+konnten+nicht+gespeichert+werden!&reason=' + urlEncode(str(errorText)))
except Warning,x:
pass
def writeContent(self, trans=None):
#
# get the year for which the new saldos have to be calculated
#
try:
year = int(self.transaction.request().field('year',''))
except ValueError:
self.transaction.response().sendRedirect('Administration')
else:
globalSetVars = self._globalSetVars
store = globalSetVars['store']
#
# remove old saldos from next year
#
storeObjects = store.fetchObjectsOfClass(self.storeName,'WHERE Jahr="%s" AND (BKZ="SVH" OR BKZ = "SVS")' % str(year+1))
for x in storeObjects:
store.deleteObject(x)
store.saveChanges()
#
# calculate new saldos from given year
#
transfers = store.fetchObjectsOfClass(self.storeName,'WHERE Jahr="%s" ORDER BY Datum' % str(year))
saldos = {}
for transfer in transfers:
x = transfer.allAttrs(0)
if saldos.has_key(x['Konto1']):
saldo = saldos[x['Konto1']]
else:
saldo = 0.0
if x['Haben'] != 0.0:
saldo = saldo + x['Haben']
if x['Soll'] != 0.0:
saldo = saldo - x['Soll']
if saldo != 0.0:
saldos[x['Konto1']] = saldo
elif saldos.has_key(x['Konto1']):
del saldos[x['Konto1']]
if (x['Konto1'] != x['Konto2']):
if saldos.has_key(x['Konto2']):
saldo = saldos[x['Konto2']]
else:
saldo = 0.0
if x['Haben'] != 0.0:
saldo = saldo - x['Haben']
if x['Soll'] != 0.0:
saldo = saldo + x['Soll']
if saldo != 0.0:
saldos[x['Konto2']] = saldo
elif saldos.has_key(x['Konto2']):
del saldos[x['Konto2']]
#
# store new saldos
#
for x in saldos.keys():
if x[:2] in self.accountStores.keys():
#
# create transfer object
#
member = store.fetchObjectsOfClass(self.accountStores[x[:2]],'WHERE ID="%s"' % x)
if member:
attrs = member[0].allAttrs(0)
transfer = Transfers()
transfer.setTAID(self.getSite() + DateTime.now().strftime("%Y%m%d%H%M%S") + "%04d" % UniqueID.next())
if attrs.has_key('Firma') and attrs['Firma']:
transfer.setImportWho(attrs['Firma'])
transfer.setWho(attrs['Firma'])
elif attrs.has_key('Bank'):
transfer.setImportWho(attrs['Bank'])
transfer.setWho(attrs['Bank'])
elif attrs.has_key('Name'):
transfer.setImportWho(attrs['Name'])
transfer.setWho(attrs['Name'])
else:
transfer.setImportWho(attrs['Nachname'] + ', ' + attrs['Vorname'])
transfer.setWho(attrs['Nachname'] + ', ' + attrs['Vorname'])
transfer.setImportBeschreibung('Saldovortrag aus %i' % year)
transfer.setBeschreibung('Saldovortrag aus %i' % year)
if saldos[x] > 0.0:
transfer.setBKZ('SVH')
transfer.setTransferID(x + "_SVH")
if year+1 == 2002:
transfer.setHaben(round(saldos[x] / 1.95583,2))
else:
transfer.setHaben(saldos[x])
transfer.setSoll(0.0)
else:
transfer.setBKZ('SVS')
transfer.setTransferID(x + "_SVS")
transfer.setHaben(0.0)
if year+1 == 2002:
transfer.setSoll(0.0 - round(saldos[x] / 1.95583,2))
else:
transfer.setSoll(0.0 - saldos[x])
transfer.setKonto1(x)
transfer.setKonto2(x)
transfer.setChangedBy(self.transaction.session().value('authenticated_user',''))
transfer.setChangedAt(DateTime.now())
transfer.setJahr(year+1)
transfer.setDatum(DateTime.DateTimeFrom('31.12.' + str(year)))
transfer.setChangedOn(self.getSite())
store.addObject(transfer)
store.saveChanges()
self.transaction.response().sendRedirect('Administration')
