From c856e29ccd63aa10d1c03434b1bc021753305348 Mon Sep 17 00:00:00 2001 From: Erik Johnston Date: Wed, 5 May 2021 13:42:58 +0100 Subject: Remvoe dictionary based access form events --- synapse/api/filtering.py | 8 ++++++++ synapse/crypto/event_signing.py | 2 +- synapse/event_auth.py | 4 +++- synapse/events/__init__.py | 28 +++++----------------------- synapse/federation/federation_base.py | 4 +--- synapse/handlers/message.py | 2 +- synapse/handlers/room.py | 2 +- synapse/notifier.py | 2 +- synapse/push/push_rule_evaluator.py | 4 ++-- 9 files changed, 23 insertions(+), 33 deletions(-) diff --git a/synapse/api/filtering.py b/synapse/api/filtering.py index ce49a0ad58..3e7eb47001 100644 --- a/synapse/api/filtering.py +++ b/synapse/api/filtering.py @@ -23,6 +23,7 @@ from jsonschema import FormatChecker from synapse.api.constants import EventContentFields from synapse.api.errors import SynapseError from synapse.api.presence import UserPresenceState +from synapse.events import EventBase from synapse.types import RoomID, UserID FILTER_SCHEMA = { @@ -290,6 +291,13 @@ class Filter: ev_type = "m.presence" contains_url = False labels = [] # type: List[str] + elif isinstance(event, EventBase): + sender = event.sender + room_id = event.room_id + ev_type = event.type + content = event.content + contains_url = isinstance(content.get("url"), str) + labels = content.get(EventContentFields.LABELS, []) else: sender = event.get("sender", None) if not sender: diff --git a/synapse/crypto/event_signing.py b/synapse/crypto/event_signing.py index 0f2b632e47..c2a67704d6 100644 --- a/synapse/crypto/event_signing.py +++ b/synapse/crypto/event_signing.py @@ -48,7 +48,7 @@ def check_event_content_hash( # some malformed events lack a 'hashes'. Protect against it being missing # or a weird type by basically treating it the same as an unhashed event. - hashes = event.get("hashes") + hashes = getattr(event, "hashes", None) # nb it might be a frozendict or a dict if not isinstance(hashes, collections.abc.Mapping): raise SynapseError( diff --git a/synapse/event_auth.py b/synapse/event_auth.py index 70c556566e..eb9cd2f5eb 100644 --- a/synapse/event_auth.py +++ b/synapse/event_auth.py @@ -418,7 +418,9 @@ def get_send_level( def _can_send_event(event: EventBase, auth_events: StateMap[EventBase]) -> bool: power_levels_event = _get_power_level_event(auth_events) - send_level = get_send_level(event.type, event.get("state_key"), power_levels_event) + send_level = get_send_level( + event.type, getattr(event, "state_key", None), power_levels_event + ) user_level = get_user_power_level(event.user_id, auth_events) if user_level < send_level: diff --git a/synapse/events/__init__.py b/synapse/events/__init__.py index c8b52cbc7a..46d26e0af9 100644 --- a/synapse/events/__init__.py +++ b/synapse/events/__init__.py @@ -263,12 +263,6 @@ class EventBase(metaclass=abc.ABCMeta): return d - def get(self, key, default=None): - return self._dict.get(key, default) - - def get_internal_metadata_dict(self): - return self.internal_metadata.get_dict() - def get_pdu_json(self, time_now=None) -> JsonDict: pdu_json = self.get_dict() @@ -285,18 +279,6 @@ class EventBase(metaclass=abc.ABCMeta): def __set__(self, instance, value): raise AttributeError("Unrecognized attribute %s" % (instance,)) - def __getitem__(self, field): - return self._dict[field] - - def __contains__(self, field): - return field in self._dict - - def items(self): - return list(self._dict.items()) - - def keys(self): - return self._dict.keys() - def prev_event_ids(self): """Returns the list of prev event IDs. The order matches the order specified in the event, though there is no meaning to it. @@ -374,9 +356,9 @@ class FrozenEvent(EventBase): def __repr__(self): return "" % ( - self.get("event_id", None), - self.get("type", None), - self.get("state_key", None), + self.event_id, + self.type, + getattr(self, "state_key", None), ) @@ -461,8 +443,8 @@ class FrozenEventV2(EventBase): return "<%s event_id=%r, type=%r, state_key=%r>" % ( self.__class__.__name__, self.event_id, - self.get("type", None), - self.get("state_key", None), + self.type, + self.state_key if self.is_state() else None, ) diff --git a/synapse/federation/federation_base.py b/synapse/federation/federation_base.py index 949dcd4614..a6471ce6cc 100644 --- a/synapse/federation/federation_base.py +++ b/synapse/federation/federation_base.py @@ -90,9 +90,7 @@ class FederationBase: # received event was probably a redacted copy (but we then use our # *actual* redacted copy to be on the safe side.) redacted_event = prune_event(pdu) - if set(redacted_event.keys()) == set(pdu.keys()) and set( - redacted_event.content.keys() - ) == set(pdu.content.keys()): + if set(redacted_event.content.keys()) == set(pdu.content.keys()): logger.info( "Event %s seems to have been redacted; using our redacted " "copy", diff --git a/synapse/handlers/message.py b/synapse/handlers/message.py index 49f8aa25ea..a9364670a1 100644 --- a/synapse/handlers/message.py +++ b/synapse/handlers/message.py @@ -1401,7 +1401,7 @@ class EventCreationHandler: ] for k in immutable_fields: - if getattr(builder, k, None) != original_event.get(k): + if getattr(builder, k, None) != getattr(original_event, k, None): raise Exception( "Third party rules module created an invalid event: " "cannot change field " + k diff --git a/synapse/handlers/room.py b/synapse/handlers/room.py index 5a888b7941..88e9d0e2fe 100644 --- a/synapse/handlers/room.py +++ b/synapse/handlers/room.py @@ -475,7 +475,7 @@ class RoomCreationHandler(BaseHandler): ): await self.room_member_handler.update_membership( requester, - UserID.from_string(old_event["state_key"]), + UserID.from_string(old_event.state_key), new_room_id, "ban", ratelimit=False, diff --git a/synapse/notifier.py b/synapse/notifier.py index b9531007e2..4787ea438e 100644 --- a/synapse/notifier.py +++ b/synapse/notifier.py @@ -277,7 +277,7 @@ class Notifier: event_pos=event_pos, room_id=event.room_id, event_type=event.type, - state_key=event.get("state_key"), + state_key=getattr(event, "state_key", None), membership=event.content.get("membership"), max_room_stream_token=max_room_stream_token, extra_users=extra_users or [], diff --git a/synapse/push/push_rule_evaluator.py b/synapse/push/push_rule_evaluator.py index 49ecb38522..fa5985894c 100644 --- a/synapse/push/push_rule_evaluator.py +++ b/synapse/push/push_rule_evaluator.py @@ -125,7 +125,7 @@ class PushRuleEvaluatorForEvent: self._power_levels = power_levels # Maps strings of e.g. 'content.body' -> event["content"]["body"] - self._value_cache = _flatten_dict(event) + self._value_cache = _flatten_dict(event.get_dict()) def matches( self, condition: Dict[str, Any], user_id: str, display_name: str @@ -271,7 +271,7 @@ def _re_word_boundary(r: str) -> str: def _flatten_dict( - d: Union[EventBase, dict], + d: dict, prefix: Optional[List[str]] = None, result: Optional[Dict[str, str]] = None, ) -> Dict[str, str]: -- cgit 1.5.1 From 3d937d23fdbe29b6f5939403a238521641a78ec8 Mon Sep 17 00:00:00 2001 From: Erik Johnston Date: Wed, 5 May 2021 13:52:41 +0100 Subject: Don't use DictProperty --- synapse/events/__init__.py | 29 +++++++++++++++-------------- synapse/handlers/message.py | 4 ++-- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/synapse/events/__init__.py b/synapse/events/__init__.py index 46d26e0af9..7a598a8193 100644 --- a/synapse/events/__init__.py +++ b/synapse/events/__init__.py @@ -230,21 +230,22 @@ class EventBase(metaclass=abc.ABCMeta): self._dict = event_dict - self.internal_metadata = _EventInternalMetadata(internal_metadata_dict) + self.auth_events = event_dict["auth_events"] + self.depth = event_dict["depth"] + self.content = event_dict["content"] + self.hashes = event_dict["hashes"] + self.origin = event_dict["origin"] + self.origin_server_ts = event_dict["origin_server_ts"] + self.prev_events = event_dict["prev_events"] + self.redacts = event_dict.get("redacts") + self.room_id = event_dict["room_id"] + self.sender = event_dict["sender"] + self.type = event_dict["type"] + self.user_id = event_dict["sender"] + if "state_key" in event_dict: + self.state_key = event_dict["state_key"] - auth_events = DictProperty("auth_events") - depth = DictProperty("depth") - content = DictProperty("content") - hashes = DictProperty("hashes") - origin = DictProperty("origin") - origin_server_ts = DictProperty("origin_server_ts") - prev_events = DictProperty("prev_events") - redacts = DefaultDictProperty("redacts", None) - room_id = DictProperty("room_id") - sender = DictProperty("sender") - state_key = DictProperty("state_key") - type = DictProperty("type") - user_id = DictProperty("sender") + self.internal_metadata = _EventInternalMetadata(internal_metadata_dict) @property def event_id(self) -> str: diff --git a/synapse/handlers/message.py b/synapse/handlers/message.py index a9364670a1..d4684755bc 100644 --- a/synapse/handlers/message.py +++ b/synapse/handlers/message.py @@ -1108,7 +1108,7 @@ class EventCreationHandler: # it's not a self-redaction (to avoid having to look up whether the # user is actually admin or not). is_admin_redaction = False - if event.type == EventTypes.Redaction: + if event.type == EventTypes.Redaction and event.redacts: original_event = await self.store.get_event( event.redacts, redact_behaviour=EventRedactBehaviour.AS_IS, @@ -1195,7 +1195,7 @@ class EventCreationHandler: # TODO: Make sure the signatures actually are correct. event.signatures.update(returned_invite.signatures) - if event.type == EventTypes.Redaction: + if event.type == EventTypes.Redaction and event.redacts: original_event = await self.store.get_event( event.redacts, redact_behaviour=EventRedactBehaviour.AS_IS, -- cgit 1.5.1 From 7e7b99bca9da9bb5c8ba16aec51eef114c084561 Mon Sep 17 00:00:00 2001 From: Erik Johnston Date: Wed, 5 May 2021 15:02:35 +0100 Subject: Slots --- synapse/events/__init__.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/synapse/events/__init__.py b/synapse/events/__init__.py index 7a598a8193..baae3be69c 100644 --- a/synapse/events/__init__.py +++ b/synapse/events/__init__.py @@ -206,6 +206,28 @@ class _EventInternalMetadata: class EventBase(metaclass=abc.ABCMeta): + __slots__ = [ + "room_version", + "signatures", + "unsigned", + "rejected_reason", + "_dict", + "auth_events", + "depth", + "content", + "hashes", + "origin", + "origin_server_ts", + "prev_events", + "redacts", + "room_id", + "sender", + "type", + "user_id", + "state_key", + "internal_metadata", + ] + @property @abc.abstractmethod def format_version(self) -> int: @@ -364,6 +386,8 @@ class FrozenEvent(EventBase): class FrozenEventV2(EventBase): + __slots__ = ["_event_id"] + format_version = EventFormatVersions.V2 # All events of this type are V2 def __init__( @@ -452,6 +476,8 @@ class FrozenEventV2(EventBase): class FrozenEventV3(FrozenEventV2): """FrozenEventV3, which differs from FrozenEventV2 only in the event_id format""" + __slots__ = ["_event_id"] + format_version = EventFormatVersions.V3 # All events of this type are V3 @property -- cgit 1.5.1 From ec1c2c69a23c2ad08b17bb2c45168f6ed69ba63c Mon Sep 17 00:00:00 2001 From: Erik Johnston Date: Wed, 5 May 2021 14:16:41 +0100 Subject: Encode json dict --- synapse/events/__init__.py | 34 ++++++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/synapse/events/__init__.py b/synapse/events/__init__.py index baae3be69c..5a443dec09 100644 --- a/synapse/events/__init__.py +++ b/synapse/events/__init__.py @@ -16,12 +16,14 @@ import abc import os +import zlib from typing import Dict, Optional, Tuple, Type from unpaddedbase64 import encode_base64 from synapse.api.room_versions import EventFormatVersions, RoomVersion, RoomVersions from synapse.types import JsonDict, RoomStreamToken +from synapse.util import json_decoder, json_encoder from synapse.util.caches import intern_dict from synapse.util.frozenutils import freeze from synapse.util.stringutils import strtobool @@ -37,6 +39,26 @@ from synapse.util.stringutils import strtobool USE_FROZEN_DICTS = strtobool(os.environ.get("SYNAPSE_USE_FROZEN_DICTS", "0")) +_PRESET_ZDICT = b""""auth_events":[],"prev_events":[],"type":"m.room.create","room_id":,"sender":,"content":"room_version":"creator":"depth":"prev_state":"state_key":""origin":"origin_server_ts":"hashes":{"sha256":"signatures":,"unsigned":{"age_ts":""" + + +def _encode_dict(d: JsonDict) -> bytes: + json_bytes = json_encoder.encode(d).encode("utf-8") + c = zlib.compressobj(1, zdict=_PRESET_ZDICT) + result_bytes = c.compress(json_bytes) + result_bytes += c.flush() + return result_bytes + + +def _decode_dict(b: bytes) -> JsonDict: + d = zlib.decompressobj(zdict=_PRESET_ZDICT) + + result_bytes = d.decompress(b) + result_bytes += d.flush() + + return json_decoder.decode(result_bytes.decode("utf-8")) + + class DictProperty: """An object property which delegates to the `_dict` within its parent object.""" @@ -211,11 +233,11 @@ class EventBase(metaclass=abc.ABCMeta): "signatures", "unsigned", "rejected_reason", - "_dict", + "_encoded_dict", "auth_events", "depth", - "content", - "hashes", + "_content", + "_hashes", "origin", "origin_server_ts", "prev_events", @@ -250,7 +272,7 @@ class EventBase(metaclass=abc.ABCMeta): self.unsigned = unsigned self.rejected_reason = rejected_reason - self._dict = event_dict + self._encoded_dict = _encode_dict(event_dict) self.auth_events = event_dict["auth_events"] self.depth = event_dict["depth"] @@ -281,7 +303,7 @@ class EventBase(metaclass=abc.ABCMeta): return hasattr(self, "state_key") and self.state_key is not None def get_dict(self) -> JsonDict: - d = dict(self._dict) + d = _decode_dict(self._encoded_dict) d.update({"signatures": self.signatures, "unsigned": dict(self.unsigned)}) return d @@ -324,7 +346,7 @@ class EventBase(metaclass=abc.ABCMeta): """'Freeze' the event dict, so it cannot be modified by accident""" # this will be a no-op if the event dict is already frozen. - self._dict = freeze(self._dict) + # self._dict = freeze(self._dict) class FrozenEvent(EventBase): -- cgit 1.5.1 From f4bb01d41a2e3fdbf0b1f5646d2ae0b0e287c3aa Mon Sep 17 00:00:00 2001 From: Erik Johnston Date: Wed, 5 May 2021 15:02:40 +0100 Subject: Compress --- synapse/events/__init__.py | 43 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 37 insertions(+), 6 deletions(-) diff --git a/synapse/events/__init__.py b/synapse/events/__init__.py index 5a443dec09..ca66dc457a 100644 --- a/synapse/events/__init__.py +++ b/synapse/events/__init__.py @@ -15,9 +15,10 @@ # limitations under the License. import abc +import attr import os import zlib -from typing import Dict, Optional, Tuple, Type +from typing import Dict, Optional, Tuple, Type, Union from unpaddedbase64 import encode_base64 @@ -39,7 +40,7 @@ from synapse.util.stringutils import strtobool USE_FROZEN_DICTS = strtobool(os.environ.get("SYNAPSE_USE_FROZEN_DICTS", "0")) -_PRESET_ZDICT = b""""auth_events":[],"prev_events":[],"type":"m.room.create","room_id":,"sender":,"content":"room_version":"creator":"depth":"prev_state":"state_key":""origin":"origin_server_ts":"hashes":{"sha256":"signatures":,"unsigned":{"age_ts":""" +_PRESET_ZDICT = b"""{"auth_events":[],"prev_events":[],"type":"m.room.member",m.room.message"room_id":,"sender":,"content":{"msgtype":"m.text","body":""room_version":"creator":"depth":"prev_state":"state_key":""origin":"origin_server_ts":"hashes":{"sha256":"signatures":,"unsigned":{"age_ts":"ed25519""" def _encode_dict(d: JsonDict) -> bytes: @@ -227,6 +228,28 @@ class _EventInternalMetadata: return self._dict.get("redacted", False) +@attr.s(slots=True, auto_attribs=True) +class _Signatures: + _signatures_bytes: bytes + + @staticmethod + def from_dict(signature_dict: JsonDict) -> "_Signatures": + return _Signatures(_encode_dict(signature_dict)) + + def get_dict(self) -> JsonDict: + return _decode_dict(self._signatures_bytes) + + def update(self, other: Union[JsonDict, "_Signatures"]): + if isinstance(other, _Signatures): + other_dict = _decode_dict(other) + else: + other_dict = other + + signatures = self.get_dict() + signatures.update(other_dict) + self._signatures_bytes = _encode_dict(self._signatures_bytes) + + class EventBase(metaclass=abc.ABCMeta): __slots__ = [ "room_version", @@ -268,7 +291,7 @@ class EventBase(metaclass=abc.ABCMeta): assert room_version.event_format == self.format_version self.room_version = room_version - self.signatures = signatures + self.signatures = _Signatures.from_dict(signatures) self.unsigned = unsigned self.rejected_reason = rejected_reason @@ -276,8 +299,6 @@ class EventBase(metaclass=abc.ABCMeta): self.auth_events = event_dict["auth_events"] self.depth = event_dict["depth"] - self.content = event_dict["content"] - self.hashes = event_dict["hashes"] self.origin = event_dict["origin"] self.origin_server_ts = event_dict["origin_server_ts"] self.prev_events = event_dict["prev_events"] @@ -291,6 +312,14 @@ class EventBase(metaclass=abc.ABCMeta): self.internal_metadata = _EventInternalMetadata(internal_metadata_dict) + @property + def content(self) -> JsonDict: + return self.get_dict()["content"] + + @property + def hashes(self) -> JsonDict: + return self.get_dict()["hashes"] + @property def event_id(self) -> str: raise NotImplementedError() @@ -304,7 +333,9 @@ class EventBase(metaclass=abc.ABCMeta): def get_dict(self) -> JsonDict: d = _decode_dict(self._encoded_dict) - d.update({"signatures": self.signatures, "unsigned": dict(self.unsigned)}) + d.update( + {"signatures": self.signatures.get_dict(), "unsigned": dict(self.unsigned)} + ) return d -- cgit 1.5.1 From faa7d48930d1c5c92d78d4863a385e9c0974fe42 Mon Sep 17 00:00:00 2001 From: Erik Johnston Date: Wed, 5 May 2021 16:35:16 +0100 Subject: More ensmalling --- synapse/events/__init__.py | 119 +++++++++++++++++++++++++++----------------- synapse/events/validator.py | 4 +- 2 files changed, 75 insertions(+), 48 deletions(-) diff --git a/synapse/events/__init__.py b/synapse/events/__init__.py index ca66dc457a..c04905dfed 100644 --- a/synapse/events/__init__.py +++ b/synapse/events/__init__.py @@ -15,12 +15,12 @@ # limitations under the License. import abc -import attr import os import zlib -from typing import Dict, Optional, Tuple, Type, Union +from typing import Dict, List, Optional, Tuple, Type, Union -from unpaddedbase64 import encode_base64 +import attr +from unpaddedbase64 import decode_base64, encode_base64 from synapse.api.room_versions import EventFormatVersions, RoomVersion, RoomVersions from synapse.types import JsonDict, RoomStreamToken @@ -239,15 +239,46 @@ class _Signatures: def get_dict(self) -> JsonDict: return _decode_dict(self._signatures_bytes) + def get(self, server_name): + return self.get_dict().get(server_name) + def update(self, other: Union[JsonDict, "_Signatures"]): if isinstance(other, _Signatures): - other_dict = _decode_dict(other) + other_dict = _decode_dict(other._signatures_bytes) else: other_dict = other signatures = self.get_dict() signatures.update(other_dict) - self._signatures_bytes = _encode_dict(self._signatures_bytes) + self._signatures_bytes = _encode_dict(signatures) + + +class _SmallListV1(str): + __slots__ = [] + + def get(self): + return self.split(",") + + @staticmethod + def create(event_ids): + return _SmallListV1(",".join(event_ids)) + + +class _SmallListV2_V3(bytes): + __slots__ = [] + + def get(self, url_safe): + i = 0 + while i * 32 < len(self): + bit = self[i * 32 : (i + 1) * 32] + i += 1 + yield "$" + encode_base64(bit, urlsafe=url_safe) + + @staticmethod + def create(event_ids): + return _SmallListV2_V3( + b"".join(decode_base64(event_id[1:]) for event_id in event_ids) + ) class EventBase(metaclass=abc.ABCMeta): @@ -257,18 +288,17 @@ class EventBase(metaclass=abc.ABCMeta): "unsigned", "rejected_reason", "_encoded_dict", - "auth_events", + "_auth_event_ids", "depth", "_content", "_hashes", "origin", "origin_server_ts", - "prev_events", + "_prev_event_ids", "redacts", "room_id", "sender", "type", - "user_id", "state_key", "internal_metadata", ] @@ -297,16 +327,13 @@ class EventBase(metaclass=abc.ABCMeta): self._encoded_dict = _encode_dict(event_dict) - self.auth_events = event_dict["auth_events"] self.depth = event_dict["depth"] self.origin = event_dict["origin"] self.origin_server_ts = event_dict["origin_server_ts"] - self.prev_events = event_dict["prev_events"] self.redacts = event_dict.get("redacts") self.room_id = event_dict["room_id"] self.sender = event_dict["sender"] self.type = event_dict["type"] - self.user_id = event_dict["sender"] if "state_key" in event_dict: self.state_key = event_dict["state_key"] @@ -320,10 +347,18 @@ class EventBase(metaclass=abc.ABCMeta): def hashes(self) -> JsonDict: return self.get_dict()["hashes"] + @property + def prev_events(self) -> List[str]: + return list(self._prev_events) + @property def event_id(self) -> str: raise NotImplementedError() + @property + def user_id(self) -> str: + return self.sender + @property def membership(self): return self.content["membership"] @@ -355,24 +390,6 @@ class EventBase(metaclass=abc.ABCMeta): def __set__(self, instance, value): raise AttributeError("Unrecognized attribute %s" % (instance,)) - def prev_event_ids(self): - """Returns the list of prev event IDs. The order matches the order - specified in the event, though there is no meaning to it. - - Returns: - list[str]: The list of event IDs of this event's prev_events - """ - return [e for e, _ in self.prev_events] - - def auth_event_ids(self): - """Returns the list of auth event IDs. The order matches the order - specified in the event, though there is no meaning to it. - - Returns: - list[str]: The list of event IDs of this event's auth_events - """ - return [e for e, _ in self.auth_events] - def freeze(self): """'Freeze' the event dict, so it cannot be modified by accident""" @@ -413,6 +430,12 @@ class FrozenEvent(EventBase): frozen_dict = event_dict self._event_id = event_dict["event_id"] + self._auth_event_ids = _SmallListV1.create( + e for e, _ in event_dict["auth_events"] + ) + self._prev_event_ids = _SmallListV1.create( + e for e, _ in event_dict["prev_events"] + ) super().__init__( frozen_dict, @@ -427,6 +450,12 @@ class FrozenEvent(EventBase): def event_id(self) -> str: return self._event_id + def auth_event_ids(self): + return list(self._auth_event_ids.get()) + + def prev_event_ids(self): + return list(self._prev_event_ids.get()) + def __str__(self): return self.__repr__() @@ -475,6 +504,8 @@ class FrozenEventV2(EventBase): frozen_dict = event_dict self._event_id = None + self._auth_event_ids = _SmallListV2_V3.create(event_dict["auth_events"]) + self._prev_event_ids = _SmallListV2_V3.create(event_dict["prev_events"]) super().__init__( frozen_dict, @@ -496,24 +527,6 @@ class FrozenEventV2(EventBase): self._event_id = "$" + encode_base64(compute_event_reference_hash(self)[1]) return self._event_id - def prev_event_ids(self): - """Returns the list of prev event IDs. The order matches the order - specified in the event, though there is no meaning to it. - - Returns: - list[str]: The list of event IDs of this event's prev_events - """ - return self.prev_events - - def auth_event_ids(self): - """Returns the list of auth event IDs. The order matches the order - specified in the event, though there is no meaning to it. - - Returns: - list[str]: The list of event IDs of this event's auth_events - """ - return self.auth_events - def __str__(self): return self.__repr__() @@ -525,6 +538,12 @@ class FrozenEventV2(EventBase): self.state_key if self.is_state() else None, ) + def auth_event_ids(self): + return list(self._auth_event_ids.get(False)) + + def prev_event_ids(self): + return list(self._prev_event_ids.get(False)) + class FrozenEventV3(FrozenEventV2): """FrozenEventV3, which differs from FrozenEventV2 only in the event_id format""" @@ -546,6 +565,12 @@ class FrozenEventV3(FrozenEventV2): ) return self._event_id + def auth_event_ids(self): + return list(self._auth_event_ids.get(True)) + + def prev_event_ids(self): + return list(self._prev_event_ids.get(True)) + def _event_type_from_format_version(format_version: int) -> Type[EventBase]: """Returns the python type to use to construct an Event object for the diff --git a/synapse/events/validator.py b/synapse/events/validator.py index fa6987d7cb..47a74fd5a3 100644 --- a/synapse/events/validator.py +++ b/synapse/events/validator.py @@ -38,6 +38,8 @@ class EventValidator: if event.format_version == EventFormatVersions.V1: EventID.from_string(event.event_id) + event_dict = event.get_dict() + required = [ "auth_events", "content", @@ -49,7 +51,7 @@ class EventValidator: ] for k in required: - if not hasattr(event, k): + if k not in event_dict: raise SynapseError(400, "Event does not have key %s" % (k,)) # Check that the following keys have string values -- cgit 1.5.1