def test_poll_eos__no_data(aeron_directory, ipc_publication, stream_id):
context = Context(aeron_dir=aeron_directory)
subscription = context.add_subscription('aeron:ipc', stream_id)
result = subscription.poll_eos()
assert_that(result, is_(0))
# def test_poll_eos__single_image(aeron_directory):
# context = Context(aeron_dir=aeron_directory)
# subscription = context.add_subscription('aeron:udp?endpoint=localhost:40456|ttl=0', 199)
# publication = context.add_publication('aeron:udp?endpoint=localhost:40456|ttl=0', 199)
# sleep(0.5)
#
# publication.offer(b'abc')
# sleep(0.5)
#
# result = subscription.poll(lambda _: None)
# assert_that(result, is_(1))
#
# publication.close()
# del publication
# sleep(1)
#
# finished = list()
#
# result = subscription.poll_eos(lambda image: finished.append(image.session_id))
# assert_that(result, is_(1))
# def test_poll_eos__multiple_images(ipc_publication):
# pass
def test_image_available_unavailable_callbacks(aeron_directory):
class Handler(object):
def __init__(self):
self.available_images = list()
self.unavailable_images = list()
def on_image_available(self, *args):
self.available_images.append(args)
def on_image_unavailable(self, *args):
self.unavailable_images.append(args)
handler = Handler()
context = Context(aeron_dir=aeron_directory,
available_image_handler=handler.on_image_available,
unavailable_image_handler=handler.on_image_unavailable)
subscription = context.add_subscription('aeron:ipc', 6000)
publication_context = Context(aeron_dir=aeron_directory)
publication = publication_context.add_publication('aeron:ipc', 6000)
sleep(1)
publication.close()
del publication
sleep(1)
assert_that(handler.available_images, is_not(empty()))
assert_that(handler.unavailable_images, is_not(empty()))
def subscriber(args):
context = Context(
aeron_dir=args.prefix,
resource_linger_timeout=timedelta(milliseconds=args.linger),
# new_publication_handler=lambda *args: print(f'new publication - {args}'),
# new_subscription_handler=lambda *args: print(f'new subscription {args}'),
# available_image_handler=lambda *args: print(f'available image {args}'),
# unavailable_image_handler = lambda *args: print(f'unavailable image {args}')
)
subscriptions = []
for id in range(0, args.processes):
subscriptions.append(context.add_subscription(args.channel, id+1))
while True:
for sub in subscriptions:
# fragments_read = sub.poll(lambda data: print(bytes(data)))
fragments_read = sub.poll(processData)
if fragments_read == 0:
# eos_count = sub.poll_eos(lambda *args: print(f'end of stream: {args}'))
eos_count = sub.poll_eos(endOfStream)
if eos_count > 0:
return 0
def test_poll__not_connected(aeron_directory, stream_id):
# always connected
context = Context(aeron_dir=aeron_directory)
subscription = context.add_subscription('aeron:ipc', stream_id)
received = list()
result = subscription.poll(lambda data: received.append(data))
assert_that(result, is_(0))
def test_create__no_publisher(aeron_directory, stream_id):
# always connected
context = Context(aeron_dir=aeron_directory)
subscription = context.add_subscription('aeron:ipc', stream_id)
sleep(0.5)
assert_that(subscription.is_connected, is_(True))
assert_that(subscription.images, is_(empty()))
def test_create__with_publisher(aeron_directory, ipc_publication, stream_id):
# always connected
context = Context(aeron_dir=aeron_directory)
subscription = context.add_subscription('aeron:ipc', stream_id)
sleep(0.5)
assert_that(subscription.images, is_not(empty()))
assert_that(subscription.images, has_length(1))
assert_that(subscription.images[0].session_id, ipc_publication.session_id)
def test_poll__no_data(aeron_directory, ipc_publication, stream_id):
context = Context(aeron_dir=aeron_directory)
subscription = context.add_subscription('aeron:ipc', stream_id)
sleep(0.5)
assert_that(subscription.images, is_not(empty()))
assert_that(subscription.images, has_length(1))
assert_that(subscription.images[0].session_id, ipc_publication.session_id)
received = list()
result = subscription.poll(lambda data: received.append(data))
assert_that(result, is_(0))
def test_poll__multiple_sessions(aeron_directory, ipc_publication_1, ipc_publication_2, stream_id):
context = Context(aeron_dir=aeron_directory)
subscription = context.add_subscription('aeron:ipc', stream_id)
sleep(0.5)
assert_that(subscription.images, has_length(2))
ipc_publication_1.offer(b'abc')
ipc_publication_2.offer(b'cde')
received = list()
result = subscription.poll(lambda data, header: received.append((header.session_id, bytes(data))))
assert_that(result, is_(equal_to(2)))
assert_that(received, has_length(2))
def test_poll__multiple_fragments(aeron_directory, ipc_publication, stream_id):
context = Context(aeron_dir=aeron_directory)
subscription = context.add_subscription('aeron:ipc', stream_id)
sleep(0.5)
ipc_publication.offer(b'abc')
ipc_publication.offer(b'cde')
ipc_publication.offer(b'efg')
received = list()
result = subscription.poll(lambda data: received.append(bytes(data)), fragment_limit=3)
assert_that(result, is_(equal_to(3)))
assert_that(received, has_length(3))
assert_that(received[0], is_(equal_to(b'abc')))
assert_that(received[1], is_(equal_to(b'cde')))
assert_that(received[2], is_(equal_to(b'efg')))
def test_add_subscription__with_handlers(aeron_directory):
class Handler:
def __init__(self):
self.subscriptions = list()
def on_new_subscription(self, *args):
self.subscriptions.append(args)
handler = Handler()
context = Context(aeron_dir=aeron_directory,
new_subscription_handler=handler.on_new_subscription)
subscription = context.add_subscription('aeron:ipc', 546)
assert_that(handler.subscriptions, is_not(empty()))
assert_that(handler.subscriptions, has_length(equal_to(1)))
assert_that(handler.subscriptions[0][0], is_('aeron:ipc'))
assert_that(handler.subscriptions[0][1], is_(546))
def main():
try:
parser = ArgumentParser()
parser.add_argument('-p', '--prefix', default=None)
parser.add_argument('-c',
'--channel',
default='aeron:udp?endpoint=localhost:40123')
parser.add_argument('-s', '--stream_id', type=int, default=1)
args = parser.parse_args()
context = Context(aeron_dir=args.prefix,
new_subscription_handler=lambda *args: print(
f'new subscription {args}'),
available_image_handler=lambda *args: print(
f'available image {args}'),
unavailable_image_handler=lambda *args: print(
f'unavailable image {args}'))
subscription = context.add_subscription(args.channel, args.stream_id)
while True:
fragments_read = subscription.poll(lambda data: print(bytes(data)))
if fragments_read == 0:
eos_count = subscription.poll_eos(
lambda *args: print(f'end of stream: {args}'))
if eos_count > 0:
break
sleep(0.1)
return 0
except ArgumentError as e:
print(e, file=sys.stderr)
return -1
except Exception as e:
print(e, file=sys.stderr)
return -2
def test_add_subscription(aeron_directory):
context = Context(aeron_dir=aeron_directory)
subscription = context.add_subscription('aeron:ipc', 1000)
assert_that(subscription, is_not(None))
assert_that(subscription.channel, is_('aeron:ipc'))
assert_that(subscription.stream_id, is_(1000))