Merge branch 'dev'

anonstream/routes/wrappers.py

@@ -137,6 +137,7 @@ def with_user_from(context, fallback_to_token=False, ignore_allowedness=False):
                     user['headers'] = tuple(context.headers)
                     if not ignore_allowedness:
                         assert_allowedness(timestamp, user)
+                if user is not None and user['verified'] is not None:
                     response = await f(timestamp, user, *args, **kwargs)
                 elif fallback_to_token:
                     #assert not broadcaster

anonstream/tasks.py

@@ -64,9 +64,13 @@ async def t_sunset_users(timestamp, iteration):
     if iteration == 0:
         return
 
-    # Deverify absent users
+    # De-access absent users
-    for user in get_absent_users(timestamp):
+    absent_users = tuple(get_absent_users(timestamp))
-        user['verified'] = False
+    for user in absent_users:
+        user['verified'] = None
+    # Absent users should have no connected websockets,
+    # so in normal operation this should always be a no-op
+    broadcast(users=absent_users, payload={'type': 'kick'})
 
     # Remove as many absent users as possible
 

anonstream/websocket.py

@@ -54,7 +54,11 @@ async def websocket_outbound(queue, user):
                 await websocket.close(1001)
                 break
             else:
-                await websocket.send_json(payload)
+                if user['verified'] is None:
+                    await websocket.send_json({'type': 'kick'})
+                    await websocket.close(1001)
+                else:
+                    await websocket.send_json(payload)
 
 async def websocket_inbound(queue, user):
     while True:
@@ -73,25 +77,28 @@ async def websocket_inbound(queue, user):
         except AllowednessException:
             payload = {'type': 'kick'}
         else:
-            try:
+            if user['verified'] is None:
-                receipt_type, parsed = parse_websocket_data(receipt)
+                payload = {'type': 'kick'}
-            except Malformed as e:
-                error , *_ = e.args
-                payload = {
-                    'type': 'error',
-                    'because': error,
-                }
             else:
-                match receipt_type:
+                try:
-                    case WS.MESSAGE:
+                    receipt_type, parsed = parse_websocket_data(receipt)
-                        handle = handle_inbound_message
+                except Malformed as e:
-                    case WS.APPEARANCE:
+                    error , *_ = e.args
-                        handle = handle_inbound_appearance
+                    payload = {
-                    case WS.CAPTCHA:
+                        'type': 'error',
-                        handle = handle_inbound_captcha
+                        'because': error,
-                    case WS.PONG:
+                    }
-                        handle = handle_inbound_pong
+                else:
-                payload = handle(timestamp, queue, user, *parsed)
+                    match receipt_type:
+                        case WS.MESSAGE:
+                            handle = handle_inbound_message
+                        case WS.APPEARANCE:
+                            handle = handle_inbound_appearance
+                        case WS.CAPTCHA:
+                            handle = handle_inbound_captcha
+                        case WS.PONG:
+                            handle = handle_inbound_pong
+                    payload = handle(timestamp, queue, user, *parsed)
 
         # Write to websocket
         if payload is not None: