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')
