Change capabilities sedes according to #6503

This changes the (de-)serialization of capabilities that are broadcast
via synapse `avatar_url` to be url query parameters.

The new capabilities serialization format in detail:

Capabilities are serialized to `avatar_url` as

    mxc://raiden.network/cap?{capabilities_url_encoded}

The spec for `{capabilities_url_encoded}` is as follows:

- `bool` values are encoded as `'1' == True` and `'0' == False`
- other values are encoded as strings
- the strings `'0'` and `'1'` are deserialized as `bool` (see above).
- other strings are kept as they are
- multiple entries / list values are allowed
- final interpretation of any value is up to the client

Changes in detail:
- hand rolled serialization is removed
- truncation of falsy entries is dropped / all entries are explicit
- unknown capabilities will be preserved
- `parse_capabilities` is renamed to `deserialize_capabilities`
- deserialization errors are treated as empty capabilities
- adjusted unit tests

Author: konradkonrad

raiden/network/transport/matrix/utils.py

@@ -56,7 +56,7 @@
 )
 from raiden.network.utils import get_average_http_response_time
 from raiden.storage.serialization.serializer import MessageSerializer
-from raiden.utils.capabilities import parse_capabilities, serialize_capabilities
+from raiden.utils.capabilities import deserialize_capabilities, serialize_capabilities
 from raiden.utils.gevent import spawn_named
 from raiden.utils.signer import Signer, recover
 from raiden.utils.typing import Address, ChainID, MessageID, PeerCapabilities, Signature
@@ -346,7 +346,7 @@ def query_capabilities_for_user_id(self, user_id: str) -> PeerCapabilities:
             return PeerCapabilities({})
         avatar_url = user.get_avatar_url()
         if avatar_url is not None:
-            return PeerCapabilities(parse_capabilities(avatar_url))
+            return PeerCapabilities(deserialize_capabilities(avatar_url))
         else:
             return PeerCapabilities({})
 

raiden/tests/integration/fixtures/raiden_network.py

@@ -198,7 +198,8 @@ def adhoc_capability():
 @pytest.fixture
 def capabilities(adhoc_capability) -> CapabilitiesConfig:
     config = CapabilitiesConfig()
-    config.adhoc_capability = adhoc_capability  # type: ignore
+    if adhoc_capability:
+        config.adhoc_capability = adhoc_capability  # type: ignore
     return config
 
 

raiden/tests/integration/network/transport/test_matrix_transport.py

@@ -56,7 +56,7 @@
 from raiden.transfer.identifiers import CANONICAL_IDENTIFIER_UNORDERED_QUEUE, QueueIdentifier
 from raiden.transfer.state import NetworkState
 from raiden.transfer.state_change import ActionChannelClose
-from raiden.utils.capabilities import capconfig_to_dict, parse_capabilities
+from raiden.utils.capabilities import capconfig_to_dict, deserialize_capabilities
 from raiden.utils.formatting import to_checksum_address
 from raiden.utils.typing import Address, Dict, List, PeerCapabilities, TokenNetworkAddress, cast
 from raiden.waiting import wait_for_network_state
@@ -1343,18 +1343,15 @@ def test_transport_capabilities(raiden_network: List[RaidenService], capabilitie
     wait_for_network_state(app0, app1.address, NetworkState.REACHABLE, retry_timeout)
     wait_for_network_state(app1, app0.address, NetworkState.REACHABLE, retry_timeout)
 
-    # only True values are set in the avatar_url (opt_in)
-    expected_capabilities = {
-        key: value for key, value in capconfig_to_dict(capabilities).items() if value
-    }
+    expected_capabilities = capconfig_to_dict(capabilities)
 
     app1_user_ids = app0.transport.get_user_ids_for_address(app1.address)
     assert len(app1_user_ids) == 1, "app1 should have exactly one user_id"
     app1_user = app0.transport._client.get_user(app1_user_ids.pop())
     app1_avatar_url = app1_user.get_avatar_url()
-    assert "adhoc_capability" in app1_avatar_url, "avatar_url not set for app1"
-    msg = "capabilities could not be parsed"
-    assert parse_capabilities(app1_avatar_url) == expected_capabilities, msg
+    assert len(app1_avatar_url), "avatar_url not set for app1"
+    app1_capabilities = deserialize_capabilities(app1_avatar_url)
+    assert "adhoc_capability" in app1_capabilities, "capabilities could not be parsed correctly"
 
     msg = "capabilities were not collected in transport client"
     collected_capabilities = app0.transport._address_mgr.get_address_capabilities(app1.address)

raiden/tests/unit/test_utils.py

@@ -11,7 +11,7 @@
 from raiden.utils.capabilities import (
     capconfig_to_dict,
     capdict_to_config,
-    parse_capabilities,
+    deserialize_capabilities,
     serialize_capabilities,
 )
 from raiden.utils.keys import privatekey_to_publickey
@@ -97,26 +97,25 @@ def test_get_http_rtt_ignore_failing(requests_responses):
     assert get_average_http_response_time(url="http://url3", method="get") is None
 
 
-def test_parse_capabilities():
-    capstring = 'foo,toad,bar="max",form,agar'
-    parsed = parse_capabilities(capstring)
+def test_deserialize_capabilities():
+    capstring = "mxc://raiden.network/cap?foo=1&toad=1&bar=max&form=1&agar=1&nottrue=0&l=one&l=2"
+    parsed = deserialize_capabilities(capstring)
     assert parsed.get("foo") is True
     assert parsed.get("toad") is True
     assert parsed.get("bar") == "max"
-    assert parsed.get("form") is True
     assert parsed.get("agar") is True
+    assert parsed.get("nottrue") is False
+    assert parsed.get("l") == ["one", "2"]
     assert not parsed.get("nothing")
 
-    assert serialize_capabilities(parsed) == f"mxc://{capstring}"
+    assert serialize_capabilities(parsed) == f"{capstring}"
 
     parsed["false"] = False
 
-    assert serialize_capabilities(parsed) == f"mxc://{capstring}"
+    # Explicit new value changes the serialization format
+    assert serialize_capabilities(parsed) != f"mxc://{capstring}"
 
-    parsed["nothing"] = None
-    assert 'nothing="None"' in serialize_capabilities(parsed)
-
-    assert parse_capabilities("") == dict()
+    assert deserialize_capabilities("") == dict()
 
     assert serialize_capabilities({}) == "mxc://"
 

raiden/utils/capabilities.py

@@ -1,44 +1,61 @@
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
+
+import structlog
+from werkzeug.urls import url_decode, url_encode
 
 from raiden.constants import Capabilities
 from raiden.settings import CapabilitiesConfig
 
+log = structlog.get_logger(__name__)
+
+
+def _bool_to_binary(value: Any) -> str:
+    if isinstance(value, bool):
+        return "1" if value is True else "0"
+    return value
+
+
+def _serialize(capdict: Optional[Dict[str, Any]]) -> str:
+    if capdict is None:
+        capdict = {}
+    for key in capdict:
+        capdict[key] = _bool_to_binary(capdict[key])
+    return url_encode(capdict)
+
+
+def serialize_capabilities(capdict: Optional[Dict[str, Any]]) -> str:
+    if not capdict:
+        return "mxc://"
+    return f"mxc://raiden.network/cap?{_serialize(capdict)}"
+
 
-def parse_capabilities(capstring: str) -> Dict[str, Any]:
+def deserialize_capabilities(capstring: str) -> Dict[str, Any]:
     if capstring.startswith("mxc://"):
         capstring = capstring[6:]
-    elif "/" in capstring:
+    if "/" in capstring:
         capstring = capstring[capstring.rindex("/") + 1 :]
-    result: Dict[str, Any] = {}
-    if len(capstring) == 0:
-        return result
-    for token in capstring.split(","):
-        if "=" in token:
-            key, value = token.split("=")
-            value = value.strip('"')
-            result[key] = value
+    if "?" in capstring:
+        capstring = capstring[capstring.rindex("?") + 1 :]
+    capdict = url_decode(capstring.encode("utf-8"))
+    capabilities: Dict[str, Any] = dict()
+    for key in capdict:
+        value = capdict.getlist(key, type=int_bool)
+        # reduce lists with one entry to just their element
+        if len(value) == 1:
+            capabilities[key] = value.pop()
         else:
-            result[token] = True
-    return result
+            capabilities[key] = value
+    return capabilities
 
 
-def serialize_capabilities(capdict: Optional[Dict[str, Any]]) -> str:
-    if not capdict:
-        return "mxc://"
-    for key in capdict.keys():
-        if "/" in str(key):
-            raise ValueError(f"Key {key} is malformed, '/' not allowed")
-
-    entries = []
-    for key, value in capdict.items():
-        if isinstance(value, bool):
-            if value:
-                entries.append(key)
+def int_bool(value: str) -> Union[bool, str]:
+    try:
+        if int(value) in {0, 1}:
+            return bool(int(value))
         else:
-            entries.append(f'{key}="{value}"')
-    if len(entries):
-        return f"mxc://{','.join(entries)}"
-    return "mxc://"
+            return value
+    except ValueError:
+        return value
 
 
 def capdict_to_config(capdict: Dict[str, Any]) -> CapabilitiesConfig: