def test_downed_hub_during_chunk_pub_to_client_terminates_correctly(self):
global PORT
hub = junction.Hub(("127.0.0.1", PORT), [])
PORT += 2
l = []
ev = greenhouse.Event()
@hub.accept_publish('service', 0, 0, 'method')
def handle(x):
for item in x:
l.append(item)
ev.set()
hub.start()
client = junction.Client(("127.0.0.1", PORT - 2))
PORT += 2
client.connect()
client.wait_connected()
client = [client]
def gen():
yield 1
yield 2
self.kill_client(client)
client[0].publish('service', 0, 'method', (gen(),))
ev.wait(TIMEOUT)
self.assertEqual(l[:2], [1,2])
self.assertEqual(len(l), 3)
self.assertIsInstance(l[-1], junction.errors.LostConnection)
def main(environ, argv):
greenhouse.global_exception_handler(traceback.print_exception)
junction.configure_logging(level=1)
hub = junction.Hub(("", 9057), [("", 9056)])
hub.start()
greenhouse.Event().wait()
def __init__(self):
self._done = greenhouse.Event()
self._waits = set()
self._children = []
self._value = None
self._failure = None
self._cbacks = []
self._errbacks = []
def __init__(self, func, count):
self._func = func
self._count = count
self._workers = [None] * count
self._available = set()
self._backlog = collections.deque()
self._worker_closed = greenhouse.Event()
self._closed_count = 0
self._closing = False
def main(environ, argv):
greenhouse.global_exception_handler(traceback.print_exception)
junction.configure_logging(level=1)
hub = junction.Hub(("", 9056), [])
hub.accept_rpc('service', 0, 0, 'echostream', handle)
hub.start()
greenhouse.Event().wait()
def get_urls(urls):
count = len(urls)
results = {}
alldone = greenhouse.Event()
# each url gets its own greenlet to fetch it
for url in urls:
greenhouse.schedule(_get_one, args=(url, results, count, alldone))
alldone.wait()
return results
def test_nonblocking_when_set(self):
ev = greenhouse.Event()
l = [False]
ev.set()
@greenhouse.schedule
def f():
ev.wait()
l[0] = True
greenhouse.pause()
assert l[0]
def main():
hub = junction.Hub(("localhost", PORT), [("localhost", SERVICE_PORT)])
hub.start()
greenhouse.schedule(greenhouse.run_backdoor,
args=(("localhost", PORT + 1), {
'hub': hub
}))
try:
greenhouse.Event().wait()
except KeyboardInterrupt:
pass
def test_timeout_clears_waiters(self):
ev = greenhouse.Event()
l = [False]
@greenhouse.schedule
def f():
ev.wait(TESTING_TIMEOUT)
l[0] = True
greenhouse.pause_for(TESTING_TIMEOUT * 2)
assert l[0]
self.assertEqual(ev._waiters, [])
def test_blocks(self):
ev = greenhouse.Event()
l = [False]
@greenhouse.schedule
def f():
ev.wait()
l[0] = True
greenhouse.pause()
greenhouse.pause()
greenhouse.pause()
assert not l[0]
def main():
hub = junction.Hub(("localhost", PORT), [("localhost", MIDDLEMAN_PORT)])
hub.start()
hub.accept_rpc(WAIT_SERVICE, 0, 0, "wait", wait)
greenhouse.schedule(greenhouse.run_backdoor,
args=(("localhost", PORT + 1), {
'hub': hub
}))
try:
greenhouse.Event().wait()
except KeyboardInterrupt:
pass
def main(environ, argv):
finished = greenhouse.Event()
backdoor = greenhouse.greenlet(run_backdoor, args=(finished,))
greenhouse.schedule(backdoor)
# nothing in run_backdoor blocks until it succeeds in
# getting a port, so this can just be a simple pause
greenhouse.pause()
telnet = subprocess.Popen(['telnet', '127.0.0.1', str(BACKDOOR_PORT)])
rc = telnet.wait()
greenhouse.end(backdoor)
finished.wait()
return rc
def test_timeouts_in_grlets(self):
l = [False]
ev = greenhouse.Event()
@greenhouse.schedule
def f():
ev.wait(TESTING_TIMEOUT)
l[0] = True
greenhouse.pause()
assert not l[0]
greenhouse.pause_for(TESTING_TIMEOUT * 2)
assert l[0]
def main():
hub = junction.Hub((HOST, PORT), [(RELAY_HOST, RELAY_PORT)])
hub.start()
hub.accept_rpc(SERVICE, 0, 0, "echo", handler)
greenhouse.schedule(greenhouse.run_backdoor,
args=((BACKHOST, BACKPORT), {
'hub': hub
}))
try:
greenhouse.Event().wait()
except KeyboardInterrupt:
pass
def handle_map_reduce(self, dumped_source, dumped_mapper, dumped_reducer,
reduce_base, base_case_provided):
reducer = random.randrange(self._num_reducers)
mappers = self._hub.publish_receiver_count(
"%s-mapper" % (self._service, ), 0)
job_id = self._hub.rpc("%s-reducer" % (self._service, ), reducer,
"setup", (dumped_reducer, mappers, self._value,
reduce_base, base_case_provided), {})
self._hub.publish("%s-mapper" % (self._service, ), 0, "map",
(job_id, dumped_source, dumped_mapper, reducer), {})
self._active[(reducer, job_id)] = waiter = greenhouse.Event()
waiter.wait()
return self._active.pop((reducer, job_id))
def test_chunked_publish_success(self):
results = []
ev = greenhouse.Event()
@self.peer.accept_publish("service", 0, 0, "method")
def handler(items):
for item in items:
results.append(item)
ev.set()
for i in xrange(4):
greenhouse.pause()
self.sender.publish("service", 0, "method", ((x for x in xrange(5)),))
assert not ev.wait(TIMEOUT)
self.assertEqual(results, [0, 1, 2, 3, 4])
def test_rpc_ruled_out_by_service(self):
results = []
ev = greenhouse.Event()
@self.peer.accept_rpc("service1", 0, 0, "method")
def handler(item):
results.append(item)
ev.set()
for i in xrange(4):
greenhouse.pause()
self.assertRaises(junction.errors.Unroutable,
self.sender.rpc, "service2", 0, "method", (1,), {}, TIMEOUT)
assert ev.wait(TIMEOUT)
self.assertEqual(results, [])
def test_publish_success(self):
results = []
ev = greenhouse.Event()
@self.peer.accept_publish("service", 0, 0, "method")
def handler(item):
results.append(item)
if len(results) == 4:
ev.set()
for i in xrange(4):
greenhouse.pause()
self.sender.publish("service", 0, "method", (1,), {})
self.sender.publish("service", 0, "method", (2,), {})
self.sender.publish("service", 0, "method", (3,), {})
self.sender.publish("service", 0, "method", (4,), {})
ev.wait(TIMEOUT)
self.assertEqual(results, [1, 2, 3, 4])
def test_publish_ruled_out_by_service(self):
results = []
ev = greenhouse.Event()
@self.peer.accept_publish("service1", 0, 0, "method")
def handler(item):
results.append(item)
ev.set()
for i in xrange(4):
greenhouse.pause()
try:
self.sender.publish("service2", 0, "method", (1,), {})
except junction.errors.Unroutable:
# eat this as Clients don't get this raised, only Hubs
pass
assert ev.wait(TIMEOUT)
self.assertEqual(results, [])
def __init__(self, futures):
self.futures = set(futures)
self.done = greenhouse.Event()
self.completed_future = None
self.finished = False
def test_timeouts(self):
ev = greenhouse.Event()
start = time.time()
ev.wait(TESTING_TIMEOUT)
now = time.time()
assert now - start > TESTING_TIMEOUT, now - start
def test_isSet(self):
ev = greenhouse.Event()
assert not ev.is_set()
ev.set()
assert ev.is_set()