def test_job_queue_kill_before_working():
def f():
gevent.sleep(999)
g = Greenlet(f)
g.done = False
g.link(lambda g: setattr(g, 'done', True))
queue = lets.JobQueue()
queue.put(g)
assert not g.done
queue.kill()
assert g.done
def _pool_requests(self, batch_no: int):
"""
Start a pool of requests (of batch size).
:param int batch_no: This batch number.
"""
self.logger.info("Starting batch: {}".format(batch_no))
pool = Pool(self.batch_size)
for _ in range(self.batch_size):
g = Greenlet(self.spammer.task)
g.link(self._request_finished)
pool.start(g)
class Periodic(object):
def __init__(self, interval, f, *args, **kwargs):
self.interval = interval
self.f = f
self.args = args
self.kwargs = kwargs
self._greenlet = None
def _run(self):
while True:
spawn_raw(self.f, *self.args, **self.kwargs)
sleep(self.interval)
def _discard_greenlet(self, val):
self._greenlet = None
@property
def started(self):
return bool(self._greenlet)
def start(self, right_away=True):
if self._greenlet:
raise RuntimeError("Periodic already started.")
self._greenlet = Greenlet(self._run)
self._greenlet.link(self._discard_greenlet)
if right_away:
self._greenlet.start()
else:
self._greenlet.start_later(self.interval)
def stop(self, block=True, timeout=None):
if not self._greenlet:
raise RuntimeError("Periodic is not started")
self._greenlet.kill(block=block, timeout=timeout)
self._greenlet = None
def __repr__(self):
return "<Periodic[%.2f seconds, %s] %r(*%r, **%r)>" % (
self.interval,
"running" if self.started else "stopped",
self.f,
self.args,
self.kwargs,
)
def create_greenlet(self, begin, end):
greenlet = Greenlet(self.update, (begin, end)) # greenlet
greenlet.link(self.finish)
greenlet.info = {
"id": begin,
"status": STATUS_WAITING, # status
"range_size": end - begin, # range size
"remain_size": end - begin, # remain size
"start_time": -1, # start time
"update_time": -1, # udpate time
"average_speed": -1, # average speed
"remain_time": -1, # remain time
"realtime_speed": -1, # realtime speed
"realtime_time": -1, # realtime time
"realtime_size": 0, # realtime size
}
self.greenlet_dict[begin] = greenlet
return greenlet
def create_greenlet(self, begin, end):
greenlet = Greenlet(self.update, (begin, end)) # greenlet
greenlet.link(self.finish)
greenlet.info = {
"id" : begin,
"status" : STATUS_WAITING, # status
"range_size" : end - begin, # range size
"remain_size" : end - begin, # remain size
"start_time" : -1, # start time
"update_time" : -1, # udpate time
"average_speed" : -1, # average speed
"remain_time" : -1, # remain time
"realtime_speed" : -1, # realtime speed
"realtime_time" : -1, # realtime time
"realtime_size" : 0, # realtime size
}
self.greenlet_dict[begin] = greenlet
return greenlet
class Periodic(object):
def __init__(self, interval, f, *args, **kwargs):
self.interval = interval
self.f = f
self.args = args
self.kwargs = kwargs
self._greenlet = None
def _run(self):
while True:
spawn_raw(self.f, *self.args, **self.kwargs)
sleep(self.interval)
def _discard_greenlet(self, val):
self._greenlet = None
@property
def started(self):
return bool(self._greenlet)
def start(self, right_away=True):
if self._greenlet:
raise RuntimeError("Periodic already started.")
self._greenlet = Greenlet(self._run)
self._greenlet.link(self._discard_greenlet)
if right_away:
self._greenlet.start()
else:
self._greenlet.start_later(self.interval)
def stop(self, block=True, timeout=None):
if not self._greenlet:
raise RuntimeError("Periodic is not started")
self._greenlet.kill(block=block, timeout=timeout)
self._greenlet = None
def __repr__(self):
return "<Periodic[%.2f seconds, %s] %r(*%r, **%r)>" % (
self.interval, 'running' if self.started else 'stopped', self.f,
self.args, self.kwargs)
def main():
q = Queue()
nlangs = 0
for lang in languages():
g = Greenlet(language_popularity, lang)
g.link(partial(got_langpop, q))
g.start()
nlangs += 1
ranks = {}
for rank in itertools.count(1):
while rank not in ranks and nlangs > 0:
result = q.get()
nlangs -= 1
new_rank, lang = result
ranks[new_rank] = lang
if rank not in ranks:
break
print(rank, ranks[rank])
for rank1 in sorted(r for r in ranks if r >= rank):
print(rank1, ranks[rank1])
def __init__(self, greenlet: Greenlet):
self.greenlet = greenlet
self.async_result: AsyncResult = AsyncResult()
greenlet.link(self.async_result)
# Block until all threads complete.
gevent.joinall(threads)
"""
def foo():
print "foo"
print gevent.getcurrent()
gevent.sleep(2)
return "foo"
def foo2(green):
print("foo2")
print gevent.getcurrent()
return "foo2"
print gevent.getcurrent()
t = Greenlet(foo)
print t.ready()
t.start()
t.link(foo2)
t.join(0)
#t.kill()
print "yes"
print t.ready()
print t.successful()
#print t.get()
print t.value
def __make_greenlet(self):
g = Greenlet(self._fn, self, *self._fn_args, **self._fn_kwargs)
g.link(self._callback)
return g
def __make(self):
g = Greenlet(self._fn, self, *self._fn_arg, **self._fn_kw)
g.link(self.__callback)
return g
import gevent
from gevent import Greenlet
import time
def foo():
print 'foo'
print 'foo again'
return "haha"
def bar():
print 'bar'
gevent.sleep(0)
print 'bar again'
g = Greenlet(foo)
class Study(object):
def __call__(self, args):
print "callback"
case = Study()
g.link(case)
g.start()
g.join()
