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 output():
while 1:
url=chan.receive()
print url
f=urllib2.urlopen(url)
#print f.read()
print 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 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 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 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, 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 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 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 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 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(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 __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 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 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 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 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
