def test_async_multiple_managers_queue_process_multiple_ports(self):
tbl = Table({"a": int, "b": float, "c": str})
tbl2 = Table({"a": int, "b": float, "c": str})
port_ids = [0]
port_data = [{"a": 0, "b": 0, "c": "0"}]
for i in range(10):
port_id = tbl.make_port()
port_id2 = tbl2.make_port()
assert port_id == port_id2
port_ids.append(port_id)
port_data.append({
"a": port_id,
"b": port_id * 1.5,
"c": str(port_id)
})
manager = PerspectiveManager()
manager2 = PerspectiveManager()
manager.host_table("tbl", tbl)
manager2.host_table("tbl2", tbl2)
manager.set_loop_callback(TestAsync.loop.add_callback)
manager2.set_loop_callback(TestAsync.loop.add_callback)
@syncify
def _task():
random.shuffle(port_ids)
for port_id in port_ids:
idx = port_id if port_id < len(port_ids) else len(port_ids) - 1
tbl.update([port_data[idx]], port_id=port_id)
tbl2.update([port_data[idx]], port_id=port_id)
return (tbl.size(), tbl2.size())
assert _task() == (11, 11)
def test_async_multiple_managers_mixed_queue_process_multiple_ports(self):
sentinel = {"async": 0, "sync": 0}
def _counter(key, f, *args, **kwargs):
sentinel[key] += 1
return f(*args, **kwargs)
sync_process = partial(_counter, "sync")
async_process = partial(TestAsync.loop.add_timeout, 1, _counter,
"async")
tbl = Table({"a": int, "b": float, "c": str})
tbl2 = Table({"a": int, "b": float, "c": str})
port_ids = [0]
port_data = [{"a": 0, "b": 0, "c": "0"}]
for i in range(10):
port_id = tbl.make_port()
port_id2 = tbl2.make_port()
assert port_id == port_id2
port_ids.append(port_id)
port_data.append({
"a": port_id,
"b": port_id * 1.5,
"c": str(port_id)
})
manager = PerspectiveManager()
manager2 = PerspectiveManager()
manager.host_table("tbl", tbl)
manager2.host_table("tbl2", tbl2)
# manager uses tornado, manager2 is synchronous
manager.set_loop_callback(async_process)
manager2.set_loop_callback(sync_process)
random.shuffle(port_ids)
@syncify
def _task():
for port_id in port_ids:
idx = port_id if port_id < len(port_ids) else len(port_ids) - 1
tbl.update([port_data[idx]], port_id=port_id)
_task()
for port_id in port_ids:
idx = port_id if port_id < len(port_ids) else len(port_ids) - 1
tbl2.update([port_data[idx]], port_id=port_id)
@syncify
def _get_size():
size = tbl.size()
tbl.delete()
return size
assert _get_size() == 11
assert tbl2.size() == 11
assert sentinel["async"] == 2
assert sentinel["sync"] == 12
tbl2.delete()
def test_async_multiple_managers_queue_process_multiple_ports(self):
tbl = Table({
"a": int,
"b": float,
"c": str
})
tbl2 = Table({
"a": int,
"b": float,
"c": str
})
port_ids = [0]
port_data = [{
"a": 0,
"b": 0,
"c": "0"
}]
for i in range(10):
port_id = tbl.make_port()
port_id2 = tbl2.make_port()
assert port_id == port_id2
port_ids.append(port_id)
port_data.append({
"a": port_id,
"b": port_id * 1.5,
"c": str(port_id)
})
manager = PerspectiveManager()
manager2 = PerspectiveManager()
manager.host_table("tbl", tbl)
manager2.host_table("tbl2", tbl2)
manager._set_queue_process(TestAsync.wrapped_queue_process)
manager2._set_queue_process(TestAsync.wrapped_queue_process)
random.shuffle(port_ids)
for port_id in port_ids:
idx = port_id if port_id < len(port_ids) else len(port_ids) - 1
tbl.update([port_data[idx]], port_id=port_id)
tbl2.update([port_data[idx]], port_id=port_id)
# assert that process gets called at some point
assert SENTINEL.get() != 0
def test_async_queue_process_multiple_ports(self):
tbl = Table({"a": int, "b": float, "c": str})
port_ids = [0]
port_data = [{"a": 0, "b": 0, "c": "0"}]
for i in range(10):
port_id = tbl.make_port()
port_ids.append(port_id)
port_data.append({
"a": port_id,
"b": port_id * 1.5,
"c": str(port_id)
})
assert port_ids == list(range(0, 11))
manager = PerspectiveManager()
manager.host(tbl)
manager.set_loop_callback(TestAsync.loop.add_callback)
assert syncify(lambda: tbl.size())() == 0
random.shuffle(port_ids)
@syncify
def _tbl_task():
for port_id in port_ids:
idx = port_id if port_id < len(port_ids) else len(port_ids) - 1
tbl.update([port_data[idx]], port_id=port_id)
size = tbl.size()
tbl.delete()
return size
assert len(port_ids) == 11
assert _tbl_task() == 11
def test_async_queue_process_multiple_ports(self):
tbl = Table({
"a": int,
"b": float,
"c": str
})
port_ids = [0]
port_data = [{
"a": 0,
"b": 0,
"c": "0"
}]
for i in range(10):
port_id = tbl.make_port()
port_ids.append(port_id)
port_data.append({
"a": port_id,
"b": port_id * 1.5,
"c": str(port_id)
})
assert port_ids == list(range(0, 11))
manager = PerspectiveManager()
manager._set_queue_process(TestAsync.wrapped_queue_process)
manager.host(tbl)
assert tbl.size() == 0
random.shuffle(port_ids)
for port_id in port_ids:
idx = port_id if port_id < len(port_ids) else len(port_ids) - 1
tbl.update([port_data[idx]], port_id=port_id)
# assert that process is being called asynchronously
assert SENTINEL.get() > 0
tbl.delete()
def test_async_multiple_managers_mixed_queue_process_multiple_ports(self):
# mutate when synchronously calling queue_process for each update
SENTINEL_2 = AsyncSentinel(0)
def sync_queue_process(table_id, state_manager):
SENTINEL_2.set(SENTINEL_2.get() - 1)
state_manager.call_process(table_id)
tbl = Table({
"a": int,
"b": float,
"c": str
})
tbl2 = Table({
"a": int,
"b": float,
"c": str
})
port_ids = [0]
port_data = [{
"a": 0,
"b": 0,
"c": "0"
}]
for i in range(10):
port_id = tbl.make_port()
port_id2 = tbl2.make_port()
assert port_id == port_id2
port_ids.append(port_id)
port_data.append({
"a": port_id,
"b": port_id * 1.5,
"c": str(port_id)
})
manager = PerspectiveManager()
manager2 = PerspectiveManager()
manager.host_table("tbl", tbl)
manager2.host_table("tbl2", tbl2)
# manager uses tornado, manager2 is synchronous
manager._set_queue_process(TestAsync.wrapped_queue_process)
manager2._set_queue_process(sync_queue_process)
random.shuffle(port_ids)
for port_id in port_ids:
idx = port_id if port_id < len(port_ids) else len(port_ids) - 1
tbl.update([port_data[idx]], port_id=port_id)
tbl2.update([port_data[idx]], port_id=port_id)
assert SENTINEL.get() != 0
assert SENTINEL_2.get() == -11
tbl2.delete()
tbl.delete()
