def test_untrusted_curve_with_allowed_password_and_client_disconnect(self):
from pseud import Client, Server
from pseud._tornado import async_sleep
client_id = b'john'
server_id = b'server'
endpoint = b'tcp://127.0.0.1:8999'
server_public, server_secret = zmq.curve_keypair()
client_public, client_secret = zmq.curve_keypair()
security_plugin = 'untrusted_curve'
password = b's3cret!'
client = Client(server_id,
security_plugin=security_plugin,
public_key=client_public,
secret_key=client_secret,
peer_public_key=server_public,
user_id=client_id,
password=password,
timeout=1,
io_loop=self.io_loop)
server = Server(server_id,
security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
io_loop=self.io_loop)
server.bind(endpoint)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
# configure manually authentication backend
server.auth_backend.user_map[client_id] = password
yield server.start()
yield client.start()
server.register_rpc(name='string.lower')(str.lower)
result = yield client.string.lower('FOO')
assert result == 'foo'
# Simulate disconnection and reconnection with new identity
client.disconnect(endpoint)
client.connect(endpoint)
yield async_sleep(self.io_loop, .15)
result = yield client.string.lower('ABC')
assert result == 'abc'
server.stop()
client.stop()
def test_untrusted_curve_with_allowed_password_and_client_disconnect(self):
from pseud import Client, Server
client_id = b'john'
server_id = b'server'
endpoint = b'tcp://127.0.0.1:8999'
server_public, server_secret = zmq.curve_keypair()
client_public, client_secret = zmq.curve_keypair()
security_plugin = 'untrusted_curve'
password = b's3cret!'
client = Client(server_id,
security_plugin=security_plugin,
public_key=client_public,
secret_key=client_secret,
peer_public_key=server_public,
user_id=client_id,
password=password,
timeout=1,
io_loop=self.io_loop)
server = Server(server_id,
security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
io_loop=self.io_loop)
server.bind(endpoint)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
# configure manually authentication backend
server.auth_backend.user_map[client_id] = password
yield server.start()
yield client.start()
server.register_rpc(name='string.lower')(str.lower)
result = yield client.string.lower('FOO')
assert result == 'foo'
# Simulate disconnection and reconnection with new identity
client.disconnect(endpoint)
client.connect(endpoint)
result = yield client.string.lower('ABC')
assert result == 'abc'
server.stop()
client.stop()
async def test_untrusted_curve_with_allowed_password_and_client_disconnect(
loop, unused_tcp_port):
from pseud import Client, Server
client_id = b'john'
server_id = b'server'
endpoint = f'tcp://127.0.0.1:{unused_tcp_port}'
server_public, server_secret = zmq.curve_keypair()
client_public, client_secret = zmq.curve_keypair()
security_plugin = 'untrusted_curve'
password = b's3cret!'
client = Client(server_id,
security_plugin=security_plugin,
public_key=client_public,
secret_key=client_secret,
peer_public_key=server_public,
user_id=client_id,
password=password,
timeout=1,
loop=loop)
server = Server(server_id,
security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
loop=loop)
server.bind(endpoint)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
# configure manually authentication backend
server.auth_backend.user_map[client_id] = password
server.register_rpc(name='string.lower')(str.lower)
async with server, client:
result = await client.string.lower('FOO')
assert result == 'foo'
# Simulate disconnection and reconnection with new identity
client.disconnect(endpoint)
client.connect(endpoint)
await asyncio.sleep(.1)
result = await client.string.lower('ABC')
assert result == 'abc'
async def test_untrusted_curve_with_allowed_password_and_client_disconnect(
loop, unused_tcp_port):
from pseud import Client, Server
client_id = b'john'
server_id = b'server'
endpoint = f'tcp://127.0.0.1:{unused_tcp_port}'
server_public, server_secret = zmq.curve_keypair()
client_public, client_secret = zmq.curve_keypair()
security_plugin = 'untrusted_curve'
password = b's3cret!'
client = Client(server_id,
security_plugin=security_plugin,
public_key=client_public,
secret_key=client_secret,
peer_public_key=server_public,
user_id=client_id,
password=password,
timeout=1,
loop=loop)
server = Server(server_id,
security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
loop=loop)
server.bind(endpoint)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
# configure manually authentication backend
server.auth_backend.user_map[client_id] = password
server.register_rpc(name='string.lower')(str.lower)
async with server, client:
result = await client.string.lower('FOO')
assert result == 'foo'
# Simulate disconnection and reconnection with new identity
client.disconnect(endpoint)
client.connect(endpoint)
await asyncio.sleep(.1)
result = await client.string.lower('ABC')
assert result == 'abc'
def test_client_can_reconnect(self):
from pseud import Client, Server
from pseud._tornado import async_sleep
server_id = b'server'
endpoint = b'tcp://127.0.0.1:8989'
server_public, server_secret = zmq.curve_keypair()
security_plugin = 'trusted_curve'
server = Server(server_id, security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
io_loop=self.io_loop)
server.bind(endpoint)
bob_public, bob_secret = server.auth_backend.known_identities[b'bob']
client = Client(server_id,
user_id=b'bob',
security_plugin=security_plugin,
public_key=bob_public,
secret_key=bob_secret,
peer_public_key=server_public,
io_loop=self.io_loop)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
yield server.start()
yield client.start()
server.register_rpc(name='string.upper')(str.upper)
result = yield client.string.upper('hello')
assert result == 'HELLO'
client.disconnect(endpoint)
client.connect(endpoint)
yield async_sleep(self.io_loop, .1)
result = yield client.string.upper('hello2')
assert result == 'HELLO2'
client.stop()
server.stop()
def test_client_can_reconnect(self):
from pseud import Client, Server
server_id = b'server'
endpoint = b'tcp://127.0.0.1:8989'
server_public, server_secret = zmq.curve_keypair()
security_plugin = 'trusted_curve'
server = Server(server_id,
security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
io_loop=self.io_loop)
server.bind(endpoint)
bob_public, bob_secret = server.auth_backend.known_identities[b'bob']
client = Client(server_id,
user_id=b'bob',
security_plugin=security_plugin,
public_key=bob_public,
secret_key=bob_secret,
peer_public_key=server_public,
io_loop=self.io_loop)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
yield server.start()
yield client.start()
server.register_rpc(name='string.upper')(str.upper)
result = yield client.string.upper('hello')
assert result == 'HELLO'
client.disconnect(endpoint)
client.connect(endpoint)
result = yield client.string.upper('hello2')
assert result == 'HELLO2'
client.stop()
server.stop()
async def test_client_can_reconnect(loop, unused_tcp_port_factory):
from pseud import Client, Server
port = unused_tcp_port_factory()
server_id = b'server'
endpoint = f'tcp://127.0.0.1:{port}'
server_public, server_secret = zmq.curve_keypair()
security_plugin = 'trusted_curve'
server = Server(server_id, security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
loop=loop)
server.bind(endpoint)
bob_public, bob_secret = server.auth_backend.known_identities[b'bob']
client = Client(server_id,
user_id=b'bob',
security_plugin=security_plugin,
public_key=bob_public,
secret_key=bob_secret,
peer_public_key=server_public,
loop=loop)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
server.register_rpc(name='string.upper')(str.upper)
async with server, client:
result = await client.string.upper('hello')
assert result == 'HELLO'
client.disconnect(endpoint)
client.connect(endpoint)
await asyncio.sleep(.01)
result = await client.string.upper('hello2')
assert result == 'HELLO2'
async def test_client_can_reconnect(loop, unused_tcp_port_factory):
from pseud import Client, Server
port = unused_tcp_port_factory()
server_id = b'server'
endpoint = f'tcp://127.0.0.1:{port}'
server_public, server_secret = zmq.curve_keypair()
security_plugin = 'trusted_curve'
server = Server(server_id, security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
loop=loop)
server.bind(endpoint)
bob_public, bob_secret = server.auth_backend.known_identities[b'bob']
client = Client(server_id,
user_id=b'bob',
security_plugin=security_plugin,
public_key=bob_public,
secret_key=bob_secret,
peer_public_key=server_public,
loop=loop)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
server.register_rpc(name='string.upper')(str.upper)
async with server, client:
result = await client.string.upper('hello')
assert result == 'HELLO'
client.disconnect(endpoint)
client.connect(endpoint)
await asyncio.sleep(.01)
result = await client.string.upper('hello2')
assert result == 'HELLO2'
