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')