def processOneRPC(self): try: procCall = self.getOneRPC() except: ex = gxutils.formatExceptionInfoAsString(2) print "Failed parsing input. Exception:", ex self.ctrErrors = self.ctrErrors + 1 if (self.ctrErrors >= 10): print "getOneRPC(). Too many errors, stopping. self.ctrErrors:", self.ctrErrors return (-98) return None if (procCall == None or procCall == -1 or procCall == 1): return (procCall) try: rc = self.sendRPC(procCall) if (rc <= -1): return (rc) rc = self.receiveResults(self.b_capture_results) return (rc) except: ex = gxutils.formatExceptionInfoAsString(2) print "Failed. Exception:", ex self.ctrErrors = self.ctrErrors + 1 if (self.ctrErrors >= 10): print "Too many errors, stopping. self.ctrErrors:", self.ctrErrors return (-99) return (-22)
def receiveResults(self, b_capture=1): # if (self.debugLevel >= 1): print "Using ctx=%s to receive response on socket %s." % ( self.ctx, self.sock.fileno()) ###print "...", # # the xmltp_gx.so module has a method called "parseResponse()". # Call it to receive the response and return it here as a Tuple... # try: resp = xmltp_gx.parseResponse(self.ctx, self.sock.fileno(), 0, b_capture, self.rcvTimeout) except: ex = gxutils.formatExceptionInfoAsString(1) print "*** receive and parse response failed:", ex resp = None try: if (type(resp) == type(())): self.displayRespTuple(resp) else: print "resp:", resp except: ex = gxutils.formatExceptionInfoAsString(1) print "*** Exception while displaying response:", ex return (0)
def shutdownBDBenvironment(b_force=0): global g_listOfBdbQueues global g_VarQueueEnv lsFailed = [] if g_listOfBdbQueues: for q in g_listOfBdbQueues: try: q.closeQueue(b_quiet=0) except: ex = gxutils.formatExceptionInfoAsString() m1 = "shutdownBDBenvironment(): q.close() FAILED q = %s. ex=%s." % ( q.name, ex, ) gxServer.addErrMsg(m1) lsFailed.append(q) g_listOfBdbQueues = None if lsFailed: g_listOfBdbQueues = lsFailed m1 = "shutdownBDBenvironment(): %s queues failed to close(). %s" % ( len(lsFailed), lsFailed, ) gxServer.addErrMsg(m1) if b_force: m1 = "shutdownBDBenvironment(): b_force=%s, trying g_VarQueueEnv.close() anyway..." % ( b_force, ) gxServer.addErrMsg(m1) else: m1 = "shutdownBDBenvironment(): b_force=%s, NOT doing g_VarQueueEnv.close()." % ( b_force, ) gxServer.addErrMsg(m1) return -1 if not g_VarQueueEnv: m1 = "No g_VarQueueEnv to close. It is %s." % (g_VarQueueEnv, ) gxServer.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) return 0 try: m1 = "shutdownBDBenvironment() is about to call g_VarQueueEnv.close() %s." % ( g_VarQueueEnv, ) gxServer.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) g_VarQueueEnv.close() g_VarQueueEnv = None except: ex = gxutils.formatExceptionInfoAsString() m1 = "shutdownBDBenvironment(): g_VarQueueEnv.close() FAILED. g_BDB_homedir=%s ex=%s." % ( g_BDB_homedir, ex, ) gxServer.addErrMsg(m1) return -2 return 0
def drainConnection(self, b_mustBeEmpty=0, b_verbose=0): if (self.data == None): self.assignState(DESTCONN_DISCONNECTED) return (-1) try: rc = 0 self.data.setblocking(0) # we want non-blocking recv() here has_data = 1 if (self.pool.getDebugLevel() >= 10): m1 = "drainConnection() about to check if data available..." srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) while (has_data): try: if (self.pool.getDebugLevel() >= 10): srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, "drainConnection() about to recv()" ) r_buff = self.data.recv(100) if (r_buff != None and r_buff != ""): if (b_mustBeEmpty): m1 = "WEIRD: data found on DestConn %s, data: %s." % (self, repr(r_buff)) srvlog.writeLog(MODULE_NAME, TxLog.L_WARNING, len(r_buff), m1) self.closeConn() # disconnect from server! rc = -3 break else: has_data = 0 except: has_data = 0 if (b_verbose): excStr = gxutils.formatExceptionInfoAsString() m1 = "drainConnection(%s): recv() failed with: %s" % (self,excStr) srvlog.writeLog(MODULE_NAME, TxLog.L_WARNING, 0, m1) except: excStr = gxutils.formatExceptionInfoAsString() m1 = "drainConnection(%s): failed with: %s" % (self, excStr) srvlog.writeLog(MODULE_NAME, TxLog.L_WARNING, 0, m1) self.closeConn() # disconnect from server! rc = -2 if (self.data != None): self.data.setblocking(1) # restore blocking mode (normal mode) return (rc)
def close(self): try: self.acquireThreadLock("close()") try: self.close_raw() except: ex = gxutils.formatExceptionInfoAsString() m1 = "self.close_raw() Exception ex=%s." % (ex, ) logTrace(L_WARNING, m1, ex) self.releaseThreadLock("close()") except: ex = gxutils.formatExceptionInfoAsString() m1 = "self.close_raw() FAILED? ex=%s." % (ex, ) logTrace(L_WARNING, m1, ex)
def createQueue(self, max): """ version specific to use bdbVarQueue ... """ self.queue = None # if this value stays after __init__() then the creation of the queue failed. if not g_VarQueueEnv: m1 = "%s -- gxbdbqueue.createQueue(): about to call prepareBDBenvironment()..." % ( self.name, ) gxServer.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) rc = prepareBDBenvironment() if rc != 0: m1 = "gxbdbqueue.createQueue(): name %s, prepareBDBenvironment() FAILED rc=%s." % ( self.name, rc, ) gxServer.addErrMsg(m1) return -1 try: m1 = "%s -- gxbdbqueue.createQueue(): about to call bdbVarQueue.VarQueue()..." % ( self.name, ) gxServer.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) self.queue = bdbVarQueue.VarQueue(self.name, max, g_VarQueueEnv) except: ex = gxutils.formatExceptionInfoAsString(10) m1 = "gxbdbqueue.createQueue(): name %s, create instance bdbVarQueue.VarQueue() got EXCEPTION, ex=%s." % ( self.name, ex, ) gxServer.addErrMsg(m1) return -2 try: m1 = "%s -- gxbdbqueue.createQueue(): about to call self.queue.open()..." % ( self.name, ) gxServer.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) self.queue.open() except: ex = gxutils.formatExceptionInfoAsString(10) m1 = "gxbdbqueue.createQueue(): name %s, self.queue.open() got EXCEPTION, ex=%s." % ( self.name, ex, ) gxServer.addErrMsg(m1) return -2
def runThread(self, aThread): # # NOTE: aThread is a gxThread instance and has more # attributes than a basic Python thread. # See gxThread module for details. # pool = None poolName = "UNKNOWN-yet" try: pool = aThread.pool poolName = pool.getName() while (not aThread.pool.b_stopThread): self.processOneRequest(aThread) m1 = "resPool '%s' is stopping. %s" % (poolName, pool) gxServer.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) except: ex = gxutils.formatExceptionInfoAsString() m1 = "Exception in ResPoolMonitor of '%s': %s" % (poolName, ex) if (pool): try: pool.exceptionMsg = m1 except: pass gxServer.writeLog(MODULE_NAME, TxLog.L_ERROR, 0, m1)
def queueRPCtoCleanUpPeerResource(self): # # Queue a RPC that will clean up (zap!) the peer # resource (a program which implement the XML2DB specs, # probably). # procName = "kill" try: poolName = self.pool.getName() if (self.pool.getDebugLevel() >= 10): m1 = "queueRPCtoCleanUpPeerResource(): '%s', will send proc: %s, pid = %s." % (poolName, procName, self.remoteResourceId) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) if (not self.remoteResourceId): return None params = [ ('@p_pid', self.remoteResourceId, 4, 0, 0), ] pseudoUserid = "%s_%s_%s" % (poolName, procName, self.remoteResourceId) pseudoMsg = "To stop runaway xml2db process" # NOTE: we queue this RPC on the priviledged requests queue: # self.pool.queueAsynchRPCextended(procName, params, pseudoUserid, pseudoMsg, b_privReq=1, sleepBeforeCall=3) except: es = gxutils.formatExceptionInfoAsString(3) m1 = "queueRPCtoCleanUpPeerResource(): failed with: %s" % ( es, ) srvlog.writeLog(MODULE_NAME, TxLog.L_WARNING, 0, m1)
def getQueueSize(self): """ Return (approximate?) number of items in the queue. Uses the difference 'cur_recno' - 'first_recno' in the values of the dictionary returned by self.db_fifo.stat(flags = bsddb3.db.DB_FAST_STAT) to compute the queue size. NOTE: the 'nkeys' element in that dictionary does not provide accurate information, when (flags = bsddb3.db.DB_FAST_STAT). But, without that flag, the .stat() call can be much too slow. Return -1 if failed. Return -2 if queue is not open. Return -3 if exception caught. """ try: if not self.b_isOpen: return -2 statsDict = self.getStats(b_aboutQueue=1, b_fast=1) if not statsDict: if getDebugLevel() >= 10: m1 = "getQueueSize(): %s: self.getStats() returned statsDict=%s. %s" % (self.name, statsDict, self, ) logTrace(L_MSG, m1, "") return -1 curr = statsDict['cur_recno'] # BSD DB version 4.3+ (2005) first = statsDict['first_recno'] return curr - first except: ex = gxutils.formatExceptionInfoAsString() m1 = "getQueueSize() name: %s FAILED? ex=%s." % (self.name, ex, ) logTrace(L_WARNING, m1, ex) return -3
def getVersionId(name): # # NOTE: if <name> is found as a registered groupName, this function # will return a list of strings. # ls = getObjList(name) if (type(ls) == type("str")): # error found return (ls) msg = None replyLs = [] try: for objMod in ls: try: v = objMod.getRcsVersionId() replyLs.append(v) except AttributeError: msg = "'%s' (%s) does not have a .getRcsVersionId() method" % ( name, objMod) if (len(ls) == 1): return (replyLs[0]) # name was an objectName, not a groupName return (replyLs) except: exc = gxutils.formatExceptionInfoAsString() msg = "%s .getVersionId() caused exception: %s" % (name, exc) return (msg)
def getTraceLevel(name): # # NOTE: if groupOrObjectName is found as a registered groupName, this function # will return a list of integers (not an integer). # ls = getObjList(name) if (type(ls) == type("str")): # error found return (ls) msg = None replyLs = [] try: for objMod in ls: try: level = objMod.getDebugLevel() replyLs.append(level) except AttributeError: msg = "'%s' (%s) does not have a .getDebugLevel() method" % ( name, objMod) if (len(ls) == 1): return (replyLs[0]) # name was an objectName, not a groupName return (replyLs) except: exc = gxutils.formatExceptionInfoAsString() msg = "%s .getTraceLevel() caused exception: %s" % (name, exc) return (msg)
def put_raw(self, item): refKey = "%.32s_%20.12f_%s" % (self.name, time.time(), self.getIncremSeqNo(), ) tx = self.VQenv.dbenv.txn_begin(flags=bsddb3.db.DB_TXN_SYNC) #print self.VQenv.dbenv.txn_stat() #print "tx.id():", tx.id() #print "db_fifo:", self.db_fifo if getDebugLevel() >= 10: logTrace(L_MSG, "refKey:", refKey) if getDebugLevel() >= 50: logTrace(L_MSG, "self.db_data.stat():", str(self.db_data.stat() ) ) logTrace(L_MSG, "self.db_fifo.stat():", str(self.db_fifo.stat() ) ) #rc = self.db_fifo.append(refKey, tx) ## does NOT work ## rc = self.db_fifo.put(0, refKey, txn=tx, flags=bsddb3.db.DB_APPEND) # works OK if getDebugLevel() >= 5: m = "self.db_fifo.append() rc=%s" % (rc,) logTrace(L_MSG, self.name, m) try: rc1 = self.db_data.put(refKey, item, txn=tx, flags=0) tx.commit() except: ex = gxutils.formatExceptionInfoAsString() m1 = "self.db_data.put() FAILED, rc=%s, refKey=%s, item=%s" % (rc1, refKey, item, ) logTrace(L_WARNING, m1, ex) tx.abort() rc = self.VQenv.dbenv.txn_checkpoint(16, 1, 0) # (kbyte=8, min=1, flag=0) if rc != None and rc != 0: m = "self.VQenv.dbenv.txn_checkpoint() FAILED, rc=%s" % (rc, ) logTrace(L_WARNING, self.name, m)
def disconnectAllClients(clt_conn, b_quiet): # # Called by: gxserver.shutdownFinal() # # Disconnect all clients, but, ourself (clt == clt_conn) # ctrDone = 0 msgOurself = "" try: ls = getListOfClients(0) # 0: unsorted for clt in ls: if (clt == clt_conn): # do not disconnect ourself! msgOurself = "(but not ourself!)" continue clt.processDisconnect("[server shutdown]", b_shutdown=1, b_quiet=b_quiet) ctrDone = ctrDone + 1 m1 = "disconnectAllClients(): closed %s of %s client conn. %s" % ( ctrDone, len(ls), msgOurself) gxServer.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) except: ex = gxutils.formatExceptionInfoAsString() m1 = "disconnectAllClients(): FAILED after closing %s client conn, Exc: %s." % ( ctrDone, ex) gxServer.writeLog(MODULE_NAME, TxLog.L_WARNING, 0, m1)
def getEnvValueXMLTP(): # # Called by: getServerHostAndPort(srvName) # global envValueXMLTP if (envValueXMLTP): return envValueXMLTP try: val = os.environ["XMLTP"] envValueXMLTP = val return val except: envValueXMLTP = "./" ex = gxutils.formatExceptionInfoAsString(2) m1 = "Cannot get 'XMLTP' environment variable. Using default value '%s'. Exception: %s." % ( envValueXMLTP, ex) if (srvlog): srvlog.writeLog(MODULE_NAME, TxLog.L_WARNING, 0, m1) else: print "Error:", m1 return envValueXMLTP
def queryTrace(): # # Return a LIST of TUPLES. Each tuple contains: # # ( groupName, name, traceLevel, versionId) # # return a string (an error msg) if fails. # namesDoneDict = {} replyLs = [] for groupName in lsGroups: try: ls = groupsDict[groupName] for objName in ls: namesDoneDict[objName] = groupName # remember was done level = getTraceLevel(objName) version = cleanVersionId(getVersionId(objName)) tup = (groupName, objName, level, version) replyLs.append(tup) except KeyError: tup = (groupName, "[Not Found]", 0, "") replyLs.append(tup) except: exc = gxutils.formatExceptionInfoAsString() msg = "queryTrace() failed when processing group %s. exception: %s" % ( groupName, exc) return (msg) for objName in lsNames: try: if (not namesDoneDict.has_key(objName)): level = getTraceLevel(objName) version = cleanVersionId(getVersionId(objName)) tup = ("", objName, level, version) replyLs.append(tup) except: exc = gxutils.formatExceptionInfoAsString() msg = "queryTrace() failed when processing group %s. exception: %s" % ( objName, exc) return (msg) return (replyLs)
def receiveResponse(self): if (self.getDebugLevel() >= 7): m1 = "receiveResponse()... %s" % (self, ) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) self.b_idFound = 0 b_eot = 0 prev_buff = "" ret_stat = -995 while (not b_eot): try: rbuff = self.sock.recv(5000) blen = len(rbuff) if (blen <= 0): self.recvStatus = "recv() ERROR" return -991 except: exc = gxutils.formatExceptionInfoAsString() m1 = "recv(): FAILED %s (%s)" % (exc, self) srvlog.writeLog(MODULE_NAME, TxLog.L_ERROR, 0, m1) self.recvStatus = "recv() Failed. Exception: %s" % (exc, ) return -992 # concat previous and current buffers to make simple it to # check if <EOT/> was received: # str = prev_buff + rbuff if (b_printBuffer): print self.getId(), "buffer: '", str, "'." ## if (string.find(str, self.getId() ) >= 0): ## self.b_idFound = 1 b_eot, ret_stat = self.checkEOTandReturnStatus(XMLTP_EOT_TAG, str) if (b_eot): self.recvStatus = XMLTP_EOT_TAG + " DONE." len_str = len(str) if (len_str < 72): # str is very small, keep it all. prev_buff = str continue # keep the ending of the previous buffer in prev_buff # in case "<EOT/>" is partially in the next and previous # buffers... # Or maybe <returnStatus>...</returnStatus> is split between # those 2 buffers... # prev_buff = str[(len_str - 70):] # # End of loop return ret_stat
def processDisconnect(self, msg=None, b_shutdown=0, b_quiet=0): # # This method is dangerous. # Other threads might access this object (self) while the method # is proceeding here. # # So, all other methods accessing this type of objects should first # test if (STATE_DISCONNECTING == self.state). # If this condition is true, they must return ASAP. # They should NOT access any other attribute! # if (STATE_DISCONNECTING == self.state): return None # cannot be done twice. prevState = self.state self.state = STATE_DISCONNECTING if (self.socket != None): sd = self.socket.fileno() # copy value while still available else: sd = -2 if (gxServer != None and not b_quiet): gxServer.writeLogClientDisconnect( sd, self.userid, getStateDescription(prevState), msg) return (None) # no socket to close try: if (gxServer != None): try: if (not b_quiet): gxServer.writeLogClientDisconnect( sd, self.userid, getStateDescription(prevState), msg) self.removeFromdictSdToClientConn(sd, "processDisconnect()") except: ex = gxutils.formatExceptionInfoAsString() m1 = "processDisconnect() did NOT complete entirely (sd=%s), Exc: %s." % ( sd, ex) gxServer.writeLog(MODULE_NAME, TxLog.L_WARNING, 0, m1) except: exc_inf = sys.exc_info() print "processDisconnect()!!! Exc: %s, %s, %s" % exc_inf if (self.socket != None): # # We do close() HERE. And, that's all: gx_poll has _already_ removed the fd from the poll_tab. # try: self.socket.close() except: pass self.socket = None
def getStats(self, b_aboutQueue=1, b_fast=1): try: stats = None self.acquireThreadLock("getStats()") try: stats = self.getStats_raw(b_aboutQueue, b_fast) except: ex = gxutils.formatExceptionInfoAsString() m1 = "self.getStats_raw() Exception ex=%s." % (ex, ) logTrace(L_WARNING, m1, ex) self.releaseThreadLock("getStats()") return stats except: ex = gxutils.formatExceptionInfoAsString() m1 = "self.getStats_raw() FAILED? ex=%s." % (ex, ) logTrace(L_WARNING, m1, ex)
def prepareConnection(self): # # 0. if connected, do nothing, return # 1. build login procCall (if not done yet) # 2. connect() # 3. send login RPC.. check that it is successful # debugLog(0, (self.sock != None), "prepareConnection()") if self.sock: return None # already connected, OK if self.err_state == ERR_LOGIN_FAILED: m1 = "%s: ERR_LOGIN_FAILED before. No re-connect." % ( self.srvName, ) return m1 try: self.ctr_reconnect = self.ctr_reconnect + 1 if not self.loginProcCall: x = xmProcCall() p = x.buildProcCallFromList( ["login", self.userid, self.passwd, MODULE_NAME]) if type(p) == type("s"): return p self.loginProcCall = p debugLog(0, 0, "prepareConnection(): about to connectToServer()") self.connectToServer() debugLog( 0, (self.sock != None), "prepareConnection(): connect done, BEFORE sendRPC() login...") ret = self.sendRPCandReceiveResults(self.loginProcCall, b_expectReturnStatus=1) if ret != 0: self.resetConn(ERR_LOGIN_FAILED) return ret self.err_state = 0 except: exTuple = gxutils.formatExceptionInfo(1) diag = gxutils.getDiagnosisFromExcInfo(exTuple) if (diag == gxutils.EXC_DS_SERVER_NOT_AVAIL): self.resetConn(ERR_CONNECT_FAILED) m1 = "%s: SERVER_NOT_AVAILABLE (ctr=%s)" % (self.srvName, self.ctr_reconnect) return m1 ex = gxutils.formatExceptionInfoAsString(1) m1 = "connectToServer() %s failed, exc: %s" % (self.srvName, ex) self.resetConn(m1) m1 = "connectToServer() %s failed, diag=%s, exc: %s" % ( self.srvName, diag, ex) return m1
def get(self): item = None try: self.acquireThreadLock("get()") try: item = self.get_raw() except: ex = gxutils.formatExceptionInfoAsString() m1 = "self.get_raw() Exception ex=%s." % (ex, ) logTrace(L_WARNING, m1, ex) self.releaseThreadLock("get()") if item != None: item = cPickle.load(StringIO.StringIO(item) ) except: ex = gxutils.formatExceptionInfoAsString() m1 = "self.get_raw() FAILED? ex=%s." % (ex, ) logTrace(L_WARNING, m1, ex) return item
def runThread(self, aThread): try: self.parseAndProcessRequest(aThread) except: self.ctrErrors = self.ctrErrors + 1 excStr = gxutils.formatExceptionInfoAsString() m1 = "Error in CallParserMonitor (%s) exc: %s." % (aThread, excStr) srvlog.writeLog(MODULE_NAME, TxLog.L_ERROR, self.ctrErrors, m1)
def releaseThreadLock(self, funcName): # # to END a Critical Section # try: self.threadLock.release() except: ex = gxutils.formatExceptionInfoAsString() m1 = "releaseThreadLock(): FAILED release(), Exc: %s, %s." % (ex, funcName, ) logTrace(L_WARNING, self.name, m1) pass # in case it is called when already unlocked
def rememberPrevExcInfo(self): if (self.excMsg == None): return None try: str = "%s, '%s', diag=%s, act=%s" % ( self.excMsg, repr( (self.excInfoTuple[0], self.excInfoTuple[1])), self.excDiag, self.excActivityType) self.prevExcInfo = str except: self.prevExcInfo = gxutils.formatExceptionInfoAsString(2)
def getOneRPC(self): print "xrpc ==> ", procCallBuilder = ProcCallBuilder() rc = 0 while (rc == 0): token = self.shlex.get_token() if (not token or token.lower() == "exit"): print "[EOF]" rc = 1 break if (self.debugLevel >= 10): print "token '%s'" % (token, ) if (token.lower() == "go" or token == ";"): print "[GO or ';']" break if (token.lower() == "/" or token.lower() == "/cap" or token.lower() == "/capture"): self.b_capture_results = (not self.b_capture_results) if (self.b_capture_results): print "[Capture response ON]" else: print "[Capture response OFF]" return (None) if (token.lower() == "?" or token.lower() == "h" or token.lower() == "/h" or token.lower() == "/help"): self.displayHelp() return None if (token.lower() == "reset"): print "[reset]" return (None) try: procCallBuilder.addToken(token) except: ex = gxutils.formatExceptionInfoAsString(2) print "RPC parsing failed:", ex rc = -1 if (rc == 0): return (procCallBuilder.getProcCall()) if (rc == 1): if (procCallBuilder.procCall == None): return (1) return (procCallBuilder.getProcCall()) return (-1)
def prepareBDBenvironment(): global g_BDB_homedir global g_VarQueueEnv if bdbVarQueue == None: m1 = "prepareBDBenvironment(): bsddb3 and/or Berkeley DB are not installed. import bdbVarQueue had failed with exception. " try: m1 = m1 + bdbVarQueue_excMsg except: pass gxServer.addErrMsg(m1) return -9 if g_VarQueueEnv: m1 = "Cannot create a VarQueueEnv BDBenvironment, because one is already active in: %s, %s, %s" % ( bdbDir, g_BDB_homedir, g_VarQueueEnv, ) gxServer.addErrMsg(m1) return -1 bdbVarQueue.g_logTraceFunction = bdbvarqueue_logTraceFunction # assign a callback pointing to bdbvarqueue_logTraceFunction() above g_BDB_homedir = gxServer.getOptionalParam( gxparam.GXPARAM_PERSISTENT_QUEUES_DIR) if not g_BDB_homedir: m1 = "prepareBDBenvironment(): MISSING param: %s. NOTE: you also have to create that directory before starting this server" % ( gxparam.GXPARAM_PERSISTENT_QUEUES_DIR, ) gxServer.addErrMsg(m1) return -2 g_VarQueueEnv = bdbVarQueue.VarQueueEnv(g_BDB_homedir) try: g_VarQueueEnv.open() except: ex = gxutils.formatExceptionInfoAsString() m1 = "prepareBDBenvironment(): g_VarQueueEnv.open() FAILED. g_BDB_homedir=%s ex=%s." % ( g_BDB_homedir, ex, ) gxServer.addErrMsg(m1) return -3 if not g_VarQueueEnv.isOpen(): m1 = "prepareBDBenvironment(): FAILED: g_VarQueueEnv %s is NOT open." % ( g_BDB_homedir, ) gxServer.addErrMsg(m1) return -5 return 0
def run(self): print self, "starting..." self.sock = None try: if (self.connect() != 0): self.displayWhyThreadStops("connect() failed", "Aborting thread.") self.monitor.notifyConnXorThreadCompleting() return (-1) m1 = "%s iterations starting (%s)" % (self.maxCycles, self) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) tnow = time.time() for i in xrange(0, self.maxCycles): self.nCycles = self.nCycles + 1 if (self.monitor.getAbortFlag()): break self.oneCycle(self.monitor.debugLevel) delta = (time.time() - tnow) if (self.nbIter <= 0): avg = 0 else: avg = self.totalWait / self.nbIter self.elapsed = delta m1 = "%s iter DONE avg response: %5.4f s, total elapsed %4.3f seconds (%s)" % (self.nbIter, avg, delta, self) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) self.closeSocketIfOpen() if (self.getDebugLevel() >= 5): m1 = "socket CLOSED (%s)" % (self, ) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) except: exc = gxutils.formatExceptionInfoAsString() self.displayWhyThreadStops("Exc:", exc) else: if (self.monitor.getAbortFlag()): msg = "Abort requested" else: msg = "completed" print "ConnXor", self.id, msg, \ "(", self.describeCurrentAction(), ")." # # this thread will end. Notify the monitor: # self.monitor.notifyConnXorThreadCompleting()
def put(self, item): try: buff = StringIO.StringIO() cPickle.dump(item, buff) buff.seek(0) item = buff.getvalue() self.acquireThreadLock("put()") try: self.put_raw(item) except: ex = gxutils.formatExceptionInfoAsString() m1 = "self.put_raw() FAILED? ex=%s." % (ex, ) logTrace(L_WARNING, m1, ex) self.releaseThreadLock("put()") return 0 except: ex = gxutils.formatExceptionInfoAsString() m1 = "self.put_raw() FAILED? ex=%s." % (ex, ) logTrace(L_WARNING, m1, ex) return -1
def sendCommand(self, clt, cmdText, procCall, srvname): st = "sendCommand()..." try: st = "clt.sendRPCandReceiveResults()" res = clt.sendRPCandReceiveResults(self.procCall, b_expectReturnStatus=0) # # res could be a string if there has been an error except: ex = gxutils.formatExceptionInfoAsString(1) m1 = "%s %s %s Exc: %s" % (st, srvname, cmdText, ex) return m1 return res
def releaseClientsListAndDictLock(funcName, connDescription): # # to END a Critical Section # try: clientsListAndDictLock.release() # m1 = "releaseClientsListAndDictLock(): SUCCESS release(). %s, %s." % (funcName, connDescription) # gxServer.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) except: ex = gxutils.formatExceptionInfoAsString() m1 = "releaseClientsListAndDictLock(): FAILED release(), Exc: %s, %s, %s." % ( ex, funcName, connDescription) gxServer.writeLog(MODULE_NAME, TxLog.L_WARNING, 0, m1) pass # in case it is called when already unlocked
def doOperation_Protected(self, res, b_newCreate): # # This PRIVATE method must NOT be overidden by a subclass! # # Called by: putResInQueueExt() -- ONLY # oper = "[unknownOper]" resName = "[unknownResName]" try: resName = res.getName() oper = self.getOperationToDo() self.doOperation(res, b_newCreate) except: excStr = gxutils.formatExceptionInfoAsString(2) m1 = "doOperation(): %s on '%s': failed with Exc: %s." % ( oper, resName, excStr) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1)