def __runTaskInPool__(self, secTime, task): def updateTask(): try: self.taskHandler.update(task) except Exception as ex: slog.error(ex) if not task['pause'] and task['status'] != 'run' and task[ 'status'] != 'wait': try: task['status'] = "wait" self.taskHandler.initRun(task) task['now'] = secTime task['status'] = 'run' updateTask() self.taskHandler.run(task) task['status'] = 'stop' task['time'] = time.time() - secTime finally: if task['status'] != 'stop': task['status'] = 'exception' try: self.taskHandler.endRun(task) updateTask() except Exception as ex: slog.error(ex) return 1 return 0
def __startTimmer__(self): tp = ThreadPool(3) while 1: try: tp.apply_async(self.__runAllTask__) time.sleep(self.interval) except Exception as ex: slog.error("Main thread: %s" % ex)
def __callObjFun__(self, reqPath, reqParam): try: return self.ws.callObjFunInworker(reqPath, reqParam) except WorkerManager.WorkerFullException as ex: slog.warn(str(ex)) except: slog.error(str(traceback.format_exc())) # If worker is full or exception, deal request in main process return ObjHandler.__callObjFun__(self, reqPath, reqParam)
def __runAllTask__(self): now = time.localtime() secTime, hour, minute = time.time(), now.tm_hour, now.tm_min for sc in self.tasks: try: self.__runMatchSchedule__(secTime, hour, minute, self.tasks[sc]) except: slog.error("Fail schedule: %s" % traceback.format_exc())
def wokerCall(callId, resultContainer, pparam, lockList, objHandler): reqPath, reqParam = resultContainer[callId] resultContainer.__delitem__(callId) try: resultContainer[callId] = objHandler.__callObjFun__(reqPath, reqParam) except Exception as ex: resultContainer[callId] = "Fail to call in process: %s" % ex slog.error(traceback.format_exc()) finally: lockList[callId].release()
def __getProxyInfo__(self, headers, address, path): ip, port, host = "", 80, "" if tryGet(headers, "cfrom", None) != self.localHosts: try: # get by host ip = headers["host"].lower() ps = ip.split(":") if len(ps) == 2: ip, port = ps[0], int(ps[1]) ps = self.hostIp[ip] ip, port, host = ps['ip'], ps['port'], ps['host'] except: # get by path ps = self.__getPathProxy__(path) if self.pathIp else None if ps is None: if self.isDebugMode: slog.warn("Not found proxy: %s \t%s" % (ip, path)) else: ip, port, host = ps['ip'], ps['port'], ps['host'] if ip == "": if self.isDebugMode: slog.error("No proxy hosts: %s" % headers) raise ProxyHttpHandle.NoHostException() return ip, port, host
def __runTaskInPool__(self, curTime, task, mspan, rargs=None): def updateTask(isfinish=False, tret=None): try: self.taskHandler.update(task, isfinish, tret) except Exception as ex: slog.error("updateTask: %s" % ex) task['stime'], ltime = curTime, task['stime'] if curTime - ltime < mspan: return # check duplicate run if task['status'] != 'run': task['status'] = 'run' task['stime'], task['runCount'] = curTime, task['runCount'] + 1 try: task['rargs'] = rargs tret = None self.taskHandler.initRun(task) try: # configured for each task time.sleep(task['targs']['delay']) except: pass updateTask() tret = self.taskHandler.run(task) task['status'] = 'finish' if ( task['maxCount'] >= 0 and task['maxCount'] <= task['runCount']) else 'wait' finally: if task['result'] > 0: task['fcount'] += 1 else: task['fcount'] = 0 task['rspan'] = time.time() - curTime if task['status'] == 'run': task['status'] = 'exception' try: self.taskHandler.endRun(task) updateTask(True, tret) except Exception as ex: slog.error(ex) return 1 return 0
def __handleRequest__(self, reqObj, reqPath, reqParam, isPost): if isPost: reqParam = reqObj.readPostBody() isMock, reqAddress, respTime = False, reqObj.client_address, time.time( ) if self.isMock and _tryExecute( self.__isMockRquest__, (reqPath, reqParam, reqObj.headers, reqObj.client_address), False): respStatus, wait, resp = self.__getMockResponse__( reqPath, reqParam, reqObj.headers) if wait > 0: time.sleep(wait) isMock, reqHeader, respBody = True, reqObj.headers, bytes(resp) respHeader = [("Content-Length", len(respBody)), ("Content-Type", "text/plan;charset=utf-8")] else: try: reqHeader, respObj = self.__sendProxyRequest( reqObj, reqParam if isPost else None) respStatus, respHeader, respBody = respObj.status, respObj.getheaders( ), respObj.read() except ProxyHttpHandle.NoHostException: return "/__file__%s" % reqPath except Exception as ex: reqHeader, respStatus, respHeader, respBody = reqObj.headers, 555, {}, str(ex) slog.error("Fail to proxy %s: %s, %s: %s" % (type(ex), ex, reqPath, reqObj.headers)) try: reqTime = time.time() - respTime self.__sendResponse(reqObj, respStatus, respHeader, respBody) finally: respTime = time.time() - respTime - reqTime self.logPool.apply_async(self.__analyzeSession__, args=(isMock, reqObj.command, reqPath, reqParam, respBody, reqTime, respTime, respStatus, reqAddress, dict(reqHeader), dict(respHeader)))
def __runCases__(self, *modelTypes): slog.info(time.strftime("%Y-%m-%d %H:%M:%S testing...")) for modelType in modelTypes: if self.tc.isInMode("run", 1): try: tcObj = modelType() except Exception as ex: slog.warn('Instance Class: %s with %s' % (modelType, ex)) continue else: tcObj = modelType() try: tcInfo, caseRunList = self.tc.getRunInfo(tcObj.__class__.__name__, tcObj) except Exception as ex: slog.error("No case: %s" % ex) continue if len(caseRunList) == 0: continue for caseName in caseRunList: if eval("tcObj.%s()" % caseName) == False: return False if self.endScenarioHandler != None: self.endScenarioHandler(tcObj, caseName) if tcInfo.isTested: if self.tc.isInMode("run", 1): try: tcObj.tearDown() except Exception as ex: slog.warn('tearDown Should NOT Fail! %s: %s' % (ex, self.getMTestTraceBack())) else: tcObj.tearDown() if self.endModelHandler != None: self.endModelHandler(tcInfo) self.tlog.close() return self.tc.report()
def updateTask(): try: self.taskHandler.update(task) except Exception as ex: slog.error(ex)
def updateTask(isfinish=False, tret=None): try: self.taskHandler.update(task, isfinish, tret) except Exception as ex: slog.error("updateTask: %s" % ex)