def output(): while 1: url=chan.receive() print url f=urllib2.urlopen(url) #print f.read() print stackless.getcurrent()
def forceStart(serviceName, serviceType): global runningServices import stackless import service old_block_trap = stackless.getcurrent().block_trap stackless.getcurrent().block_trap = 1 try: oldInstance = runningServices.get(serviceName, None) if oldInstance: forceStop(serviceName) result = serviceType() setattr(result, "state", service.SERVICE_RUNNING) result = makeServiceThunk(result) runningServices[serviceName] = result ne = getattr(result, "__notifyevents__", []) if len(ne): for evt in ne: if (not hasattr(result, evt)): log("Missing event handler for %r on %r", evt, result) else: nl = sm.notify.setdefault(evt, list()) nl.append(result) return result finally: stackless.getcurrent().block_trap = old_block_trap
def SendEventWithoutTheStars(self, eventid, args, keywords = None): if keywords is None: keywords = {} if not eventid.startswith('Do'): self.LogError('SendEvent called with event ', eventid, ". All events sent via SendEvent should start with 'Do'") self.LogError("Not only is the programmer responsible for this a 10z3r, but he wears his mother's underwear as well") log.LogTraceback() if not self.notify.get(eventid, []) and not self.notifyObs.get(eventid, []): self.LogInfo("Orphan'd event. ", eventid, "doesn't have any listeners") shouldLogMethodCalls = self.ShouldLogMethodCalls() if shouldLogMethodCalls: if IsFullLogging(): self.LogMethodCall('SendEvent(', eventid, ',*args=', args, ',**kw=', keywords, ')') else: self.LogMethodCall('SendEvent(', eventid, ')') prefix = blue.pyos.taskletTimer.GetCurrent() + '::SendEvent_' + eventid + '::' old_block_trap = stackless.getcurrent().block_trap stackless.getcurrent().block_trap = 1 ret = [] try: for srv in self.notify.get(eventid, []): try: logname = prefix + self.GetLogName(srv) if ObjectShouldReceiveMessages(srv): if shouldLogMethodCalls: self.LogMethodCall('Calling ', logname) ret.append(ClockThisWithoutTheStars(logname, getattr(srv, eventid), args, keywords)) elif shouldLogMethodCalls: self.LogMethodCall('Skipping ', logname, ' (service not running)') except StandardError: self.LogError('In %s.%s' % (getattr(srv, '__guid__', logname), eventid)) log.LogException() sys.exc_clear() notifiedToRemove = [] for weakObj in self.notifyObs.get(eventid, []): obj = weakObj() if obj is None: notifiedToRemove.append(weakObj) else: try: if shouldLogMethodCalls: logname = prefix + str(obj) self.LogMethodCall('Calling ', logname) apply(getattr(obj, eventid), args, keywords) except StandardError: self.LogError('In %s.%s' % (getattr(weakObj, '__guid__', self.GetLogName(weakObj)), eventid)) log.LogException() sys.exc_clear() for toRemove in notifiedToRemove: if toRemove in self.notifyObs[eventid]: self.notifyObs[eventid].remove(toRemove) finally: bt = 0 if old_block_trap: bt = 1 stackless.getcurrent().block_trap = bt return tuple(ret)
def CallWrapper(*args, **kwds): current = stackless.getcurrent() current.startTime = blue.os.GetWallclockTimeNow() oldtimer = PushTimer(current.context) exc = None try: try: return method(*args, **kwds) except TaskletExit as e: pass except SystemExit as e: import logmodule as log log.general.Log('system %s exiting with %r' % (stackless.getcurrent(), e), log.LGINFO) except Exception: import logmodule as log log.LogException('Unhandled exception in %r' % stackless.getcurrent()) return except: traceback.print_exc() if exc: traceback.print_exception(exc[0], exc[1], exc[2]) finally: exc = None PopTimer(oldtimer) current.endTime = blue.os.GetWallclockTimeNow()
def testNonBlockingSend(self): ''' Test that when there is a waiting receiver, we can send without blocking with normal channel behaviour. ''' originalValue = 1 receivedValues = [] # Function to block when run in a tasklet. def f(testChannel): receivedValues.append(testChannel.receive()) # Get the tasklet blocked on the channel. channel = stackless.channel() tasklet = stackless.tasklet(f)(channel) tasklet.run() # Make sure that the current tasklet cannot block when it tries to receive. We do not want # to exit this test having clobbered the block trapping value, so we make sure we restore # it. oldBlockTrap = stackless.getcurrent().block_trap try: stackless.getcurrent().block_trap = True channel.send(originalValue) finally: stackless.getcurrent().block_trap = oldBlockTrap self.assertTrue( len(receivedValues) == 1 and receivedValues[0] == originalValue, "We sent a value, but it was not the one we received. Completely unexpected." )
def testNonBlockingSend(self): ''' Test that when there is a waiting receiver, we can send without blocking with normal channel behaviour. ''' originalValue = 1 receivedValues = [] # Function to block when run in a tasklet. def f(testChannel): receivedValues.append(testChannel.receive()) # Get the tasklet blocked on the channel. channel = stackless.channel() tasklet = stackless.tasklet(f)(channel) tasklet.run() # Make sure that the current tasklet cannot block when it tries to receive. We do not want # to exit this test having clobbered the block trapping value, so we make sure we restore # it. oldBlockTrap = stackless.getcurrent().block_trap try: stackless.getcurrent().block_trap = True channel.send(originalValue) finally: stackless.getcurrent().block_trap = oldBlockTrap self.assertTrue(len(receivedValues) == 1 and receivedValues[0] == originalValue, "We sent a value, but it was not the one we received. Completely unexpected.")
def CallWrapper(*args, **kwds): current = stackless.getcurrent() current.startTime = blue.os.GetWallclockTimeNow() oldtimer = PushTimer(current.context) exc = None try: try: return method(*args, **kwds) except TaskletExit as e: import log t = stackless.getcurrent() log.general.Log('tasklet (%s) %s exiting with %r' % (t.tasklet_id, t, e), log.LGINFO) except SystemExit as e: import log log.general.Log('system %s exiting with %r' % (stackless.getcurrent(), e), log.LGINFO) except Exception: import log print >> debugFile, 'Unhandled exception in tasklet', repr(stackless.getcurrent()) traceback.print_exc(file=debugFile) exc = sys.exc_info() log.LogException('Unhandled exception in %r' % stackless.getcurrent()) return except: traceback.print_exc() traceback.print_exc(file=debugFile) if exc: traceback.print_exception(exc[0], exc[1], exc[2]) traceback.print_exception(exc[0], exc[1], exc[2], file=debugFile) finally: exc = None PopTimer(oldtimer) current.endTime = blue.os.GetWallclockTimeNow()
def GetReferees(self, data, *args): refList = [] object = data.instanceData referrers = gc.get_referrers(object) myref = stackless.getcurrent().frame known = [ gc.garbage, stackless.getcurrent().frame, object, data, self.scroll ] for ref in referrers: if ref not in known: try: objectName = self.GetObjectName(ref) listEntry = ScrollEntryNode(decoClass=SE_GenericCore, id=id, name=objectName, label=objectName, sublevel=1) refList.append(listEntry) except Exception as e: log.LogError( 'Failed naming reference! Need to do something about this error' ) return refList
def testSendInsert(self): channel_obj = stackless.channel() self.assertEqual(None, channel_obj.queue) tasklet1 = stackless.tasklet(lambda: 1 / 0)() tasklet2 = stackless.tasklet(channel_obj.receive)() tasklet2.run() self.assertRaisesStr(RuntimeError, 'You cannot remove a blocked tasklet.', tasklet2.remove) # channel_obj.send inserts tasklet2 after current, and since tasklet1 was # after current, the insertion runs tasklet1 eventually, which triggers # the ZeroDivisionError, propagated to current (== main). self.assertRaises(ZeroDivisionError, channel_obj.send, 0) self.assertEqual(1, stackless.getruncount()) self.assertEqual(None, channel_obj.queue) channel_obj.preference = 1 # Prefer the sender. tasklet1 = stackless.tasklet(lambda: 1 / 0)() tasklet2 = stackless.tasklet(channel_obj.receive)() self.assertEqual(False, tasklet2.blocked) self.assertEqual(True, tasklet2.scheduled) tasklet2.run() self.assertEqual(True, tasklet2.blocked) self.assertEqual(True, tasklet2.scheduled) self.assertEqual(tasklet1, stackless.getcurrent().next) self.assertEqual(None, channel_obj.send(0)) self.assertEqual(tasklet1, stackless.getcurrent().next) self.assertEqual(tasklet2, stackless.current.prev) tasklet1.remove() stackless.schedule()
def _try_acquire(self): if not (super(RLock, self)._try_acquire() or self._owning == stackless.getcurrent()): return False self._owning = stackless.getcurrent() self._locked += 1 return True
def CreateServiceInstance(self, serviceName): old_block_trap = stackless.getcurrent().block_trap stackless.getcurrent().block_trap = 1 try: try: createName, createClass = self.classmapWithReplacements[serviceName] except KeyError: self._BuildClassMap() try: createName, createClass = self.classmapWithReplacements[serviceName] except KeyError: raise ServiceNotFound(serviceName) if createName != serviceName: print 'Replacing service %r with %r' % (serviceName, createName) replaceService = getattr(createClass, '__replaceservice__', None) if replaceService is not None and replaceService != serviceName: raise RuntimeError('Must not start %s directly as it replaces %s' % (serviceName, replaceService)) srv = createClass() if not isinstance(srv, service.Service): raise RuntimeError('Service name %r does not resolve to a service class (%r)' % (serviceName, createClass)) srv.__servicename__ = serviceName srv.session = base.GetServiceSession(serviceName) self.VerifyServiceExports(srv, serviceName) return srv finally: stackless.getcurrent().block_trap = old_block_trap
def CreateServiceInstance(self, serviceName): old_block_trap = stackless.getcurrent().block_trap stackless.getcurrent().block_trap = 1 try: try: createName, createClass = self.classmapWithReplacements[ serviceName] except KeyError: self._BuildClassMap() try: createName, createClass = self.classmapWithReplacements[ serviceName] except KeyError: raise ServiceNotFound(serviceName) if createName != serviceName: print 'Replacing service %r with %r' % (serviceName, createName) replaceService = getattr(createClass, '__replaceservice__', None) if replaceService is not None and replaceService != serviceName: raise RuntimeError( 'Must not start %s directly as it replaces %s' % (serviceName, replaceService)) srv = createClass() if not isinstance(srv, service.Service): raise RuntimeError( 'Service name %r does not resolve to a service class (%r)' % (serviceName, createClass)) srv.__servicename__ = serviceName srv.session = base.GetServiceSession(serviceName) self.VerifyServiceExports(srv, serviceName) return srv finally: stackless.getcurrent().block_trap = old_block_trap
def testSendInsert(self): channel_obj = stackless.channel() self.assertEqual(None, channel_obj.queue) tasklet1 = stackless.tasklet(lambda: 1 / 0)() tasklet2 = stackless.tasklet(channel_obj.receive)() tasklet2.run() self.assertRaisesStr( RuntimeError, 'You cannot remove a blocked tasklet.', tasklet2.remove) # channel_obj.send inserts tasklet2 after current, and since tasklet1 was # after current, the insertion runs tasklet1 eventually, which triggers # the ZeroDivisionError, propagated to current (== main). self.assertRaises(ZeroDivisionError, channel_obj.send, 0) self.assertEqual(1, stackless.getruncount()) self.assertEqual(None, channel_obj.queue) channel_obj.preference = 1 # Prefer the sender. tasklet1 = stackless.tasklet(lambda: 1 / 0)() tasklet2 = stackless.tasklet(channel_obj.receive)() self.assertEqual(False, tasklet2.blocked) self.assertEqual(True, tasklet2.scheduled) tasklet2.run() self.assertEqual(True, tasklet2.blocked) self.assertEqual(True, tasklet2.scheduled) self.assertEqual(tasklet1, stackless.getcurrent().next) self.assertEqual(None, channel_obj.send(0)) self.assertEqual(tasklet1, stackless.getcurrent().next) self.assertEqual(tasklet2, stackless.current.prev) tasklet1.remove() stackless.schedule()
def testNonBlockingReceive(self): ''' Test that when there is a waiting sender, we can receive without blocking with normal channel behaviour. ''' originalValue = 1 # Function to block when run in a tasklet. def f(testChannel, valueToSend): testChannel.send(valueToSend) # Get the tasklet blocked on the channel. channel = stackless.channel() tasklet = stackless.tasklet(f)(channel, originalValue) tasklet.run() # Make sure that the current tasklet cannot block when it tries to receive. We do not want # to exit this test having clobbered the block trapping value, so we make sure we restore # it. oldBlockTrap = stackless.getcurrent().block_trap try: stackless.getcurrent().block_trap = True value = channel.receive() finally: stackless.getcurrent().block_trap = oldBlockTrap tasklet.kill() self.assertEqual(value, originalValue, "We received a value, but it was not the one we sent. Completely unexpected.")
def stack(*argl, **argd): if log_level > LOG_LEVEL_ERROR: return print "S", str(id(stackless.getcurrent())), "| ************************************************************" print "S", str(id(stackless.getcurrent())), '|', _log(*argl, **argd) traceback.print_stack() print "S", str(id(stackless.getcurrent())), "| ************************************************************"
def testNonBlockingReceive(self): ''' Test that when there is a waiting sender, we can receive without blocking with normal channel behaviour. ''' originalValue = 1 # Function to block when run in a tasklet. def f(testChannel, valueToSend): testChannel.send(valueToSend) # Get the tasklet blocked on the channel. channel = stackless.channel() tasklet = stackless.tasklet(f)(channel, originalValue) tasklet.run() # Make sure that the current tasklet cannot block when it tries to receive. We do not want # to exit this test having clobbered the block trapping value, so we make sure we restore # it. oldBlockTrap = stackless.getcurrent().block_trap try: stackless.getcurrent().block_trap = True value = channel.receive() finally: stackless.getcurrent().block_trap = oldBlockTrap tasklet.kill() self.assertEqual( value, originalValue, "We received a value, but it was not the one we sent. Completely unexpected." )
def get_dict(self): d = object.__getattribute__(self, "__dict__")["_tasklets"] try: a = d[stackless.getcurrent()] except KeyError: a = {} d[stackless.getcurrent()] = a return a
def __AddMessage(self, char, system): #添加消息 old = stackless.getcurrent().set_atomic(True) try: if system not in self.__cachemsgs: self.__cachemsgs[system] = [] self.__cachemsgs[system].append(char) finally: stackless.getcurrent().set_atomic(old)
def release(self, override = False): with atomic(): if self.strict and not override: if stackless.getcurrent() not in self.threads: raise RuntimeError, 'wrong tasklet releasing strict semaphore' self.count += 1 self.threads.remove(stackless.getcurrent()) self.lockedWhen = None self._pump()
def writer(n): for i in range(n): with self.lock.acquired(): inlock.append(stackless.getcurrent()) for j in xrange(random.randint(1, 3)): stackless.schedule() stats.append(inlock[:]) inlock.remove(stackless.getcurrent())
def ProcessDispatchOrders(self, orders): ownersToPrime, tickersToPrime, allyTickersToPrime, stuffToAdd, newState, locationsToPrime = orders if locationsToPrime: try: cfg.evelocations.Prime(locationsToPrime) except StandardError: self.LogError('In michelle.Dispatcher') log.LogException() sys.exc_clear() if ownersToPrime: try: cfg.eveowners.Prime(ownersToPrime) except StandardError: self.LogError('In michelle.Dispatcher') log.LogException() sys.exc_clear() if tickersToPrime: try: cfg.corptickernames.Prime(tickersToPrime) except StandardError: self.LogError('In michelle.Dispatcher') log.LogException() sys.exc_clear() if allyTickersToPrime: try: cfg.allianceshortnames.Prime(allyTickersToPrime) except StandardError: self.LogError('In michelle.Dispatcher') log.LogException() sys.exc_clear() realBalls = {} for ballID, slimItem in stuffToAdd: try: if self.__bp and ballID in self.__bp.balls: ball = self.__bp.balls[ballID] if not self.__bp.slimItems.has_key(ballID): realBalls[ballID] = (ball, slimItem) self.__bp.slimItems[ballID] = slimItem except StandardError: self.LogError('In michelle.Dispatcher') log.LogException() sys.exc_clear() if len(realBalls): t = stackless.getcurrent() timer = t.PushTimer(blue.pyos.taskletTimer.GetCurrent() + '::DoBallsAdded') sm.SendEvent('DoBallsAdded', realBalls.values()) t.PopTimer(timer) if newState is not None: t = stackless.getcurrent() timer = t.PushTimer(blue.pyos.taskletTimer.GetCurrent() + '::OnNewState') sm.ScatterEvent('OnNewState', newState) t.PopTimer(timer)
def release(self): if self.__reentrantRefs: # MEB: assert self.thread is stackless.getcurrent() assert self.thread is stackless.getcurrent() or IsCurrentSynonymOf(self.thread) # MEB: if self.thread is not stackless.getcurrent(): if not (self.thread is stackless.getcurrent() or IsCurrentSynonymOf(self.thread)): raise RuntimeError, "wrong tasklet releasing reentrant CriticalSection" self.__reentrantRefs -= 1 else: Semaphore.release(self)
def testTempval(self): def Worker(items): items.append(stackless.schedule()) items.append(stackless.schedule(None)) items.append(stackless.schedule('foo')) items.append(stackless.schedule(42)) items = [] tasklet_obj = stackless.tasklet(Worker)(items) self.assertEqual(None, tasklet_obj.tempval) self.assertEqual([], items) stackless.current.tempval = 5 self.assertEqual(stackless.getcurrent(), stackless.schedule()) self.assertEqual(None, stackless.current.tempval) self.assertEqual(tasklet_obj, tasklet_obj.tempval) self.assertEqual([], items) stackless.schedule() self.assertEqual(None, tasklet_obj.tempval) self.assertEqual([tasklet_obj], items) stackless.schedule() self.assertEqual('foo', tasklet_obj.tempval) self.assertEqual([tasklet_obj, None], items) tasklet_obj.tempval = False stackless.schedule() self.assertEqual([tasklet_obj, None, False], items) self.assertEqual(42, tasklet_obj.tempval) stackless.schedule() self.assertEqual([tasklet_obj, None, False, 42], items) # Upon TaskletExit. self.assertEqual(None, tasklet_obj.tempval) self.assertEqual(1, stackless.getruncount()) self.assertEqual(stackless.getcurrent(), stackless.schedule()) self.assertEqual(None, stackless.current.tempval) self.assertEqual(43, stackless.schedule(43)) # This seems to be a strange Stackless quirk, this should be 43. self.assertEqual(None, stackless.getcurrent().tempval) self.assertEqual(54, stackless.schedule_remove(54)) self.assertEqual(None, stackless.current.tempval) def Worker2(items, main_tasklet): items.append(stackless.getcurrent().tempval) items.append(stackless.schedule(44)) items.append(stackless.current.tempval) main_tasklet.insert() del items[:] stackless.tasklet(Worker2)(items, stackless.getcurrent()) self.assertEqual(55, stackless.schedule_remove(55)) self.assertEqual(None, stackless.current.tempval) self.assertEqual([None, 44, None], items) self.assertRaisesStr(AssertionError, '', stackless.schedule, stackless.bomb(AssertionError)) self.assertRaisesStr(AssertionError, 'foo', stackless.schedule, stackless.bomb(AssertionError, 'foo'))
def Parallel(funcs,exceptionHandler=None,maxcount=30): ''' Executes in parallel all the function calls specified in the list/tuple 'funcs', but returns the return values in the order of the funcs list/tuple. If an exception occurs, only the first exception will reach you. The rest will dissapear in a puff of logic. Each 'func' entry should be a tuple/list of: 1. a function to call 2. a tuple of arguments to call it with 3. optionally, a dict of keyword args to call it with. ''' if not funcs: return context = "ParallelHelper::"+getattr(stackless.getcurrent(),"context","???") ch = stackless.channel(), id(stackless.getcurrent()) ret = [ None ] * len(funcs) n = len(funcs) if n > maxcount: n = maxcount for i in range(n): if type(funcs[i]) != types.TupleType: raise RuntimeError("Parallel requires a list/tuple of (function, args tuple, optional keyword dict,)") Pool(context, ParallelHelper, ch, i, funcs[i]) for i in range(len(funcs)): ok, bunch = ch[0].receive() if ok: idx,val = bunch if len(funcs[i])==4: ret[idx] = (funcs[i][3], val,) else: ret[idx] = val else: try: raise bunch[0],bunch[1],bunch[2] except StandardError: if exceptionHandler: exctype, exc, tb = sys.exc_info() try: try: apply( exceptionHandler, (exc,) ) except StandardError: raise exc, None, tb finally: exctype, exc, tb = None, None, None else: StackTrace() raise if n<len(funcs): if type(funcs[n]) != types.TupleType: raise RuntimeError("Parallel requires a list/tuple of (function, args tuple, optional keyword dict,)") Pool(context, ParallelHelper, ch, n, funcs[n]) n+=1 return ret
def acquire(self): if self.strict: assert self.thread is not stackless.getcurrent() if self.thread is stackless.getcurrent(): raise RuntimeError, "tasklet deadlock, acquiring tasklet holds strict semaphore" self.count -= 1 if self.count < 0: self.waiting.receive() self.lockedWhen = time.time() self.thread = stackless.getcurrent()
def try_acquire(self): with atomic(): if self.strict: if self.count <= 0 and stackless.getcurrent() in self.threads: raise RuntimeError, 'tasklet deadlock, acquiring tasklet holds strict semaphore' if self.count > 0: self.count -= 1 self.lockedWhen = blue.os.GetWallclockTime() self.threads.append(stackless.getcurrent()) return True return False
def lock(self, relockKey=None): if self._islock == True: if self._fttask == stackless.getcurrent(): self.relock += 1 return if self.relockKey != None and self.relockKey == relockKey: self.relock += 1 return self.receive() self._islock = True self._fttask = stackless.getcurrent()
def __acquire_inner(self): while 1: try: if self.lockers.has_key(stackless.getcurrent()): self.lockers[stackless.getcurrent()] += 1 else: self.lockers[stackless.getcurrent()] = 1 break except: StackTrace() sys.exc_clear()
def release(self): if self.strict: assert self.thread is stackless.getcurrent() if self.thread is not stackless.getcurrent(): raise RuntimeError, "wrong tasklet releasing strict semaphore" self.count += 1 self.thread = None self.lockedWhen = None if self.count <= 0: PoolWorker("uthread::Semaphore::delayed_release",self.__delayed_release)
def ChainEventWithoutTheStars(self, eventid, args, keywords = None): if keywords is None: keywords = {} if not eventid.startswith('Process'): self.LogError('ChainEvent called with event ', eventid, ". All events sent via ChainEvent should start with 'Process'") self.LogError("Not only is the programmer responsible for this a 10z3r, but he wears his mother's underwear as well") log.LogTraceback() if stackless.getcurrent().block_trap or stackless.getcurrent().is_main: raise RuntimeError("ChainEvent is blocking by design, but you're block trapped. You have'll have to find some alternative means to do Your Thing, dude.") if not self.notify.get(eventid, []) and not self.notifyObs.get(eventid, []): self.LogInfo("Orphan'd event. ", eventid, "doesn't have any listeners") shouldLogMethodCalls = self.ShouldLogMethodCalls() if shouldLogMethodCalls: self.LogMethodCall('ChainEvent(', eventid, ',*args=', args, ',**kw=', keywords, ')') prefix = blue.pyos.taskletTimer.GetCurrent() + '::ChainEvent_' + eventid + '::' ret = [] for srv in self.notify.get(eventid, []): contextName = self.GetLogName(srv) try: logname = prefix + contextName if ObjectShouldReceiveMessages(srv): if shouldLogMethodCalls: self.LogMethodCall('Calling ', logname) retval = ClockThisWithoutTheStars(logname, getattr(srv, eventid), args, keywords) ret.append(retval) elif shouldLogMethodCalls: self.LogMethodCall('Skipping ', logname, ' (service not running)') except StandardError: self.LogError('In %s.%s' % (contextName, eventid)) log.LogException() sys.exc_clear() notifiedToRemove = [] for weakObj in self.notifyObs.get(eventid, []): obj = weakObj() if obj is None: notifiedToRemove.append(weakObj) else: contextName = self.GetLogName(weakObj) try: logname = prefix + contextName if shouldLogMethodCalls: self.LogMethodCall('Calling ', prefix + str(obj)) ClockThisWithoutTheStars(logname, getattr(obj, eventid), args, keywords) except StandardError: self.LogError('In %s.%s:' % (contextName, eventid)) log.LogException() sys.exc_clear() for toRemove in notifiedToRemove: if toRemove in self.notifyObs[eventid]: self.notifyObs[eventid].remove(toRemove) return tuple(ret)
def func(n, counter): for i in range(n): with self.lock: counter[0] += 1 self.assertEqual(have, []) have.append(stackless.getcurrent()) for i in xrange(random.randint(1, 5)): stackless.schedule() self.assertEqual(have, [stackless.getcurrent()]) have.remove(stackless.getcurrent()) stackless.schedule()
def release(self): if self.strict: assert self.thread is stackless.getcurrent() if self.thread is not stackless.getcurrent(): raise RuntimeError, "wrong tasklet releasing strict semaphore" self.count += 1 self.thread = None self.lockedWhen = None if self.count <= 0: PoolWorker("uthread::Semaphore::delayed_release", self.__delayed_release)
def release(self): if self.__reentrantRefs: # MEB: assert self.thread is stackless.getcurrent() assert self.thread is stackless.getcurrent() or IsCurrentSynonymOf( self.thread) # MEB: if self.thread is not stackless.getcurrent(): if not (self.thread is stackless.getcurrent() or IsCurrentSynonymOf(self.thread)): raise RuntimeError, "wrong tasklet releasing reentrant CriticalSection" self.__reentrantRefs -= 1 else: Semaphore.release(self)
def blocking(func, *args, **kwargs): """ Wrap a function like the deferred decorator but call it as a blocking call to support synchronous calls in a tasklet outside of the reactor. WARNING: Currently does not function. """ func2 = tasklet(func) deferred = func2(*args, **kwargs) if REACTASK != sl.getcurrent() and sl.getcurrent() != sl.getmain(): return _block_on(deferred) raise RuntimeError("Cannot block in reactor task")
def lock(self): if not self.locked: self.locked = True self.owner = stackless.getcurrent() return True if self.owner == stackless.getcurrent(): return False self.receive() self.locked = True self.owner = stackless.getcurrent() return True
def upload(self): """ 如果上传失败,每隔2*n的时间重试一次,重试4次 """ key = stackless.getcurrent()._fttask.run_argl[0] data = stackless.getcurrent()._fttask.run_argl[1] times = stackless.getcurrent()._fttask.run_argl[2] ret, _ = majiang_conf.uploadVideo(key, data) if ret == 0: ftlog.debug("MJCreateTableRecordMsg: upload the record success!!!") if ret != 0 and times <= 16: times = times * 2 FTTimer(SCANRATE * times, self.upload, key, data, times)
def child(r): r.b1 = c.balance r.rc1 = stackless.getruncount() r.cur1 = stackless.getcurrent() r.blocked1 = r.cur1.blocked r.alive1 = r.cur1.alive try: c.receive() finally: r.b2 = c.balance r.rc2 = stackless.getruncount() r.cur2 = stackless.getcurrent() r.blocked2 = r.cur2.blocked r.alive2 = r.cur2.alive
def tasklet(self): global DEBUG_TASK_MAIN_TIME, DEBUG_TASK_MAP, DEBUG_TASK_SCHEDULE, SLOW_TASK_TIMES self._return_channel = FTChannel() self._me = stackless.getcurrent() if DEBUG_TASK_SCHEDULE: tkey = repr(self._me) DEBUG_TASK_MAP[tkey].insert(0, (self.run_args['creattime'], "create")) DEBUG_TASK_MAP[tkey].append((time(), "run")) self._timeocall = None self._me._fttask = self ctn = time() try: self.handle() ct = time() rtime = ct - ctn time_recv = self.run_args.get('time_recv', 0) if time_recv: time_recv = ctn - time_recv if rtime > SLOW_TASK_TIMES or time_recv > SLOW_TASK_TIMES: ftlog.warn('TASKLET TOO SLOW !! runtime=%0.6f' % (rtime), 'schedule=%0.6f' % (time_recv), 'ct=', ct, 'args=', self.run_args) except: ftlog.error('tasklet handle error', self.run_args) FTTasklet.concurrent_task_count -= 1 if DEBUG_TASK_SCHEDULE: del DEBUG_TASK_MAP[tkey]
def query(dst, data, userheader1='', userheader2='', timeout=2, notimeoutex=0, returnDeffer=0): src = ftcon.global_config["server_id"] server_conf = ftcon.getServerConf(src) agent_id = server_conf['agent'] protocol = ftcon.serverid_protocol_map[agent_id] if ide_debug(): ide_print_pack("Query[%s]" % dst.split("-")[0], json.loads(data)) d = protocol.query(src, dst, userheader1, userheader2, data, timeout, notimeoutex=notimeoutex) if returnDeffer == 1: return d res = stackless.getcurrent()._fttask.waitDefer(d) global _QUERY_SLOW_TIME if isinstance(res, tuple): msg = res[0] query_write_time = res[1] query_recive_time = res[2] ct = time() if ct - query_write_time > _QUERY_SLOW_TIME: if performance.PERFORMANCE_NET: msg = performance.linkMsgTime('DO', msg) ftlog.warn('QUERY REPLAY SLOW ! reply=%0.6f' % (query_recive_time - query_write_time), 'schedule=%0.6f' % (ct - query_recive_time), 'total=%0.6f' % (ct - query_write_time), 'dst=', dst, 'request=', data, 'response=', msg) return msg return res
def Read(self, bufsize=4096, flags=0): if stackless.getcurrent().is_main: raise RuntimeError( "You can't Read from a socket in a synchronous manner without blocking, dude." ) try: r = self.socket.recv(bufsize, flags) except socket.error as e: if e[0] in (10053, 10054, 995): self.Close(localization.GetByLabel( '/Carbon/MachoNet/SocketWasClosed'), exception=e) else: log.LogException() self.Close(localization.GetByLabel( '/Carbon/MachoNet/SomethingHappenedSocketWasClosed'), exception=e) raise GPSTransportClosed(**self.closeReason) except Exception as e: self.Close(localization.GetByLabel( '/Carbon/MachoNet/SomethingHappenedSocketWasClosed'), exception=e) raise if not r: self.Close( localization.GetByLabel( '/Carbon/MachoNet/ConnectionWasClosed')) raise GPSTransportClosed(**self.closeReason) if self.socketStatsEnabled: self.statsBytesReadPerPacket.AddSample(len(r)) self.statsBytesRead.Add(len(r)) self.statsPacketsRead.Add() return r
def killComplete(self, force=False): if (self == mainTasklet or self == stackless.getcurrent()) and not force: return 0 super().kill() super().remove() del allTasklets[self.name]
def onMsg(self): pack = stackless.getcurrent()._fttask.pack ftlog.debug('A2AProtocol->', FTTasklet.concurrent_task_count, '[' + pack + ']') src, dst, queryid, userheader1, userheader2, message = agentmsg.unpack( pack) if src == None or dst == None: ftlog.info("ERROR, recive a error format message") return if self.peer_id == 0: self.peer_id = src ftcon.serverid_protocol_map[self.peer_id] = self ftlog.info("Receive other agent register, agentid=", self.peer_id) return # 处理agent服务自身的命令 if dst == ftcon.global_config[ "server_id"] and A2AProtocol.onCommand != None: # ftlog.debug('A2AProtocol-> it self command !!') A2AProtocol.onCommand(self, src, queryid, userheader1, userheader2, message) return try: # 从其他agent过来的数据,转给连接的dst service # ftlog.debug('A2AProtocol->send to target->', dst) protocol = ftcon.serverid_protocol_map[dst] if performance.PERFORMANCE_NET: pack = performance.linkMsgTime('LW', pack) protocol.transport.write(pack + '\r\n') except: ftlog.error('msg route error, dst_server_id=', dst)
def Connect(self, address): if stackless.getcurrent().is_main: raise RuntimeError("Can't do a Connect() on the main thread") s = socket.socket() self._PreSocketConnectOperations(s) address = address.encode('ascii') try: host, port = address.split(':') port = int(port) if port < 1 or port > 65535: raise GPSBadAddress(localization.GetByLabel('/Carbon/MachoNet/SpecifiedPortNotvalid')) except ValueError as e: raise GPSBadAddress(localization.GetByLabel('/Carbon/MachoNet/SpecifiedPortNotValidNotInt'), e) except Exception as e: raise GPSBadAddress(localization.GetByLabel('/Carbon/MachoNet/SpecifiedAddressBogus'), e) try: s.connect((host, port)) except socket.gaierror as e: raise GPSBadAddress(localization.GetByLabel('/Carbon/MachoNet/CouldNotConnectToAddress'), e) except socket.error as e: raise GPSTransportClosed(localization.GetByLabel('/Carbon/MachoNet/CouldNotConnectToAddress'), exception=e) if self.MaxPacketSize: s.setmaxpacketsize(self.MaxPacketSize) return self.Transport()(s)
def channel_wait(chan, timeout): if timeout is None: chan.receive() return True waiting_tasklet = stackless.getcurrent() def break_wait(): # careful to only timeout if it is still blocked. This ensures # that a successful channel.send doesn't simultaneously result in # a timeout, which would be a terrible source of race conditions. with atomic(): if waiting_tasklet and waiting_tasklet.blocked: waiting_tasklet.raise_exception(LockTimeoutError) with atomic(): try: # schedule the break event after a certain time event_queue.push_after(break_wait, timeout) chan.receive() return True except LockTimeoutError: return False finally: waiting_tasklet = None