def test_cancel_unused(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.cancel() # Ticket is canceled and can be removed immediately. assert ticket.canceled info = ticket.info() assert info["canceled"] assert info["connections"] == 0
def test_cancel_no_connection(cfg): ticket = Ticket(testutil.create_ticket(ops=["read"]), cfg) ticket.cancel() # Ticket is canceled and can be removed immediately. assert ticket.canceled info = ticket.info() assert info["canceled"] assert not info["active"] assert info["connections"] == 0
def test_transfered_inactive_non_continuous_ops(): ticket = Ticket(testutil.create_ticket(ops=["read"])) # Run 2 non-continutes operations ticket.run(Operation(0, 100)) ticket.run(Operation(200, 100)) assert ticket.transferred() == 200 # Run last operation filling the hole - with some overlap. ticket.run(Operation(80, 120)) assert ticket.transferred() == 300
def test_cancel_timeout(cfg): ticket = Ticket(testutil.create_ticket(ops=["read"]), cfg) # Add conection - having connections does not block cancelation, but we # cannot have ongoing operations without a connection. ctx = Context() ticket.add_context(1, ctx) # Ongoing operation blocks cancel. ticket._add_operation(Operation(0, 100)) # Canceling will time out. with pytest.raises(errors.TransferCancelTimeout): ticket.cancel(timeout=0.001) # Ticket is marked as canceled, but the context was not closed. assert ticket.canceled assert not ctx.closed # Caller can poll ticket "active" property and remove the ticket when the # ticket is inactive. info = ticket.info() assert info["canceled"] assert info["active"] assert info["connections"] == 1
def test_repr(): ticket = Ticket(testutil.create_ticket( ops=["read"], filename="tmp_file")) ticket_repr = repr(ticket) info = ticket.info() del info["timeout"] for key, value in info.items(): pair = "%s=%r" % (key, value) assert pair in ticket_repr
def test_run_benchmark(cfg, workers, client_class, mode): ticket = Ticket(testutil.create_ticket(size=100 * 1024**3, ops=mode), cfg) client = client_class(ticket, workers) elapsed = client.run() if mode != ["read", "write"]: assert ticket.transferred() == ticket.size ops = ticket.size // client.io_size print("%d workers, %d ops, %.3f s, %.2f ops/s" % (client.workers, ops, elapsed, ops / elapsed))
def test_remove_context_error(cfg): class FailingContext: def __init__(self): self.count = 1 self.closed = False def close(self): if self.count > 0: self.count -= 1 raise RuntimeError("Cannot close yet") self.closed = True ticket = Ticket(testutil.create_ticket(ops=["read"]), cfg) ctx = FailingContext() ticket.add_context(1, ctx) # If closing a context fails, fail. The ticket cannot be removed # until this context is closed successfully. with pytest.raises(RuntimeError): ticket.cancel(timeout=0) assert not ctx.closed # Calling again will close context successfully, and the ticket can # be removed. ticket.cancel(timeout=0) assert ctx.closed
def test_transfered_inactive_empty_ops(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.run(Operation(0, 0)) assert ticket.transferred() == 0 ticket.run(Operation(1000, 0)) assert ticket.transferred() == 0
def test_remove_context_missing(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.add_context(1, Context()) assert ticket.info()["connections"] == 1 ticket.remove_context(2) assert ticket.info()["connections"] == 1
def test_cancel_wait(): ticket = Ticket(testutil.create_ticket(ops=["read"])) # Add connections using this ticket. connections = [] for i in range(4): ctx = Context() ticket.add_context(i, ctx) connections.append(ctx) def close_connections(): time.sleep(0.1) for i in range(4): ticket.remove_context(i) info = ticket.info() assert not info["canceled"] assert info["connections"] == 4 t = util.start_thread(close_connections) try: ticket.cancel(timeout=10) # After the ticket was canceled, number of connections must be zero. info = ticket.info() assert info["connections"] == 0 # And all contexts must be closed. assert all(ctx.closed for ctx in connections) finally: t.join()
def test_run_operation_benchmark(): # Run 1000000 operations with 4 concurrent threads. ticket = Ticket(testutil.create_ticket(ops=["read"])) operations = 10**6 workers = 4 chunk = 10**9 step = chunk * workers // operations def worker(offset, size): while offset < size: ticket.run(Operation(offset, step)) offset += step start = time.monotonic() threads = [] try: for i in range(workers): t = util.start_thread(worker, args=(i * chunk, chunk)) threads.append(t) finally: for t in threads: t.join() elapsed = time.monotonic() - start print("%d operations, %d concurrent threads in %.3f seconds (%d nsec/op)" % (operations, workers, elapsed, elapsed * 10**9 // operations))
def test_cancel_async(cfg): ticket = Ticket(testutil.create_ticket(ops=["read"]), cfg) ctx = Context() ticket.add_context(1, ctx) ticket._add_operation(Operation(0, 100)) ticket.cancel(timeout=0) # Ticket is marked as canceled, but the context was not closed. assert ticket.canceled assert not ctx.closed info = ticket.info() assert info["canceled"] assert info["active"] assert info["connections"] == 1
def test_cancel_async(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.add_context(1, None) ticket.cancel(timeout=0) # Ticket is canceled, but it cannot be removed. assert ticket.canceled info = ticket.info() assert info["canceled"] assert info["connections"] == 1
def test_canceled_fail_run_after(cfg): ticket = Ticket(testutil.create_ticket(ops=["read"]), cfg) class Operation: def __init__(self): self.done = False self.canceled = False def run(self): self.done = True ticket.cancel(timeout=0.001) def cancel(self): self.canceled = True op = Operation() # If ticket was canceled while ongoing operations are running, ticket run # will fail removing the operations. with pytest.raises(errors.AuthorizationError): ticket.run(op) assert op.done
def test_cancel_ongoing_operations(): ticket = Ticket(testutil.create_ticket(ops=["read"])) # Few connections are using this ticket. Each running an operation. ops = [] for i in range(4): ctx = Context() op = Operation() ticket.add_context(i, ctx) ticket._add_operation(op) ops.append(op) ticket.cancel(timeout=0) # All ongoing operations are canceled. assert all(op.canceled for op in ops)
def test_canceled_fail_add_context(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.cancel() ctx = Context() # Adding new context must fail. with pytest.raises(errors.AuthorizationError): ticket.add_context(2, ctx)
def test_ticket_run(): ticket = Ticket(testutil.create_ticket(ops=["read"])) op = Operation(0, 100) assert ticket.transferred() == op.done assert op.done == 0 ticket.run(op) assert ticket.transferred() == op.done assert op.done == 100
def test_canceled_fail_run_before(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.cancel() op = Operation() # Running operations must fail. with pytest.raises(errors.AuthorizationError): ticket.run(op) # Operation was not run. assert op.done == 0
def test_cancel_timeout(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.add_context(1, None) # Canceling will time out. with pytest.raises(errors.TicketCancelTimeout): ticket.cancel(timeout=0.001) # But ticket is marked as canceled. assert ticket.canceled # Caller can poll ticket status and remove the ticket when number of # connections is zero. info = ticket.info() assert info["canceled"] assert info["connections"] == 1
def test_cancel_idle_connection(cfg): ticket = Ticket(testutil.create_ticket(ops=["read"]), cfg) ctx = Context() ticket.add_context(1, ctx) ticket.cancel() # Ticket is canceled and can be removed immediately. assert ticket.canceled assert ctx.closed info = ticket.info() assert info["canceled"] assert not info["active"] # The conection context was closed. The connection will be closed when it # times out or when a user send the next request. assert info["connections"] == 1
def test_transferred_benchmark(concurrent): # Time trransferred call with multiple ongoing and completed operations. ticket = Ticket(testutil.create_ticket(ops=["read"])) calls = 10000 # Add some completed ranges - assume worst case when ranges are not # continues. for i in range(concurrent): ticket.run(Operation(i * 1000, 100)) # Add some ongoing operations - assume worst case when ranges are not # continues. for i in range(concurrent): ticket._add_operation(Operation(i * 1000 + 200, 100)) # Time transferred call - merging ongoing and completed ranges. start = time.monotonic() for i in range(calls): ticket.transferred() elapsed = time.monotonic() - start print("%d concurrent operations, %d calls in %.3f seconds (%d nsec/op)" % (concurrent, calls, elapsed, elapsed * 10**9 // calls))
def test_transferred_benchmark(cfg, workers): # Time trransferred call with multiple ongoing and completed operations. ticket = Ticket(testutil.create_ticket(ops=["read"]), cfg) ops = 10000 # Add some completed ranges - assume worst case when ranges are not # continues. for i in range(workers): ticket.run(Operation(i * 1000, 100)) # Add some ongoing operations - assume worst case when ranges are not # continues. for i in range(workers): ticket._add_operation(Operation(i * 1000 + 200, 100)) # Time transferred call - merging ongoing and completed ranges. start = time.monotonic() for i in range(ops): ticket.transferred() elapsed = time.monotonic() - start print("%d workers, %d ops, %.3f s, %.2f ops/s" % (workers, ops, elapsed, ops / elapsed))
def test_transfered_inactive_overlapping_ops(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.run(Operation(0, 120)) assert ticket.transferred() == 120 ticket.run(Operation(100, 100)) assert ticket.transferred() == 200 ticket.run(Operation(180, 120)) assert ticket.transferred() == 300
def test_transfered_inactive_unordered_ops(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.run(Operation(100, 100)) assert ticket.transferred() == 100 ticket.run(Operation(0, 100)) assert ticket.transferred() == 200 ticket.run(Operation(200, 100)) assert ticket.transferred() == 300
def test_remove_context_error(): class FailingContext: def __init__(self): self.count = 1 self.closed = False def close(self): if self.count > 0: self.count -= 1 raise RuntimeError("Cannot close yet") self.closed = True ticket = Ticket(testutil.create_ticket(ops=["read"])) ticket.add_context(1, FailingContext()) ticket.cancel(timeout=0) # If closing a context fails, keep it. The ticket cannot be removed until # this context is removed successfully. with pytest.raises(RuntimeError): ticket.remove_context(1) info = ticket.info() assert info["connections"] == 1 # Calling again will close and remove the context successfully. ticket.remove_context(1) info = ticket.info() assert info["connections"] == 0
def test_get_context(): ticket = Ticket(testutil.create_ticket(ops=["read"])) ctx = Context() ticket.add_context(1, ctx) assert ticket.get_context(1) is ctx
def test_get_context_missing(): ticket = Ticket(testutil.create_ticket(ops=["read"])) with pytest.raises(KeyError): ticket.get_context(1)
def test_transfer_id_unset(): ticket = Ticket(testutil.create_ticket()) assert ticket.transfer_id is None
def test_transfered_nothing(): ticket = Ticket(testutil.create_ticket(ops=["read"])) assert ticket.transferred() == 0
def test_transfer_id(): ticket = Ticket(testutil.create_ticket(transfer_id="123")) assert ticket.transfer_id == "123"