def initLogFilePath(serverName, filePath): global g_log if g_log == None: g_log = TxLog.TxLog(filePath, serverName) g_log.writeLog(MODULE_NAME, TxLog.L_MSG, 0, "### log started ###") writePreExecLog("### log started ###", MODULE_NAME) else: g_log.writeLog(MODULE_NAME, TxLog.L_ERROR, 0, "### initLogFilePath() called repeatedly!")
def sendUDPcmdWithOptions(self, cmd_char, option_char, options_str): timeStr = TxLog.get_log_time() msg = struct.pack("cc55s32s50s100s", cmd_char, option_char, timeStr, self.origin_server_name, options_str, "[filler]") return (self.sendDatagram(msg, b_broadcast=0) )
def writePreExecLog(procName, procCallObject): """Writes a line in the pre-exec log. The line format is: aLine = "%s;%10.15s;%-64.64s, %s\n" % (timeStr, g_log.srvName, procName, procCallString, ) The beginning of the line looks like: 2005-11-02 14:48:05.549;ANY_Server;spxx_super_extremely_long_procedure_name_just_to_really_see_trun>> """ timeStr = TxLog.get_log_time() obj = (time.time(), procCallObject) buff = StringIO.StringIO() cPickle.dump(obj, buff) buff.seek(0) aLine = "%s;%10.15s;%-64.64s%s%s\n" % (timeStr, g_log.srvName, procName, PREFIX_END_MARK, repr(buff.getvalue()), ) return g_log.writeLogLineRaw(aLine)
def loginToServer(self): # Called by: verifyDestConn() # # NOTE: this function uses self.reentry_ctr to avoid being called recursively! # # Send a ProcCall like: # RP_DB_LOGIN @p_username = "******", @p_password = "******", @p_trg_name = "OSDETR80" # if (self.data == None or (self.getState() != DESTCONN_CONNECTED_NOT_LOGIN and self.getState() != DESTCONN_LOGIN_FAILED) ): m1 = "loginToServer() cannot be called when state=%s, %s" % (self.getState(), self) srvlog.writeLog(MODULE_NAME, TxLog.L_WARNING, 0, m1) return (-9) try: # check if we are called recursively: # if (self.reentry_ctr >= 2): if (self.pool.getDebugLevel() >= 1): m1 = "loginToServer(): avoiding recursion. DestConn %s." % (self, ) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) return (-8) self.remoteResourceId = None self.reentry_ctr = self.reentry_ctr + 1 if (self.pool.getDebugLevel() >= 10): m1 = "loginToServer() by DestConn %s. self.reentry_ctr=%s" % (self, self.reentry_ctr) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) mon = gxrpcmonitors.gxDestConnLoginMonitor("DestConnLoginMonitor") frame = gxrpcframe.gxRPCframe(None) # create frame _without_ client conn frame.assignMonitor(mon) frame.assignDestconn(self) # bind DestConn to frame procName = self.pool.loginProc userid = self.pool.userid passwd = self.pool.master.readFirstLineOfFile(self.pool.passwordFile) if (self.pool.getDebugLevel() == 12): # special debug level to put our thread id in srvName srvName = TxLog.get_thread_id() else: srvName = self.pool.origSrvName # the origin-Server-Name procCall = (procName, [ ('@p_username', userid, 12, 0, 0), ('@p_password', passwd, 12, 0, 0), ('@p_trg_name', srvName, 12,0, 0) ], 0) frame.assignProccall(procCall) tempInfoKey = "resultSets" val = [(0, tempInfoKey), ] frame.storeTempInfo(gxrpcmonitors.TEMP_INFO_LIST_RESP_PARTS_TO_GRAB, val) self.assignState(DESTCONN_LOGIN_IN_PROGRESS) mon.doLogin(threading.currentThread(), frame) # could trigger recursion if it gets a disconnect if (frame.getReturnStatus() == 0): pid = self.getPidOfXml2dbFromTempInfo(frame, tempInfoKey) self.remoteResourceId = pid # pid of the "XML2DB" process self.assignState(DESTCONN_LOGIN_OK) self.reentry_ctr = 0 # release recursion avoidance flag return (0) # OK, success else: self.assignState(DESTCONN_LOGIN_FAILED) except: es = gxutils.formatExceptionInfoAsString() m1 = "loginToServer() on %s: Exception: %s" % (self, es) srvlog.writeLog(MODULE_NAME, TxLog.L_WARNING, 0, m1) self.assignState(DESTCONN_LOGIN_FAILED) self.reentry_ctr = 0 # release recursion avoidance flag return (-5) self.reentry_ctr = 0 # release recursion avoidance flag return (-1) # login failed
The program will ask the password interactively, unless there is an environment variable PASSWORD_FILE_PATH defined. You should also define a LOG_PATH environment variable which points to the log file where you want the program to write to, otherwise, it will write to "./gxcmd.log" """ VERSION_ID = "v0.1 $Header: /ext_hd/cvs/gx/gxcmd.py,v 1.2 2006-06-04 18:23:15 toucheje Exp $" MODULE_NAME = "gxcmd" # # Modules variables # logPath = os.environ.get("LOG_PATH", "./gxcmd.log") srvlog = TxLog.TxLog(logPath, MODULE_NAME) xmclient.srvlog = srvlog # DEBUG level global variable: # s_debug_level = 0 # 1 for unit testing, 0 for Prod, 10 for intensive debugging. xmclient.s_debug_level = s_debug_level # propage cette valeur dans xmclient.py def debugLog(level, n, msg, requiredDebugLevel=10): if (s_debug_level >= requiredDebugLevel): writeLog(level, n, msg) def writeLog(level, n, msg, ex=None): srvlog.writeLog(MODULE_NAME, level, n, msg)
# --- Module Constants: # MODULE_NAME = "RRGX" # --- Open the server LOG with path name given on command line # --- (if given, otherwise, use default filename). # # NOTE: the name of the logfile does NOT come from the config file. # if (len(sys.argv) >= 4 and sys.argv[3].find(".log") > 0): logFilePath = sys.argv[3] else: print "WARNING: logFilePath not given on command line. Using 'gxserver.log'..." logFilePath = "gxserver.log" srvlog = TxLog.TxLog(logFilePath, "rrgx") srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, "Loading rrgx.py...") gxServer = None if __name__ == '__main__': if (len(sys.argv) < 3): print "Usage: rrgx.py ServerName configFile logFilePath" print "example: rrgx.py XMDECG80 gxconfig ./rrgx.log" raise SystemExit srvName = sys.argv[1] srvlog.setServerName(srvName) cfgFile = sys.argv[2]
def writeReport(self, t_begin): # . avg wait between RPC calls (per thread) # . ctr failed/success # . TPM target # . TPM achieved t_finish = time.time() delta_elapsed = t_finish - t_begin nbXor = len(self.xorList) tot_done = 0.0 tot_OK = 0.0 tot_failed = 0.0 tot_avg_wait = 0.0 tot_avg_OK = 0.0 tot_avg_failed = 0.0 tot_elapsed = 0.0 tot_nbIter = 0.0 for xor in self.xorList: if (not xor.elapsed): ### @@@ to be checked-in !!! continue; tot_nbIter = tot_nbIter + xor.nbIter tot_elapsed = tot_elapsed + xor.elapsed tot_done = tot_done + xor.statsSleep.getN() tot_OK = tot_OK + xor.statsOK.getN() tot_failed = tot_failed + xor.statsFailed.getN() tot_avg_wait = tot_avg_wait + xor.statsSleep.getAverage() tot_avg_OK = tot_avg_OK + xor.statsOK.getAverage() tot_avg_failed = tot_avg_failed + xor.statsFailed.getAverage() #@@@@@ m1 = "%s RPC sent: %s OK, %s failed." % (tot_done, tot_OK, tot_failed) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) avg_wait_ms = (tot_avg_wait / nbXor ) * 1000.0 # convert to ms avg_OK_ms = (tot_avg_OK / nbXor ) * 1000.0 # convert to ms avg_failed = (tot_avg_failed/ nbXor ) * 1000.0 # convert to ms interArrival = avg_wait_ms / nbXor m1 = "averages: sleep: %6.1f ms, inter-arrival: %6.1f ms, OK: %6.2f ms, failed: %6.2f ms" % (avg_wait_ms, interArrival, avg_OK_ms, avg_failed) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) avg_wait = (tot_avg_wait / nbXor ) avg_OK = (tot_avg_OK / nbXor ) if (avg_wait): target_TPM = (60 / avg_wait) else: target_TPM = 0 if (avg_OK): theoretical_TPM = (60 / avg_OK) else: theoretical_TPM = 0 observed_TPM = (tot_nbIter / delta_elapsed) * 60.0 avg_elapsed = (tot_elapsed / nbXor) m1 = "target TPM : %6.1f TPM (if response time was zero 0 ms)." % (target_TPM, ) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) m1 = "theoretical : %6.1f TPM (based on avg OK only)." % (theoretical_TPM, ) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) m1 = "observed TPM: %6.1f TPM ((tot_nbIter %6.1f / delta_elapsed %6.1f) * 60.0)." % (observed_TPM, tot_nbIter, delta_elapsed) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, m1) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, "****************") # write .csv file, with these columns: # timestamp, port, nbXor, maxCycles, maxSleepSeconds, # tot_done, tot_OK, tot_failed, # avg_wait_ms, interArrival, avg_OK_ms, avg_failed, # target_TPM, theoretical_TPM, # observed_TPM, tot_nbIter, delta_elapsed, avg_elapsed, # sp_name # m1 = "%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, \n" % (TxLog.get_log_time(), self.port, nbXor, self.maxCycles, self.maxSleepSeconds, tot_done, tot_OK, tot_failed, avg_wait_ms, interArrival, avg_OK_ms, avg_failed, target_TPM, theoretical_TPM, observed_TPM, tot_nbIter, delta_elapsed, avg_elapsed, self.sp_name) self.writeCSVline(m1)
import TxLog import gxutils import gxqueue # for class gxStats import xmltp_tags b_printBuffer = 0 # ------------------------------------------- Constants: # XMLTP_EOT_TAG = "<EOT/>" LOG_FILENAME = "gxserver.log" MODULE_NAME = "xml_load" srvlog = TxLog.TxLog(LOG_FILENAME, MODULE_NAME) srvlog.setServerName(MODULE_NAME) srvlog.writeLog(MODULE_NAME, TxLog.L_MSG, 0, "XML LOADTEST client starting...") gxqueue.gxServer = srvlog # module gxqueue will call .writeLog() # Name of report file: # REPORT_FILENAME = "loadtest.csv" # Constants: # ACTION_INIT = 0 ACTION_WAIT = 1 ACTION_RECV = 2 ACTION_SEND = 3
print "'import xmltp_gx' failed. Module is not in the current directory nor installed." print "WARNING: subsequent calls to xmltp_gx.parseResponse() will fail." print xmltp_gx = None # # Standard constants: # RCS_VERSION_ID = "RCS $Header: /ext_hd/cvs/gx/xrpc.py,v 1.3 2004/09/20 11:22:46 blanchjj Exp $" MODULE_NAME = "xrpc.py" # # Modules variables # srvlog = TxLog.TxLog("xrpc.log", MODULE_NAME) FMT_TIMESTAMP_STR = "%23.23s" FMT_INT_STR = "%6d" FMT_NUM_STR = "%12.5f" FMT_STR_STR = "%-*.*s" FMT_UNKNOWN_STR = "'%s'" dictTypeToFormatString = { xmltp_tags.JAVA_SQL_DATE: (FMT_TIMESTAMP_STR, 23), xmltp_tags.JAVA_SQL_TIME: (FMT_TIMESTAMP_STR, 23), xmltp_tags.JAVA_SQL_TIMESTAMP: (FMT_TIMESTAMP_STR, 23), xmltp_tags.JAVA_SQL_TINYINT: (FMT_INT_STR, 7), xmltp_tags.JAVA_SQL_SMALLINT: (FMT_INT_STR, 7), xmltp_tags.JAVA_SQL_BIGINT: (FMT_INT_STR, 7), xmltp_tags.JAVA_SQL_BIT: (FMT_INT_STR, 7),
stats = self.getStatsObjForType(statsType) return (stats.getN() ) def getStatsAverageHistory(self, statsType): stats = self.getStatsObjForType(statsType) return (stats.getAverageHistory() ) def resetStats(self): self.inQueueStats.resetCounters() self.outQueueStats.resetCounters() self.outQueueAltStats.resetCounters() if __name__ == '__main__': gxServer = TxLog.TxLog("toto", "toto1") print "getStatsBucketsLimitsAsColNames():" print getStatsBucketsLimitsAsColNames() q = gxqueue("Queue01", owner=None, max=3) q.put("Elem1") q.put("Elem2") q.put("Elem3") print "q.put(), 1,2,3 done" q.put("Elem4", 0)