From 9f2186725adba33b634f7287e3518086e2bbc3ea Mon Sep 17 00:00:00 2001 From: Miguel Grinberg Date: Wed, 2 Jan 2019 23:01:09 +0000 Subject: [PATCH] user sessions --- docs/server.rst | 64 +++++++++++++++++++++++++++++++ socketio/asyncio_namespace.py | 33 ++++++++++++++++ socketio/asyncio_server.py | 67 ++++++++++++++++++++++++++++++++ socketio/namespace.py | 29 ++++++++++++++ socketio/server.py | 68 +++++++++++++++++++++++++++++++++ tests/test_asyncio_namespace.py | 21 ++++++++++ tests/test_asyncio_server.py | 32 ++++++++++++++++ tests/test_namespace.py | 18 +++++++++ tests/test_server.py | 28 ++++++++++++++ 9 files changed, 360 insertions(+) diff --git a/docs/server.rst b/docs/server.rst index 4b35184..af856bd 100644 --- a/docs/server.rst +++ b/docs/server.rst @@ -275,6 +275,70 @@ during the broadcast. def message(sid, data): sio.emit('my reply', data, room='chat_users', skip_sid=sid) +User Sessions +------------- + +The server can maintain application-specific information in a user session +dedicated to each connected client. Applications can use the user session to +write any details about the user that need to be preserved throughout the life +of the connection, such as usernames or user ids. + +The ``save_session()`` and ``get_session()`` methods are used to store and +retrieve information in the user session:: + + @sio.on('connect') + def on_connect(sid, environ): + username = authenticate_user(environ) + sio.save_session(sid, {'username': username}) + + @sio.on('message') + def on_message(sid, data): + session = sio.get_session(sid) + print('message from ', session['username']) + +For the ``asyncio`` server, these methods are coroutines:: + + + @sio.on('connect') + async def on_connect(sid, environ): + username = authenticate_user(environ) + await sio.save_session(sid, {'username': username}) + + @sio.on('message') + async def on_message(sid, data): + session = await sio.get_session(sid) + print('message from ', session['username']) + +The session can also be manipulated with the `session()` context manager:: + + @sio.on('connect') + def on_connect(sid, environ): + username = authenticate_user(environ) + with sio.session(sid) as session: + session['username'] = username + + @sio.on('message') + def on_message(sid, data): + with sio.session(sid) as session: + print('message from ', session['username']) + +For the ``asyncio`` server, an asynchronous context manager is used:: + + @sio.on('connect') + def on_connect(sid, environ): + username = authenticate_user(environ) + async with sio.session(sid) as session: + session['username'] = username + + @sio.on('message') + def on_message(sid, data): + async with sio.session(sid) as session: + print('message from ', session['username']) + +The ``get_session()``, ``save_session()`` and ``session()`` methods take an +optional ``namespace`` argument. If this argument isn't provided, the session +is attached to the default namespace. + Using a Message Queue --------------------- diff --git a/socketio/asyncio_namespace.py b/socketio/asyncio_namespace.py index 38bad98..e376875 100644 --- a/socketio/asyncio_namespace.py +++ b/socketio/asyncio_namespace.py @@ -82,6 +82,39 @@ class AsyncNamespace(namespace.Namespace): return await self.server.close_room( room, namespace=namespace or self.namespace) + async def get_session(self, sid, namespace=None): + """Return the user session for a client. + + The only difference with the :func:`socketio.Server.get_session` + method is that when the ``namespace`` argument is not given the + namespace associated with the class is used. + + Note: this method is a coroutine. + """ + return await self.server.get_session( + sid, namespace=namespace or self.namespace) + + async def save_session(self, sid, session, namespace=None): + """Store the user session for a client. + + The only difference with the :func:`socketio.Server.save_session` + method is that when the ``namespace`` argument is not given the + namespace associated with the class is used. + + Note: this method is a coroutine. + """ + return await self.server.save_session( + sid, session, namespace=namespace or self.namespace) + + def session(self, sid, namespace=None): + """Return the user session for a client with context manager syntax. + + The only difference with the :func:`socketio.Server.session` method is + that when the ``namespace`` argument is not given the namespace + associated with the class is used. + """ + return self.server.session(sid, namespace=namespace or self.namespace) + async def disconnect(self, sid, namespace=None): """Disconnect a client. diff --git a/socketio/asyncio_server.py b/socketio/asyncio_server.py index 2188f22..cbd812b 100644 --- a/socketio/asyncio_server.py +++ b/socketio/asyncio_server.py @@ -169,6 +169,73 @@ class AsyncServer(server.Server): self.logger.info('room %s is closing [%s]', room, namespace) await self.manager.close_room(room, namespace) + async def get_session(self, sid, namespace=None): + """Return the user session for a client. + + :param sid: The session id of the client. + :param namespace: The Socket.IO namespace. If this argument is omitted + the default namespace is used. + + The return value is a dictionary. Modifications made to this + dictionary are not guaranteed to be preserved. If you want to modify + the user session, use the ``session`` context manager instead. + """ + namespace = namespace or '/' + eio_session = await self.eio.get_session(sid) + return eio_session.setdefault(namespace, {}) + + async def save_session(self, sid, session, namespace=None): + """Store the user session for a client. + + :param sid: The session id of the client. + :param session: The session dictionary. + :param namespace: The Socket.IO namespace. If this argument is omitted + the default namespace is used. + """ + namespace = namespace or '/' + eio_session = await self.eio.get_session(sid) + eio_session[namespace] = session + + def session(self, sid, namespace=None): + """Return the user session for a client with context manager syntax. + + :param sid: The session id of the client. + + This is a context manager that returns the user session dictionary for + the client. Any changes that are made to this dictionary inside the + context manager block are saved back to the session. Example usage:: + + @eio.on('connect') + def on_connect(sid, environ): + username = authenticate_user(environ) + if not username: + return False + with eio.session(sid) as session: + session['username'] = username + + @eio.on('message') + def on_message(sid, msg): + async with eio.session(sid) as session: + print('received message from ', session['username']) + """ + class _session_context_manager(object): + def __init__(self, server, sid, namespace): + self.server = server + self.sid = sid + self.namespace = namespace + self.session = None + + async def __aenter__(self): + self.session = await self.server.get_session( + sid, namespace=self.namespace) + return self.session + + async def __aexit__(self, *args): + await self.server.save_session(sid, self.session, + namespace=self.namespace) + + return _session_context_manager(self, sid, namespace) + async def disconnect(self, sid, namespace=None): """Disconnect a client. diff --git a/socketio/namespace.py b/socketio/namespace.py index 158657f..30ab1bf 100644 --- a/socketio/namespace.py +++ b/socketio/namespace.py @@ -100,6 +100,35 @@ class Namespace(BaseNamespace): """ return self.server.rooms(sid, namespace=namespace or self.namespace) + def get_session(self, sid, namespace=None): + """Return the user session for a client. + + The only difference with the :func:`socketio.Server.get_session` + method is that when the ``namespace`` argument is not given the + namespace associated with the class is used. + """ + return self.server.get_session( + sid, namespace=namespace or self.namespace) + + def save_session(self, sid, session, namespace=None): + """Store the user session for a client. + + The only difference with the :func:`socketio.Server.save_session` + method is that when the ``namespace`` argument is not given the + namespace associated with the class is used. + """ + return self.server.save_session( + sid, session, namespace=namespace or self.namespace) + + def session(self, sid, namespace=None): + """Return the user session for a client with context manager syntax. + + The only difference with the :func:`socketio.Server.session` method is + that when the ``namespace`` argument is not given the namespace + associated with the class is used. + """ + return self.server.session(sid, namespace=namespace or self.namespace) + def disconnect(self, sid, namespace=None): """Disconnect a client. diff --git a/socketio/server.py b/socketio/server.py index 389c529..449c94a 100644 --- a/socketio/server.py +++ b/socketio/server.py @@ -317,6 +317,74 @@ class Server(object): namespace = namespace or '/' return self.manager.get_rooms(sid, namespace) + def get_session(self, sid, namespace=None): + """Return the user session for a client. + + :param sid: The session id of the client. + :param namespace: The Socket.IO namespace. If this argument is omitted + the default namespace is used. + + The return value is a dictionary. Modifications made to this + dictionary are not guaranteed to be preserved unless + ``save_session()`` is called, or when the ``session`` context manager + is used. + """ + namespace = namespace or '/' + eio_session = self.eio.get_session(sid) + return eio_session.setdefault(namespace, {}) + + def save_session(self, sid, session, namespace=None): + """Store the user session for a client. + + :param sid: The session id of the client. + :param session: The session dictionary. + :param namespace: The Socket.IO namespace. If this argument is omitted + the default namespace is used. + """ + namespace = namespace or '/' + eio_session = self.eio.get_session(sid) + eio_session[namespace] = session + + def session(self, sid, namespace=None): + """Return the user session for a client with context manager syntax. + + :param sid: The session id of the client. + + This is a context manager that returns the user session dictionary for + the client. Any changes that are made to this dictionary inside the + context manager block are saved back to the session. Example usage:: + + @sio.on('connect') + def on_connect(sid, environ): + username = authenticate_user(environ) + if not username: + return False + with sio.session(sid) as session: + session['username'] = username + + @sio.on('message') + def on_message(sid, msg): + with sio.session(sid) as session: + print('received message from ', session['username']) + """ + class _session_context_manager(object): + def __init__(self, server, sid, namespace): + self.server = server + self.sid = sid + self.namespace = namespace + self.session = None + + def __enter__(self): + self.session = self.server.get_session(sid, + namespace=namespace) + return self.session + + def __exit__(self, *args): + self.server.save_session(sid, self.session, + namespace=namespace) + + return _session_context_manager(self, sid, namespace) + def disconnect(self, sid, namespace=None): """Disconnect a client. diff --git a/tests/test_asyncio_namespace.py b/tests/test_asyncio_namespace.py index e5f0466..b99cd20 100644 --- a/tests/test_asyncio_namespace.py +++ b/tests/test_asyncio_namespace.py @@ -170,6 +170,27 @@ class TestAsyncNamespace(unittest.TestCase): ns.rooms('sid', namespace='/bar') ns.server.rooms.assert_called_with('sid', namespace='/bar') + def test_session(self): + ns = asyncio_namespace.AsyncNamespace('/foo') + mock_server = mock.MagicMock() + mock_server.get_session = AsyncMock() + mock_server.save_session = AsyncMock() + ns._set_server(mock_server) + _run(ns.get_session('sid')) + ns.server.get_session.mock.assert_called_with('sid', namespace='/foo') + _run(ns.get_session('sid', namespace='/bar')) + ns.server.get_session.mock.assert_called_with('sid', namespace='/bar') + _run(ns.save_session('sid', {'a': 'b'})) + ns.server.save_session.mock.assert_called_with('sid', {'a': 'b'}, + namespace='/foo') + _run(ns.save_session('sid', {'a': 'b'}, namespace='/bar')) + ns.server.save_session.mock.assert_called_with('sid', {'a': 'b'}, + namespace='/bar') + ns.session('sid') + ns.server.session.assert_called_with('sid', namespace='/foo') + ns.session('sid', namespace='/bar') + ns.server.session.assert_called_with('sid', namespace='/bar') + def test_disconnect(self): ns = asyncio_namespace.AsyncNamespace('/foo') mock_server = mock.MagicMock() diff --git a/tests/test_asyncio_server.py b/tests/test_asyncio_server.py index c4272c3..3738cda 100644 --- a/tests/test_asyncio_server.py +++ b/tests/test_asyncio_server.py @@ -454,6 +454,38 @@ class TestAsyncServer(unittest.TestCase): _run(s._handle_eio_message('123', '3/foo,1["foo",2]')) cb.assert_called_once_with('foo', 2) + def test_session(self, eio): + fake_session = {} + + async def fake_get_session(sid): + return fake_session + + async def fake_save_session(sid, session): + global fake_session + fake_session = session + + eio.return_value.send = AsyncMock() + s = asyncio_server.AsyncServer() + s.eio.get_session = fake_get_session + s.eio.save_session = fake_save_session + + async def _test(): + await s._handle_eio_connect('123', 'environ') + await s.save_session('123', {'foo': 'bar'}) + async with s.session('123') as session: + self.assertEqual(session, {'foo': 'bar'}) + session['foo'] = 'baz' + session['bar'] = 'foo' + self.assertEqual(await s.get_session('123'), {'foo': 'baz', 'bar': 'foo'}) + self.assertEqual(fake_session, {'/': {'foo': 'baz', 'bar': 'foo'}}) + async with s.session('123', namespace='/ns') as session: + self.assertEqual(session, {}) + session['a'] = 'b' + self.assertEqual(await s.get_session('123', namespace='/ns'), {'a': 'b'}) + self.assertEqual(fake_session, {'/': {'foo': 'baz', 'bar': 'foo'}, + '/ns': {'a': 'b'}}) + _run(_test()) + def test_disconnect(self, eio): eio.return_value.send = AsyncMock() s = asyncio_server.AsyncServer() diff --git a/tests/test_namespace.py b/tests/test_namespace.py index 8eaec96..b07e820 100644 --- a/tests/test_namespace.py +++ b/tests/test_namespace.py @@ -120,6 +120,24 @@ class TestNamespace(unittest.TestCase): ns.rooms('sid', namespace='/bar') ns.server.rooms.assert_called_with('sid', namespace='/bar') + def test_session(self): + ns = namespace.Namespace('/foo') + ns._set_server(mock.MagicMock()) + ns.get_session('sid') + ns.server.get_session.assert_called_with('sid', namespace='/foo') + ns.get_session('sid', namespace='/bar') + ns.server.get_session.assert_called_with('sid', namespace='/bar') + ns.save_session('sid', {'a': 'b'}) + ns.server.save_session.assert_called_with('sid', {'a': 'b'}, + namespace='/foo') + ns.save_session('sid', {'a': 'b'}, namespace='/bar') + ns.server.save_session.assert_called_with('sid', {'a': 'b'}, + namespace='/bar') + ns.session('sid') + ns.server.session.assert_called_with('sid', namespace='/foo') + ns.session('sid', namespace='/bar') + ns.server.session.assert_called_with('sid', namespace='/bar') + def test_disconnect(self): ns = namespace.Namespace('/foo') ns._set_server(mock.MagicMock()) diff --git a/tests/test_server.py b/tests/test_server.py index 03370d3..5e16ec5 100644 --- a/tests/test_server.py +++ b/tests/test_server.py @@ -375,6 +375,34 @@ class TestServer(unittest.TestCase): s._handle_eio_message('123', '3/foo,1["foo",2]') cb.assert_called_once_with('foo', 2) + def test_session(self, eio): + fake_session = {} + + def fake_get_session(sid): + return fake_session + + def fake_save_session(sid, session): + global fake_session + fake_session = session + + s = server.Server() + s.eio.get_session = fake_get_session + s.eio.save_session = fake_save_session + s._handle_eio_connect('123', 'environ') + s.save_session('123', {'foo': 'bar'}) + with s.session('123') as session: + self.assertEqual(session, {'foo': 'bar'}) + session['foo'] = 'baz' + session['bar'] = 'foo' + self.assertEqual(s.get_session('123'), {'foo': 'baz', 'bar': 'foo'}) + self.assertEqual(fake_session, {'/': {'foo': 'baz', 'bar': 'foo'}}) + with s.session('123', namespace='/ns') as session: + self.assertEqual(session, {}) + session['a'] = 'b' + self.assertEqual(s.get_session('123', namespace='/ns'), {'a': 'b'}) + self.assertEqual(fake_session, {'/': {'foo': 'baz', 'bar': 'foo'}, + '/ns': {'a': 'b'}}) + def test_disconnect(self, eio): s = server.Server() s._handle_eio_connect('123', 'environ')