async def test_trusted_curve(loop, unused_tcp_port, trusted_curve_auth_backend): from pseud import Client, Server from pseud.utils import register_rpc server_id = b'server' endpoint = f'tcp://127.0.0.1:{unused_tcp_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 register_rpc(name='string.lower')(str.lower) async with server, client: result = await client.string.lower('FOO') assert result == 'foo'
async def test_trusted_curve_with_wrong_peer_public_key( loop, unused_tcp_port_factory): from pseud import Client, Server from pseud.utils import register_rpc server_id = b'server' port = unused_tcp_port_factory() endpoint = f'tcp://127.0.0.1:{port}' server_public, server_secret = zmq.curve_keypair() server = Server(server_id, security_plugin='trusted_curve', public_key=server_public, secret_key=server_secret, loop=loop) server.bind(endpoint) alice_public, alice_secret = \ server.auth_backend.known_identities[b'alice'] client = Client(server_id, user_id=b'alice', security_plugin='trusted_curve', public_key=alice_public, secret_key=alice_secret, peer_public_key=z85.encode(b'R' * 32), timeout=.5, loop=loop) client.connect(endpoint) assert server.socket.mechanism == zmq.CURVE assert client.socket.mechanism == zmq.CURVE register_rpc(name='string.lower')(str.lower) async with server, client: with pytest.raises(asyncio.TimeoutError): await client.string.lower('BAR')
async def test_trusted_curve(loop, unused_tcp_port): from pseud import Client, Server from pseud.utils import register_rpc server_id = b'server' endpoint = f'tcp://127.0.0.1:{unused_tcp_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 register_rpc(name='string.lower')(str.lower) async with server, client: result = await client.string.lower('FOO') assert result == 'foo'
def test_server_can_send(): from pseud.utils import register_rpc client_id = 'client' server_id = 'server' endpoint = 'tcp://127.0.0.1:5000' # PLAIN server = make_one_server(server_id, security_plugin='plain') client = make_one_client(server_id, user_id=client_id, password=client_id, security_plugin='plain') server.bind(endpoint) server.start() client.connect(endpoint) client.start() import string register_rpc(name='string.lower')(string.lower) result = client.string.lower('TATA').get() assert result == 'tata' future = server.send_to(client_id).string.lower('SCREAM') assert future.get() == 'scream' client.stop() server.stop()
def test_client_can_reconnect(): from pseud.utils import register_rpc server_id = 'server' endpoint = 'tcp://127.0.0.1:8989' server = make_one_server(server_id) client = make_one_client(server_id) server.bind(endpoint) server.start() client.connect(endpoint) import string register_rpc(name='string.upper')(string.upper) future = client.string.upper('hello') assert future.get() == 'HELLO' client.disconnect(endpoint) client.connect(endpoint) gevent.sleep(.1) future = client.string.upper('hello') assert future.get() == 'HELLO' client.stop() server.stop()
def test_server_can_proxy_another_server(self): """ Client1 --> Server1.string.lower() Client2 --> Server2(Server1.string.lower()) """ from pseud.interfaces import ServiceNotFoundError from pseud.utils import get_rpc_callable, register_rpc server1 = self.make_one_server(b'server1') server2 = self.make_one_server(b'server2', proxy_to=server1) client1 = self.make_one_client(b'server1') client2 = self.make_one_client(b'server2') server1.bind(b'inproc://server1') server2.bind(b'inproc://server2') client1.connect(b'inproc://server1') client2.connect(b'inproc://server2') yield server1.start() yield server2.start() # Local registration server1.register_rpc(name='str.lower')(str.lower) # Global registration register_rpc(name='str.upper')(str.upper) # local registration only to proxy server2.register_rpc(name='bla.lower')(str.lower) with pytest.raises(ServiceNotFoundError): get_rpc_callable('str.lower', registry=server2.registry) with pytest.raises(ServiceNotFoundError): get_rpc_callable('bla.lower', registry=server1.registry) with pytest.raises(ServiceNotFoundError): get_rpc_callable('bla.lower') with pytest.raises(ServiceNotFoundError): assert get_rpc_callable('str.lower') assert get_rpc_callable('str.lower', registry=server1.registry)('L') == 'l' result1 = yield client1.str.lower('SCREAM') result2 = yield client2.str.lower('SCREAM') result3 = yield client1.str.upper('whisper') result4 = yield client2.str.upper('whisper') result5 = yield client2.bla.lower('SCREAM') assert result1 == 'scream' assert result2 == 'scream' assert result3 == 'WHISPER' assert result4 == 'WHISPER' assert result5 == 'scream' client1.stop() client2.stop() server1.stop() server2.stop()
async def test_server_can_send_to_several_client(loop, unused_tcp_port): from pseud.utils import register_rpc server_id = b'server' endpoint = f'tcp://127.0.0.1:{unused_tcp_port}' server = make_one_server(server_id, loop, security_plugin='plain') client1 = make_one_client(server_id, loop, user_id=b'alice', password=b'alice', security_plugin='plain') client2 = make_one_client(server_id, loop, user_id=b'bob', password=b'bob', security_plugin='plain') server.bind(endpoint) client1.connect(endpoint) client2.connect(endpoint) register_rpc(name='string.lower')(str.lower) async with server, client1, client2: await asyncio.sleep(.1) result1 = await server.send_to(b'alice').string.lower('SCREAM1') result2 = await server.send_to(b'bob').string.lower('SCREAM2') assert result1 == 'scream1' assert result2 == 'scream2'
def test_server_can_send(self): from pseud.utils import register_rpc server_id = b'server' endpoint = b'tcp://127.0.0.1:5000' server = self.make_one_server(server_id, security_plugin='plain') client = self.make_one_client(server_id, user_id=b'alice', password=b'alice', security_plugin='plain') server.bind(endpoint) client.connect(endpoint) yield server.start() yield client.start() register_rpc(name='string.lower')(str.lower) yield client.string.lower('TATA') result = yield server.send_to(b'alice').string.lower('SCREAM') assert result == 'scream' client.stop() server.stop()
def test_client_can_reconnect(self): from pseud.utils import register_rpc client_id = b'client' server_id = b'server' endpoint = b'tcp://127.0.0.1:8989' server = self.make_one_server(server_id) client = self.make_one_client(server_id) server.bind(endpoint) server.start() client.connect(endpoint) 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('hello') assert result == 'HELLO' client.stop() server.stop()
def test_rpc_simple_registration(): from pseud.interfaces import ServiceNotFoundError from pseud.utils import (get_rpc_callable, register_rpc, RPCCallable, ) @register_rpc def callme(*args, **kw): return args, kw assert isinstance(get_rpc_callable('callme'), RPCCallable) assert get_rpc_callable('callme')() == ((), {}) assert get_rpc_callable('callme')('a', foo='goo') == (('a',), {'foo': 'goo'}) @register_rpc(name='totally.something.else') def callme2(*args, **kw): return args, kw with pytest.raises(ServiceNotFoundError): get_rpc_callable('callme2') assert isinstance(get_rpc_callable('totally.something.else'), RPCCallable) def call_me_again(): return True register_rpc(functools.partial(call_me_again), name='call_me_again') assert get_rpc_callable('call_me_again')() is True
def test_trusted_curve(): from pseud._gevent import Client, Server from pseud.utils import register_rpc server_id = 'server' endpoint = 'tcp://127.0.0.1:8998' 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) server.bind(endpoint) bob_public, bob_secret = server.auth_backend.known_identities[b'bob'] client = Client(server_id, security_plugin=security_plugin, public_key=bob_public, secret_key=bob_secret, peer_public_key=server_public) client.connect(endpoint) assert server.socket.mechanism == zmq.CURVE assert client.socket.mechanism == zmq.CURVE server.start() client.start() import string register_rpc(name='string.lower')(string.lower) future = client.string.lower('FOO') assert future.get() == 'foo' server.stop() client.stop()
def test_untrusted_curve_with_allowed_password(self): from pseud import Client, Server from pseud.utils import register_rpc 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, 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() register_rpc(name='string.lower')(str.lower) future = client.string.lower('FOO') future2 = client.string.lower('FOO_JJ') yield async_sleep(self.io_loop, .01) future3 = server.send_to(client_id).string.lower('ABC') result = yield future result2 = yield future2 result3 = yield future3 assert result == 'foo' assert result2 == 'foo_jj' assert result3 == 'abc' server.stop() client.stop()
def test_untrusted_curve_with_allowed_password(self): from pseud import Client, Server from pseud.utils import register_rpc 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, 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() register_rpc(name='string.lower')(str.lower) result = yield client.string.lower('FOO') result2 = yield client.string.lower('FOO_JJ') result3 = yield server.send_to(client_id).string.lower('ABC') assert result == 'foo' assert result2 == 'foo_jj' assert result3 == 'abc' server.stop() client.stop()
async def test_client_can_send(loop): from pseud.utils import register_rpc server_id = b'server' endpoint = b'inproc://here' server = make_one_server(server_id, loop) client = make_one_client(server_id, loop) server.bind(endpoint) client.connect(endpoint) register_rpc(name='string.upper')(str.upper) async with server, client: result = await client.string.upper('hello') assert result == 'HELLO'
def test_untrusted_curve_with_wrong_password(self): from pseud import Client, Server from pseud.interfaces import UnauthorizedError from pseud.utils import register_rpc client_id = b'john' server_id = b'server' endpoint = b'tcp://127.0.0.1:8998' 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, user_id=client_id, security_plugin=security_plugin, public_key=client_public, secret_key=client_secret, peer_public_key=server_public, password=password, 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 + b'Looser' yield server.start() yield client.start() register_rpc(name='string.lower')(str.lower) future = client.string.lower(b'IMSCREAMING') with pytest.raises(UnauthorizedError): yield future server.stop() client.stop()
def test_untrusted_curve_with_allowed_password_and_client_disconnect(): from pseud._gevent import Client, Server from pseud.utils import register_rpc client_id = 'john' server_id = 'server' endpoint = 'tcp://127.0.0.1:8998' server_public, server_secret = zmq.curve_keypair() client_public, client_secret = zmq.curve_keypair() security_plugin = 'untrusted_curve' password = '******' 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) server = Server(server_id, security_plugin=security_plugin, public_key=server_public, secret_key=server_secret) 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.start() import string register_rpc(name='string.lower')(string.lower) future = client.string.lower('FOO') assert future.get() == 'foo' # Simulate disconnection and reconnection with new identity client.socket.disconnect(endpoint) client.socket.identity = 'wow-doge' client.socket.connect(endpoint) gevent.sleep(.1) # Warmup assert client.string.lower('ABC').get() == 'abc' server.stop() client.stop()
async def test_untrusted_curve_with_allowed_password( loop, unused_tcp_port, untrusted_curve_auth_backend): from pseud import Client, Server from pseud.utils import register_rpc 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, 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 register_rpc(name='string.lower')(str.lower) async with server, client: result = await client.string.lower('FOO') result2 = await client.string.lower('FOO_JJ') result3 = await server.send_to(client_id).string.lower('ABC') assert result == 'foo' assert result2 == 'foo_jj' assert result3 == 'abc'
def test_untrusted_curve_with_allowed_password(): from pseud._gevent import Client, Server from pseud.utils import register_rpc client_id = 'john' server_id = 'server' endpoint = 'tcp://127.0.0.1:8998' server_public, server_secret = zmq.curve_keypair() client_public, client_secret = zmq.curve_keypair() security_plugin = 'untrusted_curve' password = '******' 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) server = Server(server_id, security_plugin=security_plugin, public_key=server_public, secret_key=server_secret) 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.start() import string register_rpc(name='string.lower')(string.lower) future = client.string.lower('FOO') future2 = client.string.lower('FOO_JJ') assert future.get() == 'foo' assert future2.get() == 'foo_jj' future3 = server.send_to(client_id).string.lower('ABC') assert future3.get() == 'abc' server.stop() client.stop()
async def test_server_can_send(loop, unused_tcp_port, plain_auth_backend): from pseud.utils import register_rpc server_id = b'server' endpoint = f'tcp://127.0.0.1:{unused_tcp_port}' server = make_one_server(server_id, loop, security_plugin='plain') client = make_one_client(server_id, loop, user_id=b'alice', password=b'alice', security_plugin='plain') server.bind(endpoint) client.connect(endpoint) register_rpc(name='string.lower')(str.lower) async with server, client: await asyncio.sleep(.1) result = await server.send_to(b'alice').string.lower('SCREAM') assert result == 'scream'
async def test_untrusted_curve_with_wrong_password(loop, unused_tcp_port): from pseud import Client, Server from pseud.interfaces import UnauthorizedError from pseud.utils import register_rpc 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, user_id=client_id, security_plugin=security_plugin, public_key=client_public, secret_key=client_secret, peer_public_key=server_public, password=password, 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 + b'Looser' register_rpc(name='string.lower')(str.lower) async with server, client: with pytest.raises(UnauthorizedError): await client.string.lower(b'IMSCREAMING')
def test_server_can_send_to_several_client(): from pseud.utils import register_rpc server_id = 'server' endpoint = 'tcp://127.0.0.1:5000' server = make_one_server(server_id, security_plugin='plain') client1 = make_one_client( server_id, security_plugin='plain', user_id='client1', password='******', ) client2 = make_one_client( server_id, security_plugin='plain', user_id='client2', password='******', ) server.bind(endpoint) client1.connect(endpoint) client2.connect(endpoint) server.start() client1.start() client2.start() import string register_rpc(name='string.lower')(string.lower) client1.string.lower('TATA').get() client2.string.lower('TATA').get() future1 = server.send_to('client1').string.lower('SCREAM1') future2 = server.send_to('client2').string.lower('SCREAM2') assert future1.get() == 'scream1' assert future2.get() == 'scream2' client1.stop() client2.stop() server.stop()
async def test_client_can_reconnect(loop, unused_tcp_port): from pseud.utils import register_rpc server_id = b'server' endpoint = f'tcp://127.0.0.1:{unused_tcp_port}' server = make_one_server(server_id, loop) client = make_one_client(server_id, loop) server.bind(endpoint) client.connect(endpoint) register_rpc(name='string.upper')(str.upper) async with server: result = await client.string.upper('hello') assert result == 'HELLO' client.disconnect(endpoint) client.connect(endpoint) await asyncio.sleep(.1) result = await client.string.upper('hello') assert result == 'HELLO'
def test_client_can_send(self): from pseud.utils import register_rpc server_id = b'server' endpoint = b'inproc://here' server = self.make_one_server(server_id) client = self.make_one_client(server_id) server.bind(endpoint) yield server.start() client.connect(endpoint) yield client.start() register_rpc(name='string.upper')(str.upper) result = yield client.string.upper('hello') assert result == 'HELLO' client.stop() server.stop()
def test_client_can_send(): from pseud.utils import register_rpc server_id = 'server' endpoint = 'inproc://here' server = make_one_server(server_id) client = make_one_client(server_id) server.bind(endpoint) server.start() client.connect(endpoint) client.start() import string register_rpc(name='string.upper')(string.upper) future = client.string.upper('hello') assert future.get() == 'HELLO' client.stop() server.stop()
def test_server_can_send_to_several_client(self): from pseud.utils import register_rpc from pseud._tornado import async_sleep server_id = b'server' endpoint = b'tcp://127.0.0.1:5000' server = self.make_one_server(server_id, security_plugin='plain') client1 = self.make_one_client(server_id, user_id=b'alice', password=b'alice', security_plugin='plain') client2 = self.make_one_client(server_id, user_id=b'bob', password=b'bob', security_plugin='plain') server.bind(endpoint) yield server.start() client1.connect(endpoint) client2.connect(endpoint) yield client1.start() yield client2.start() register_rpc(name='string.lower')(str.lower) # call the server to register yield client1.string.lower('TATA') yield client2.string.lower('TATA') result1 = yield server.send_to(b'alice').string.lower('SCREAM1') result2 = yield server.send_to(b'bob').string.lower('SCREAM2') assert result1 == 'scream1' assert result2 == 'scream2' client1.stop() client2.stop() server.stop()
def test_trusted_curve_with_wrong_peer_public_key(self): from pseud import Client, Server from pseud.utils import register_rpc server_id = b'server' endpoint = 'inproc://{}'.format(__name__).encode() endpoint = b'tcp://127.0.0.1:8998' server_public, server_secret = zmq.curve_keypair() server = Server(server_id, security_plugin='trusted_curve', public_key=server_public, secret_key=server_secret, io_loop=self.io_loop) server.bind(endpoint) alice_public, alice_secret = \ server.auth_backend.known_identities[b'alice'] client = Client(server_id, user_id=b'alice', security_plugin='trusted_curve', public_key=alice_public, secret_key=alice_secret, peer_public_key=z85.encode(b'R' * 32), timeout=.5, 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() register_rpc(name='string.lower')(str.lower) with pytest.raises(TimeoutError): yield client.string.lower('BAR') server.stop() client.stop()
def test_server_can_send_to_several_client(): from pseud.utils import register_rpc server_id = 'server' endpoint = 'tcp://127.0.0.1:5000' server = make_one_server(server_id, security_plugin='plain') client1 = make_one_client(server_id, security_plugin='plain', user_id='client1', password='******', ) client2 = make_one_client(server_id, security_plugin='plain', user_id='client2', password='******', ) server.bind(endpoint) client1.connect(endpoint) client2.connect(endpoint) server.start() client1.start() client2.start() import string register_rpc(name='string.lower')(string.lower) client1.string.lower('TATA').get() client2.string.lower('TATA').get() future1 = server.send_to('client1').string.lower('SCREAM1') future2 = server.send_to('client2').string.lower('SCREAM2') assert future1.get() == 'scream1' assert future2.get() == 'scream2' client1.stop() client2.stop() server.stop()
def test_trusted_curve(self): from pseud import Client, Server from pseud.utils import register_rpc server_id = b'server' endpoint = b'tcp://127.0.0.1:8998' 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() register_rpc(name='string.lower')(str.lower) result = yield client.string.lower('FOO') assert result == 'foo' server.stop() client.stop()