Dehydrated devices

synapse/handlers/device.py

@@ -532,7 +532,9 @@ async def store_dehydrated_device(
             await self.delete_device(user_id, old_device_id)
         return device_id
 
-    async def get_dehydrated_device(self, user_id: str) -> Tuple[str, JsonDict]:
+    async def get_dehydrated_device(
+        self, user_id: str
+    ) -> Optional[Tuple[str, JsonDict]]:
         """Retrieve the information for a dehydrated device.
 
         Args:

synapse/rest/client/v2_alpha/devices.py

@@ -188,7 +188,7 @@ class DehydratedDeviceServlet(RestServlet):
 
     """
 
-    PATTERNS = client_patterns("/org.matrix.msc2697.v2/dehydrated_device")
+    PATTERNS = client_patterns("/org.matrix.msc2697.v2/dehydrated_device", releases=())
 
     def __init__(self, hs):
         super(DehydratedDeviceServlet, self).__init__()
@@ -197,21 +197,32 @@ def __init__(self, hs):
         self.device_handler = hs.get_device_handler()
 
     async def on_GET(self, request: SynapseRequest):
-        requester = await self.auth.get_user_by_req(request, allow_guest=True)
-        (
-            device_id,
-            dehydrated_device,
-        ) = await self.device_handler.get_dehydrated_device(requester.user.to_string())
-        if dehydrated_device:
+        requester = await self.auth.get_user_by_req(request)
+        dehydrated_device = await self.device_handler.get_dehydrated_device(
+            requester.user.to_string()
+        )
+        if dehydrated_device is not None:
+            (device_id, device_data) = dehydrated_device
             result = {"device_id": device_id, "device_data": dehydrated_device}
             return (200, result)
         else:
-            raise errors.NotFoundError()
+            raise errors.NotFoundError("No dehydrated device available")
 
     async def on_PUT(self, request: SynapseRequest):
         submission = parse_json_object_from_request(request)
         requester = await self.auth.get_user_by_req(request)
 
+        if "device_data" not in submission:
+            raise errors.SynapseError(
+                400, "device_data missing", errcode=errors.Codes.MISSING_PARAM,
+            )
+        elif isinstance(submission["device_id"], dict):
+            raise errors.SynapseError(
+                400,
+                "device_data must be an object",
+                errcode=errors.Codes.INVALID_PARAM,
+            )
+
         device_id = await self.device_handler.store_dehydrated_device(
             requester.user.to_string(),
             submission["device_data"],
@@ -239,7 +250,9 @@ class ClaimDehydratedDeviceServlet(RestServlet):
 
     """
 
-    PATTERNS = client_patterns("/org.matrix.msc2697.v2/dehydrated_device/claim")
+    PATTERNS = client_patterns(
+        "/org.matrix.msc2697.v2/dehydrated_device/claim", releases=()
+    )
 
     def __init__(self, hs):
         super(ClaimDehydratedDeviceServlet, self).__init__()
@@ -248,10 +261,19 @@ def __init__(self, hs):
         self.device_handler = hs.get_device_handler()
 
     async def on_POST(self, request: SynapseRequest):
-        requester = await self.auth.get_user_by_req(request, allow_guest=True)
+        requester = await self.auth.get_user_by_req(request)
 
         submission = parse_json_object_from_request(request)
 
+        if "device_id" not in submission:
+            raise errors.SynapseError(
+                400, "device_id missing", errcode=errors.Codes.MISSING_PARAM,
+            )
+        elif isinstance(submission["device_id"], str):
+            raise errors.SynapseError(
+                400, "device_id must be a string", errcode=errors.Codes.INVALID_PARAM,
+            )
+
         result = await self.device_handler.rehydrate_device(
             requester.user.to_string(),
             self.auth.get_access_token_from_request(request),

synapse/rest/client/v2_alpha/keys.py

@@ -77,14 +77,14 @@ async def on_POST(self, request, device_id):
         body = parse_json_object_from_request(request)
 
         if device_id is not None:
-            # passing the device_id here is deprecated; however, we allow it
-            # for now for compatibility with older clients.
+            # passing the device_id here should only be done for setting keys
+            # for dehydrated devices; however, we allow it for now for
+            # compatibility with older clients.
             if requester.device_id is not None and device_id != requester.device_id:
-                (
-                    dehydrated_device_id,
-                    _,
-                ) = await self.device_handler.get_dehydrated_device(user_id)
-                if device_id != dehydrated_device_id:
+                dehydrated_device = await self.device_handler.get_dehydrated_device(
+                    user_id
+                )
+                if dehydrated_device is not None and device_id != dehydrated_device[0]:
                     set_tag("error", True)
                     log_kv(
                         {

synapse/storage/databases/main/devices.py

@@ -698,7 +698,9 @@ def _mark_remote_user_device_list_as_unsubscribed_txn(txn):
             _mark_remote_user_device_list_as_unsubscribed_txn,
         )
 
-    async def get_dehydrated_device(self, user_id: str) -> Tuple[str, JsonDict]:
+    async def get_dehydrated_device(
+        self, user_id: str
+    ) -> Optional[Tuple[str, JsonDict]]:
         """Retrieve the information for a dehydrated device.
 
         Args:
@@ -715,9 +717,7 @@ async def get_dehydrated_device(self, user_id: str) -> Tuple[str, JsonDict]:
             allow_none=True,
         )
         return (
-            (row["device_id"], json_decoder.decode(row["device_data"]))
-            if row
-            else (None, None)
+            (row["device_id"], json_decoder.decode(row["device_data"])) if row else None
         )
 
     def _store_dehydrated_device_txn(
@@ -730,23 +730,12 @@ def _store_dehydrated_device_txn(
             retcol="device_id",
             allow_none=True,
         )
-        if old_device_id is None:
-            self.db_pool.simple_insert_txn(
-                txn,
-                table="dehydrated_devices",
-                values={
-                    "user_id": user_id,
-                    "device_id": device_id,
-                    "device_data": device_data,
-                },
-            )
-        else:
-            self.db_pool.simple_update_txn(
-                txn,
-                table="dehydrated_devices",
-                keyvalues={"user_id": user_id},
-                updatevalues={"device_id": device_id, "device_data": device_data},
-            )
+        self.db_pool.simple_upsert_txn(
+            txn,
+            table="dehydrated_devices",
+            keyvalues={"user_id": user_id},
+            values={"device_id": device_id, "device_data": device_data},
+        )
         return old_device_id
 
     async def store_dehydrated_device(
@@ -756,8 +745,8 @@ async def store_dehydrated_device(
 
         Args:
             user_id: the user that we are storing the device for
+            device_id: the ID of the dehydrated device
             device_data: the dehydrated device information
-            initial_device_display_name: The display name to use for the device
         Returns:
             device id of the user's previous dehydrated device, if any
         """

synapse/storage/databases/main/schema/delta/58/11dehydration.sql

@@ -16,5 +16,5 @@
 CREATE TABLE IF NOT EXISTS dehydrated_devices(
     user_id TEXT NOT NULL PRIMARY KEY,
     device_id TEXT NOT NULL,
-    device_data TEXT NOT NULL
+    device_data TEXT NOT NULL -- JSON-encoded client-defined data
 );

tests/handlers/test_device.py

@@ -300,4 +300,4 @@ def test_dehydrate_and_rehydrate_device(self):
         # make sure that there's no device available for dehydrating now
         ret = self.get_success(self.handler.get_dehydrated_device(user_id=user_id))
 
-        self.assertEqual(ret, (None, None))
+        self.assertEqual(ret, None)