Fix/device delegate auth

synapse/api/auth/msc3861_delegated.py

@@ -349,16 +349,21 @@ async def get_user_by_access_token(
 
             # Create the device on the fly if it does not exist
             try:
+                logger.info(f"[DELEGATED AUTH]: Device search started: {user_id.to_string()} - {device_id}")
                 device = await self.store.get_device(
                     user_id=user_id.to_string(), device_id=device_id
                 )
-                if device is None:
+                if device:
+                    logger.info(f"[DELEGATED AUTH]: Device found: {device_id}")
+                else:
+                    logger.info(f"[DELEGATED AUTH]: Device not found, storing new device: {device_id}")
                     await self.store.store_device(
                         user_id=user_id.to_string(),
                         device_id=device_id,
                         initial_device_display_name="OIDC-native client",
                     )
-            except StoreError:
+            except StoreError as error:
+                logger.error(f"[DELEGATED AUTH]: Error in device processing: {error}")
                 await self.store.store_device(
                     user_id=user_id.to_string(),
                     device_id=device_id,

synapse/handlers/device.py

@@ -760,24 +760,24 @@ async def rehydrate_device(
         # token and refresh token to use the dehydrated device's ID and
         # copy the old device display name to the dehydrated device,
         # and destroy the old device ID
-        old_device_id = await self.store.set_device_for_access_token(
-            access_token, device_id
-        )
-        await self.store.set_device_for_refresh_token(user_id, old_device_id, device_id)
-        old_device = await self.store.get_device(user_id, old_device_id)
-        if old_device is None:
-            raise errors.NotFoundError()
-        await self.store.update_device(user_id, device_id, old_device["display_name"])
-        # can't call self.delete_device because that will clobber the
-        # access token so call the storage layer directly
-        await self.store.delete_devices(user_id, [old_device_id])
-        await self.store.delete_e2e_keys_by_device(
-            user_id=user_id, device_id=old_device_id
-        )
+        # old_device_id = await self.store.set_device_for_access_token(
+        #     access_token, device_id
+        # )
+        # await self.store.set_device_for_refresh_token(user_id, old_device_id, device_id)
+        # old_device = await self.store.get_device(user_id, old_device_id)
+        # if old_device is None:
+        #     raise errors.NotFoundError()
+        # await self.store.update_device(user_id, device_id, old_device["display_name"])
+        # # can't call self.delete_device because that will clobber the
+        # # access token so call the storage layer directly
+        # await self.store.delete_devices(user_id, [old_device_id])
+        # await self.store.delete_e2e_keys_by_device(
+        #     user_id=user_id, device_id=old_device_id
+        # )
 
         # tell everyone that the old device is gone and that the dehydrated
         # device has a new display name
-        await self.notify_device_update(user_id, [old_device_id, device_id])
+        await self.notify_device_update(user_id, [device_id])
 
         return {"success": True}
 

synapse/storage/databases/main/devices.py

@@ -262,6 +262,7 @@ async def get_device(
             desc="get_device",
             allow_none=True,
         )
+        logger.info("[DELEGATED AUTH]: get_device(%s, %s) -> %s", user_id, device_id, row)
         if row is None:
             return None
         return {"user_id": row[0], "device_id": row[1], "display_name": row[2]}
@@ -1789,7 +1790,7 @@ async def delete_devices(self, user_id: str, device_ids: List[str]) -> None:
             user_id: The ID of the user which owns the devices
             device_ids: The IDs of the devices to delete
         """
-
+        logger.info("[DELEGATED AUTH]: Deleting devices %r for user %r", device_ids, user_id)
         def _delete_devices_txn(txn: LoggingTransaction) -> None:
             self.db_pool.simple_delete_many_txn(
                 txn,