async def test_exception_in_handler(test_server, protocol, loop, from_details, to_details): async def handler(dialog, request): raise RuntimeError('TestError') app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server_app.dialplan.add_user('pytest', {'SUBSCRIBE': handler}) server = await test_server(server_app) peer = await app.connect( protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port']) ) subscribe_dialog = peer.create_dialog( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) response = await subscribe_dialog.subscribe() assert response.status_code == 500 assert response.status_message == 'Server Internal Error' await server_app.close() await app.close()
async def test_cancel(test_server, protocol, loop, from_details, to_details): subscribe_dialog = None cancel_future = loop.create_future() async def subscribe(dialog, request): subscribe_dialog.close() async def cancel(dialog, request): cancel_future.set_result(request) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server_app.dialplan.add_user('pytest', { 'SUBSCRIBE': subscribe, 'CANCEL': cancel }) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port'])) subscribe_dialog = peer.create_dialog( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) with pytest.raises(asyncio.CancelledError): await subscribe_dialog.subscribe() result = await cancel_future assert result.method == 'CANCEL' await app.close() await server_app.close()
async def test_exception_in_handler(test_server, protocol, loop, from_details, to_details, close_order): class Dialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.on_subscribe async def on_subscribe(self, request, message): raise RuntimeError('Test error') app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop, dialplan=Dialplan()) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port'])) subscription = await peer.subscribe( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) assert subscription.status_code == 500 assert subscription.status_message == 'Server Internal Error' if close_order[0] == 'client': await app.close() await server_app.close() else: await server_app.close() await app.close()
async def test_subscribe(test_server, protocol, loop, from_details, to_details): callback_complete = loop.create_future() async def handler(dialog, request): await dialog.reply(request, status_code=200) callback_complete.set_result(request) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server_app.dialplan.add_user('pytest', {'SUBSCRIBE': handler}) server = await test_server(server_app) peer = await app.connect( protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port']) ) subscribe_dialog = peer.create_dialog( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) response = await subscribe_dialog.subscribe(expires=1800) received_request = await callback_complete assert response.status_code == 200 assert response.status_message == 'OK' assert received_request.method == 'SUBSCRIBE' await server_app.close() await app.close()
async def test_invite(test_server, protocol, loop, from_details, to_details, close_order): call_established = loop.create_future() call_disconnected = loop.create_future() class Dialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.invite async def invite(self, request, message): dialog = await request.prepare(status_code=100) await asyncio.sleep(0.1) await dialog.reply(message, status_code=180) await asyncio.sleep(0.1) await dialog.reply(message, status_code=200) call_established.set_result(None) async for message in dialog: await dialog.reply(message, 200) if message.method == 'BYE': call_disconnected.set_result(None) break app = aiosip.Application(loop=loop, debug=True) server_app = aiosip.Application(loop=loop, debug=True, dialplan=Dialplan()) server = await test_server(server_app) peer = await app.connect( protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port']) ) call = await peer.invite( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) responses = list() async for msg in call.wait_for_terminate(): responses.append(msg.status_code) if msg.status_code == 200: await asyncio.sleep(0.1) await call.close() await call_established await call_disconnected assert responses == [100, 180, 200] if close_order[0] == 'client': await app.close() await server_app.close() else: await server_app.close() await app.close()
async def test_notify(test_server, protocol, loop, from_details, to_details, close_order): notify_list = [0, 1, 2, 3, 4] subscribe_future = loop.create_future() class Dialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.subscribe async def subscribe(self, request, msg): expires = int(msg.headers['Expires']) dialog = await request.prepare(status_code=200, headers={'Expires': expires}) await asyncio.sleep(0.1) for i in notify_list: await dialog.notify(payload=str(i)) subscribe_future.set_result(None) async for msg in dialog: if msg.method == 'SUBSCRIBE': expires = int(msg.headers['Expires']) await dialog.reply(msg, status_code=200, headers={'Expires': expires}) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop, dialplan=Dialplan()) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port'])) subscribe_dialog = await peer.subscribe( expires=1800, from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) for expected in notify_list: request = await asyncio.wait_for(subscribe_dialog.recv(), timeout=1) await subscribe_dialog.reply(request, status_code=200) assert int(request.payload) == expected await subscribe_future if close_order[0] == 'client': await app.close() await server_app.close() else: await server_app.close() await app.close()
async def test_notify_with_router(test_server, protocol, loop, from_details, to_details): notify_list = [0, 1, 2, 3, 4] received_notify_futures = [loop.create_future() for _ in notify_list] subscribe_future = loop.create_future() async def subscribe(dialog, request): assert len(dialog.peer.subscriber) == 1 await dialog.reply(request, status_code=200) await asyncio.sleep(0.1) for i in notify_list: await dialog.notify(payload=str(i)) subscribe_future.set_result(None) async def notify(dialog, request): await dialog.reply(request, status_code=200) received_notify_futures[int(request.payload)].set_result(request) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server_app.dialplan.add_user('pytest', {'SUBSCRIBE': subscribe}) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port'])) client_router = aiosip.Router() client_router['notify'] = notify subscribe_dialog = peer.create_dialog( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), router=client_router) response = await subscribe_dialog.subscribe(expires=1800) done, pending = await asyncio.wait(received_notify_futures, return_when=asyncio.ALL_COMPLETED, timeout=1) received_notify = [f.result() for f in done] assert len(pending) == 0 await subscribe_future assert response.status_code == 200 assert response.status_message == 'OK' assert all((r.method == 'NOTIFY' for r in received_notify)) await server_app.close() await app.close()
async def test_proxy_subscribe(test_server, test_proxy, protocol, loop, from_details, to_details): callback_complete = loop.create_future() callback_complete_proxy = loop.create_future() async def subscribe(dialog, request): await dialog.reply(request, status_code=200) callback_complete.set_result(request) async def proxy_subscribe(dialog, request): await dialog.router.proxy(dialog, request, timeout=0.1) callback_complete_proxy.set_result(request) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server_app.dialplan.add_user('pytest', {'SUBSCRIBE': subscribe}) await test_server(server_app) proxy_router = aiosip.ProxyRouter() proxy_router['subscribe'] = proxy_subscribe proxy_app = aiosip.Application(loop=loop) proxy_app.dialplan.add_user('pytest', proxy_router) proxy = await test_proxy(proxy_app) peer = await app.connect(protocol=protocol, remote_addr=(proxy.sip_config['server_host'], proxy.sip_config['server_port'])) subscribe_dialog = peer.create_dialog( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) response = await subscribe_dialog.subscribe(expires=1800) received_request_server = await asyncio.wait_for(callback_complete, timeout=2) received_request_proxy = await asyncio.wait_for(callback_complete_proxy, timeout=2) assert response.status_code == 200 assert response.status_message == 'OK' assert received_request_server.method == 'SUBSCRIBE' assert received_request_server.payload == received_request_proxy.payload assert received_request_server.headers == received_request_proxy.headers await server_app.close() await proxy_app.close() await app.close()
async def test_authentication_rejection(test_server, protocol, loop, from_details, to_details, close_order): received_messages = list() class Dialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.subscribe async def subscribe(self, request, message): dialog = request._create_dialog() received_messages.append(message) await dialog.unauthorized(message) async for message in dialog: received_messages.append(message) await dialog.reply(message, 401) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop, dialplan=Dialplan()) server = await test_server(server_app) peer = await app.connect( protocol=protocol, remote_addr=( server.sip_config['server_host'], server.sip_config['server_port'], ) ) result = await peer.register( expires=1800, from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), password='******', ) # wait long enough to ensure no improper retransmit await asyncio.sleep(1) assert len(received_messages) == 2 assert result.status_code == 401 if close_order[0] == 'client': await app.close() await server_app.close() else: await server_app.close() await app.close()
async def test_authentication(test_server, protocol, loop, from_details, to_details, close_order): password = '******' received_messages = list() class Dialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.subscribe async def subscribe(self, request, message): dialog = request._create_dialog() received_messages.append(message) assert not dialog.validate_auth(message, password) await dialog.unauthorized(message) async for message in dialog: received_messages.append(message) if dialog.validate_auth(message, password): await dialog.reply(message, 200) else: await dialog.unauthorized(message) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop, dialplan=Dialplan()) server = await test_server(server_app) peer = await app.connect( protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port']) ) await peer.subscribe( expires=1800, from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), password=password ) assert len(received_messages) == 2 assert 'Authorization' in received_messages[1].headers if close_order[0] == 'client': await app.close() await server_app.close() else: await server_app.close() await app.close()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-p', '--protocol', default='udp') parser.add_argument('user') args = parser.parse_args() sip_config['user'] = args.user loop = asyncio.get_event_loop() app = aiosip.Application(loop=loop, dialplan=Dialplan()) if args.protocol == 'udp': server = start(app, aiosip.UDP) elif args.protocol == 'tcp': server = start(app, aiosip.TCP) elif args.protocol == 'ws': server = start(app, aiosip.WS) else: raise RuntimeError("Unsupported protocol: {}".format(args.protocol)) # TODO: refactor registration = loop.run_until_complete(server) loop.run_until_complete(registration.__aenter__()) try: loop.run_forever() except KeyboardInterrupt: loop.run_until_complete(registration.__aexit__(None, None, None)) print('Closing') loop.run_until_complete(app.close()) loop.close()
async def test_authentication_rejection(test_server, protocol, loop, from_details, to_details, close_order): received_messages = list() class Dialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.subscribe async def subscribe(self, request, message): dialog = request._create_dialog() received_messages.append(message) await dialog.unauthorized(message) async for message in dialog: received_messages.append(message) await dialog.unauthorized(message) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop, dialplan=Dialplan()) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=( server.sip_config['server_host'], server.sip_config['server_port'], )) with pytest.raises(aiosip.exceptions.AuthentificationFailed): await peer.register( expires=1800, from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), password='******', ) assert len(received_messages) == 3 assert all( list('Authorization' in message.headers for message in received_messages[1:])) if close_order[0] == 'client': await app.close() await server_app.close() else: await server_app.close() await app.close()
async def test_cancel(test_server, protocol, loop, from_details, to_details, close_order): cancel_future = loop.create_future() class Dialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) if kwargs['method'] == 'SUBSCRIBE': return self.subscribe elif kwargs['method'] == 'CANCEL': return self.cancel async def subscribe(self, request, message): pending_subscription.cancel() async def cancel(self, request, message): cancel_future.set_result(message) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop, dialplan=Dialplan()) server = await test_server(server_app) peer = await app.connect( protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port']) ) pending_subscription = asyncio.ensure_future(peer.subscribe( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), )) with pytest.raises(asyncio.CancelledError): await pending_subscription result = await cancel_future assert result.method == 'CANCEL' if close_order[0] == 'client': await app.close() await server_app.close() else: await server_app.close() await app.close()
async def test_response_404(test_server, protocol, loop, from_details, to_details): app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port'])) subscribe_dialog = peer.create_dialog( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) response = await subscribe_dialog.subscribe() assert response.status_code == 404 assert response.status_message == 'Not Found' await server_app.close() await app.close()
async def test_invite(test_server, protocol, loop, from_details, to_details): ack_future = loop.create_future() async def invite(dialog, request): await dialog.reply(request, 100) await asyncio.sleep(0.1) await dialog.reply(request, 180) await asyncio.sleep(0.1) ack = await dialog.reply(request, 200, wait_for_ack=True) ack_future.set_result(ack) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server_app.dialplan.add_user('pytest', {'INVITE': invite}) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port'])) invite_dialog = peer.create_dialog( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) responses = list() async for msg in invite_dialog.invite(): if msg.status_code == 200: invite_dialog.ack(msg) responses.append(msg) ack = await ack_future assert len(responses) == 3 assert responses[0].status_code == 100 assert responses[1].status_code == 180 assert responses[2].status_code == 200 assert ack.method == 'ACK' await app.close() await server_app.close()
async def test_notify(test_server, protocol, loop, from_details, to_details): notify_list = [0, 1, 2, 3, 4] subscribe_future = loop.create_future() async def subscribe(dialog, request): assert len(dialog.peer.subscriber) == 1 await dialog.reply(request, status_code=200) await asyncio.sleep(0.1) for i in notify_list: await dialog.notify(payload=str(i)) subscribe_future.set_result(None) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server_app.dialplan.add_user('pytest', {'SUBSCRIBE': subscribe}) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port'])) subscribe_dialog = peer.create_dialog( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) response = await subscribe_dialog.subscribe(expires=1800) for expected in notify_list: request = await asyncio.wait_for(subscribe_dialog.recv(), timeout=1) await subscribe_dialog.reply(request, status_code=200) assert int(request.payload) == expected await subscribe_future assert response.status_code == 200 assert response.status_message == 'OK' await server_app.close() await app.close()
async def test_subscribe(test_server, protocol, loop, from_details, to_details, close_order): callback_complete = loop.create_future() class Dialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.on_subscribe async def on_subscribe(self, request, message): await request.prepare(status_code=200) callback_complete.set_result(message) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop, dialplan=Dialplan()) server = await test_server(server_app) peer = await app.connect( protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port']) ) await peer.subscribe( expires=1800, from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) received_request = await callback_complete assert received_request.method == 'SUBSCRIBE' if close_order[0] == 'client': await app.close() await server_app.close() else: await server_app.close() await app.close()
def main(): loop = asyncio.get_event_loop() app = aiosip.Application(loop=loop) app.dialplan.add_user('asterisk', option) if len(sys.argv) > 1 and sys.argv[1] == 'tcp': loop.run_until_complete(start(app, aiosip.TCP)) elif len(sys.argv) > 1 and sys.argv[1] == 'ws': loop.run_until_complete(start(app, aiosip.WS)) else: loop.run_until_complete(start(app, aiosip.UDP)) loop.close()
def main(): loop = asyncio.get_event_loop() app = aiosip.Application(loop=loop) app.dialplan.add_user('subscriber', {'REGISTER': on_register, 'SUBSCRIBE': session(on_subscribe)}) if len(sys.argv) > 1 and sys.argv[1] == 'tcp': start(app, aiosip.TCP) elif len(sys.argv) > 1 and sys.argv[1] == 'ws': start(app, aiosip.WS) else: start(app, aiosip.UDP) loop.close()
async def test_response_501(test_server, protocol, loop, from_details, to_details, close_order): app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port'])) subscription = await peer.subscribe( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) assert subscription.status_code == 501 assert subscription.status_message == 'Not Implemented' if close_order[0] == 'client': await app.close() await server_app.close() else: await server_app.close() await app.close()
async def on_invite(request, message): dialog = await request.prepare(status_code=100) to_uri = message.to_details['uri'] to_user = to_uri['user'] to_host, to_port = await get_address(to_user) if not to_host: not_found_message = "User {} is not registered.".format(to_user) print(not_found_message) await dialog.reply(message, status_code=404) async for message in dialog: print('Client message method:', message.method) await dialog.reply(message, status_code=200) if message.method == 'BYE' or message.method == 'CANCEL': break print('Exited dialog loop.') return sip = aiosip.Application(loop=loop) local_port = random.randint(6001, 6999) peer = await sip.connect((to_host, to_port), protocol=aiosip.TCP, local_addr=(local_host, local_port)) call = await peer.invite(from_details=message.from_details, to_details=message.to_details, contact_details=message.contact_details, password=pwd) async with call: async def reader(): async for msg in call.wait_for_terminate(): print("CALL STATUS:", msg.status_code) await dialog.reply(message, status_code=msg.status_code) with contextlib.suppress(asyncio.TimeoutError): await asyncio.wait_for(reader(), timeout=10) async for message in dialog: await dialog.reply(message, 200) if message.method == 'BYE': break await sip.close()
async def test_authentification(test_server, protocol, loop, from_details, to_details): password = '******' received_request = list() async def subscribe(dialog, request): if dialog.validate_auth(request, password): received_request.append(request) await dialog.reply(request, 200) else: received_request.append(request) await dialog.unauthorized(request) app = aiosip.Application(loop=loop) server_app = aiosip.Application(loop=loop) server_app.dialplan.add_user('pytest', {'SUBSCRIBE': subscribe}) server = await test_server(server_app) peer = await app.connect(protocol=protocol, remote_addr=(server.sip_config['server_host'], server.sip_config['server_port'])) subscribe_dialog = peer.create_dialog( from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), password=password) response = await subscribe_dialog.subscribe(expires=1800) assert len(received_request) == 2 assert 'Authorization' in received_request[1].headers assert response.status_code == 200 assert response.status_message == 'OK' await server_app.close() await app.close()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-p', '--protocol', default='udp') args = parser.parse_args() loop = asyncio.get_event_loop() app = aiosip.Application(loop=loop, dialplan=Dialplan()) if args.protocol == 'udp': start(app, aiosip.UDP) elif args.protocol == 'tcp': start(app, aiosip.TCP) elif args.protocol == 'ws': start(app, aiosip.WS) else: raise RuntimeError("Unsupported protocol: {}".format(args.protocol)) loop.close()
async def on_register(request, message): dialog = await request.prepare(status_code=100) sip = aiosip.Application(loop=loop) local_port = random.randint(7001, 7999) peer = await sip.connect((registrar_host, registrar_port), protocol=aiosip.TCP, local_addr=(local_host, local_port)) rdialog = await peer.register(from_details=message.from_details, to_details=message.to_details, contact_details=message.contact_details, password=pwd) print("Registrar response:", rdialog.status_code) await dialog.reply(message, status_code=rdialog.status_code) await sip.close()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-p', '--protocol', default='udp') parser.add_argument('filename', default='udp') args = parser.parse_args() loop = asyncio.get_event_loop() app = aiosip.Application(loop=loop) if args.protocol == 'udp': loop.run_until_complete(start(app, aiosip.UDP, args.filename)) elif args.protocol == 'tcp': loop.run_until_complete(start(app, aiosip.TCP, args.filename)) elif args.protocol == 'ws': loop.run_until_complete(start(app, aiosip.WS, args.filename)) else: raise RuntimeError("Unsupported protocol: {}".format(args.protocol)) loop.close()
def main(loop): app = aiosip.Application(loop=loop) dialog = yield from app.start_dialog( from_uri='sip:{user}@{realm}:{srv_port}'.format(**sip_config), to_uri='sip:{user}@{realm}:{srv_port}'.format(**sip_config), local_addr=(sip_config['local_ip'], sip_config['local_port']), remote_addr=(sip_config['srv_host'], sip_config['srv_port']), password=sip_config['pwd'], ) fut = dialog.register() try: result = yield from asyncio.wait_for(fut, 5, loop=loop) print('register ok') except asyncio.TimeoutError: print('Timeout doing REGISTER !') dialog.register_callback('NOTIFY', show_notify) watched_user = '******' headers = multidict.CIMultiDict() headers['Expires'] = '1800' headers['Event'] = 'dialog' headers['Accept'] = 'application/dialog-info+xml' send_future = dialog.send_message( method='SUBSCRIBE', to_uri='sip:{0}@{realm}:{srv_port}'.format(watched_user, **sip_config), headers=headers, payload='') try: result = yield from asyncio.wait_for(send_future, 5, loop=loop) print('%s: %s' % (result.status_code, result.status_message)) except asyncio.TimeoutError: print('Message not received !') yield from asyncio.sleep(240) # wait NOTIFY messages dialog.close()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-p', '--protocol', default='udp') parser.add_argument('-u', '--user', default='client') parser.add_argument('-d', '--duration', type=int, default=5) parser.add_argument('target') args = parser.parse_args() sip_config['user'] = args.user loop = asyncio.get_event_loop() app = aiosip.Application(loop=loop) if args.protocol == 'udp': client = start(app, aiosip.UDP, args.target, args.duration) elif args.protocol == 'tcp': client = start(app, aiosip.TCP, args.target, args.duration) elif args.protocol == 'ws': client = start(app, aiosip.WS, args.target, args.duration) else: raise RuntimeError("Unsupported protocol: {}".format(args.protocol)) loop.run_until_complete(client) loop.close()
async def test_proxy_subscribe(test_server, test_proxy, protocol, loop, from_details, to_details, close_order): callback_complete = loop.create_future() callback_complete_proxy = loop.create_future() class ServerDialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.subscribe async def subscribe(self, request, message): await request.prepare(status_code=200) callback_complete.set_result(message) class ProxyDialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.proxy_subscribe async def proxy_subscribe(self, request, message): dialog = request._create_dialog() peer = await aiosip.utils.get_proxy_peer(dialog, message) async for proxy_response in peer.proxy_request( dialog, message, 0.1): if proxy_response: dialog.peer.proxy_response(proxy_response) callback_complete_proxy.set_result(message) app = aiosip.Application(loop=loop, debug=True) server_app = aiosip.Application(loop=loop, debug=True, dialplan=ServerDialplan()) await test_server(server_app) proxy_app = aiosip.Application(loop=loop, dialplan=ProxyDialplan()) proxy = await test_proxy(proxy_app) peer = await app.connect(protocol=protocol, remote_addr=(proxy.sip_config['server_host'], proxy.sip_config['server_port'])) await peer.subscribe( expires=1800, from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details), ) received_request_server = await asyncio.wait_for(callback_complete, timeout=2) received_request_proxy = await asyncio.wait_for(callback_complete_proxy, timeout=2) assert received_request_server.method == 'SUBSCRIBE' assert received_request_server.payload == received_request_proxy.payload assert received_request_server.headers == received_request_proxy.headers for item in close_order: if item == 'client': await app.close() elif item == 'server': await server_app.close() elif item == 'proxy': await proxy_app.close() else: raise ValueError('Invalid close_order')
async def test_proxy_notify(test_server, test_proxy, protocol, loop, from_details, to_details, close_order): callback_complete = loop.create_future() callback_complete_proxy = loop.create_future() class ServerDialpan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.subscribe async def subscribe(self, request, message): dialog = await request.prepare(status_code=200) await asyncio.sleep(0.2) await dialog.notify(payload='1') class ProxyDialplan(aiosip.BaseDialplan): async def resolve(self, *args, **kwargs): await super().resolve(*args, **kwargs) return self.proxy_subscribe async def proxy_subscribe(self, request, message): dialog = request._create_dialog() peer = await aiosip.utils.get_proxy_peer(dialog, message) async for proxy_response in peer.proxy_request( dialog, message, 0.1): if proxy_response: dialog.peer.proxy_response(proxy_response) # TODO: refactor subscription = request.app._dialogs[frozenset( (message.to_details.details, message.from_details.details, message.headers['Call-ID']))] async for msg in subscription: async for proxy_response in dialog.peer.proxy_request( subscription, msg): if proxy_response: peer.proxy_response(proxy_response) callback_complete_proxy.set_result(msg) app = aiosip.Application(loop=loop, debug=True) server_app = aiosip.Application(loop=loop, debug=True, dialplan=ServerDialpan()) await test_server(server_app) proxy_app = aiosip.Application(loop=loop, debug=True, dialplan=ProxyDialplan()) proxy = await test_proxy(proxy_app) peer = await app.connect(protocol=protocol, remote_addr=(proxy.sip_config['server_host'], proxy.sip_config['server_port'])) subscription = await peer.subscribe( expires=1800, from_details=aiosip.Contact.from_header(from_details), to_details=aiosip.Contact.from_header(to_details)) async for msg in subscription: await subscription.reply(msg, 200) callback_complete.set_result(msg) break # We only expect a single message received_notify_server = await asyncio.wait_for(callback_complete, timeout=2) received_notify_proxy = await asyncio.wait_for(callback_complete_proxy, timeout=2) assert received_notify_server.method == 'NOTIFY' assert received_notify_server.payload == '1' assert received_notify_server.payload == received_notify_proxy.payload assert received_notify_server.headers == received_notify_proxy.headers for item in close_order: if item == 'client': await app.close() elif item == 'server': await server_app.close() elif item == 'proxy': await proxy_app.close() else: raise ValueError('Invalid close_order')