mirror of
https://mau.dev/maunium/synapse.git
synced 2024-08-22 18:25:34 +00:00
![Richard van der Hoff](/assets/img/avatar_default.png)
... and use it in places where it's trivial to do so. This will make it easier to pass room versions into the FrozenEvent constructors.
442 lines
14 KiB
Python
442 lines
14 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright 2014-2016 OpenMarket Ltd
|
|
# Copyright 2019 New Vector Ltd
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import os
|
|
from distutils.util import strtobool
|
|
from typing import Optional, Type
|
|
|
|
import six
|
|
|
|
from unpaddedbase64 import encode_base64
|
|
|
|
from synapse.api.room_versions import EventFormatVersions, RoomVersion, RoomVersions
|
|
from synapse.types import JsonDict
|
|
from synapse.util.caches import intern_dict
|
|
from synapse.util.frozenutils import freeze
|
|
|
|
# Whether we should use frozen_dict in FrozenEvent. Using frozen_dicts prevents
|
|
# bugs where we accidentally share e.g. signature dicts. However, converting a
|
|
# dict to frozen_dicts is expensive.
|
|
#
|
|
# NOTE: This is overridden by the configuration by the Synapse worker apps, but
|
|
# for the sake of tests, it is set here while it cannot be configured on the
|
|
# homeserver object itself.
|
|
USE_FROZEN_DICTS = strtobool(os.environ.get("SYNAPSE_USE_FROZEN_DICTS", "0"))
|
|
|
|
|
|
class _EventInternalMetadata(object):
|
|
def __init__(self, internal_metadata_dict):
|
|
self.__dict__ = dict(internal_metadata_dict)
|
|
|
|
def get_dict(self):
|
|
return dict(self.__dict__)
|
|
|
|
def is_outlier(self):
|
|
return getattr(self, "outlier", False)
|
|
|
|
def is_out_of_band_membership(self):
|
|
"""Whether this is an out of band membership, like an invite or an invite
|
|
rejection. This is needed as those events are marked as outliers, but
|
|
they still need to be processed as if they're new events (e.g. updating
|
|
invite state in the database, relaying to clients, etc).
|
|
"""
|
|
return getattr(self, "out_of_band_membership", False)
|
|
|
|
def get_send_on_behalf_of(self):
|
|
"""Whether this server should send the event on behalf of another server.
|
|
This is used by the federation "send_join" API to forward the initial join
|
|
event for a server in the room.
|
|
|
|
returns a str with the name of the server this event is sent on behalf of.
|
|
"""
|
|
return getattr(self, "send_on_behalf_of", None)
|
|
|
|
def need_to_check_redaction(self):
|
|
"""Whether the redaction event needs to be rechecked when fetching
|
|
from the database.
|
|
|
|
Starting in room v3 redaction events are accepted up front, and later
|
|
checked to see if the redacter and redactee's domains match.
|
|
|
|
If the sender of the redaction event is allowed to redact any event
|
|
due to auth rules, then this will always return false.
|
|
|
|
Returns:
|
|
bool
|
|
"""
|
|
return getattr(self, "recheck_redaction", False)
|
|
|
|
def is_soft_failed(self):
|
|
"""Whether the event has been soft failed.
|
|
|
|
Soft failed events should be handled as usual, except:
|
|
1. They should not go down sync or event streams, or generally
|
|
sent to clients.
|
|
2. They should not be added to the forward extremities (and
|
|
therefore not to current state).
|
|
|
|
Returns:
|
|
bool
|
|
"""
|
|
return getattr(self, "soft_failed", False)
|
|
|
|
def should_proactively_send(self):
|
|
"""Whether the event, if ours, should be sent to other clients and
|
|
servers.
|
|
|
|
This is used for sending dummy events internally. Servers and clients
|
|
can still explicitly fetch the event.
|
|
|
|
Returns:
|
|
bool
|
|
"""
|
|
return getattr(self, "proactively_send", True)
|
|
|
|
def is_redacted(self):
|
|
"""Whether the event has been redacted.
|
|
|
|
This is used for efficiently checking whether an event has been
|
|
marked as redacted without needing to make another database call.
|
|
|
|
Returns:
|
|
bool
|
|
"""
|
|
return getattr(self, "redacted", False)
|
|
|
|
|
|
_SENTINEL = object()
|
|
|
|
|
|
def _event_dict_property(key, default=_SENTINEL):
|
|
"""Creates a new property for the given key that delegates access to
|
|
`self._event_dict`.
|
|
|
|
The default is used if the key is missing from the `_event_dict`, if given,
|
|
otherwise an AttributeError will be raised.
|
|
|
|
Note: If a default is given then `hasattr` will always return true.
|
|
"""
|
|
|
|
# We want to be able to use hasattr with the event dict properties.
|
|
# However, (on python3) hasattr expects AttributeError to be raised. Hence,
|
|
# we need to transform the KeyError into an AttributeError
|
|
|
|
def getter_raises(self):
|
|
try:
|
|
return self._event_dict[key]
|
|
except KeyError:
|
|
raise AttributeError(key)
|
|
|
|
def getter_default(self):
|
|
return self._event_dict.get(key, default)
|
|
|
|
def setter(self, v):
|
|
try:
|
|
self._event_dict[key] = v
|
|
except KeyError:
|
|
raise AttributeError(key)
|
|
|
|
def delete(self):
|
|
try:
|
|
del self._event_dict[key]
|
|
except KeyError:
|
|
raise AttributeError(key)
|
|
|
|
if default is _SENTINEL:
|
|
# No default given, so use the getter that raises
|
|
return property(getter_raises, setter, delete)
|
|
else:
|
|
return property(getter_default, setter, delete)
|
|
|
|
|
|
class EventBase(object):
|
|
def __init__(
|
|
self,
|
|
event_dict,
|
|
signatures={},
|
|
unsigned={},
|
|
internal_metadata_dict={},
|
|
rejected_reason=None,
|
|
):
|
|
self.signatures = signatures
|
|
self.unsigned = unsigned
|
|
self.rejected_reason = rejected_reason
|
|
|
|
self._event_dict = event_dict
|
|
|
|
self.internal_metadata = _EventInternalMetadata(internal_metadata_dict)
|
|
|
|
auth_events = _event_dict_property("auth_events")
|
|
depth = _event_dict_property("depth")
|
|
content = _event_dict_property("content")
|
|
hashes = _event_dict_property("hashes")
|
|
origin = _event_dict_property("origin")
|
|
origin_server_ts = _event_dict_property("origin_server_ts")
|
|
prev_events = _event_dict_property("prev_events")
|
|
redacts = _event_dict_property("redacts", None)
|
|
room_id = _event_dict_property("room_id")
|
|
sender = _event_dict_property("sender")
|
|
state_key = _event_dict_property("state_key")
|
|
type = _event_dict_property("type")
|
|
user_id = _event_dict_property("sender")
|
|
|
|
@property
|
|
def event_id(self) -> str:
|
|
raise NotImplementedError()
|
|
|
|
@property
|
|
def membership(self):
|
|
return self.content["membership"]
|
|
|
|
def is_state(self):
|
|
return hasattr(self, "state_key") and self.state_key is not None
|
|
|
|
def get_dict(self) -> JsonDict:
|
|
d = dict(self._event_dict)
|
|
d.update({"signatures": self.signatures, "unsigned": dict(self.unsigned)})
|
|
|
|
return d
|
|
|
|
def get(self, key, default=None):
|
|
return self._event_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()
|
|
|
|
if time_now is not None and "age_ts" in pdu_json["unsigned"]:
|
|
age = time_now - pdu_json["unsigned"]["age_ts"]
|
|
pdu_json.setdefault("unsigned", {})["age"] = int(age)
|
|
del pdu_json["unsigned"]["age_ts"]
|
|
|
|
# This may be a frozen event
|
|
pdu_json["unsigned"].pop("redacted_because", None)
|
|
|
|
return pdu_json
|
|
|
|
def __set__(self, instance, value):
|
|
raise AttributeError("Unrecognized attribute %s" % (instance,))
|
|
|
|
def __getitem__(self, field):
|
|
return self._event_dict[field]
|
|
|
|
def __contains__(self, field):
|
|
return field in self._event_dict
|
|
|
|
def items(self):
|
|
return list(self._event_dict.items())
|
|
|
|
def keys(self):
|
|
return six.iterkeys(self._event_dict)
|
|
|
|
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]
|
|
|
|
|
|
class FrozenEvent(EventBase):
|
|
format_version = EventFormatVersions.V1 # All events of this type are V1
|
|
|
|
def __init__(self, event_dict, internal_metadata_dict={}, rejected_reason=None):
|
|
event_dict = dict(event_dict)
|
|
|
|
# Signatures is a dict of dicts, and this is faster than doing a
|
|
# copy.deepcopy
|
|
signatures = {
|
|
name: {sig_id: sig for sig_id, sig in sigs.items()}
|
|
for name, sigs in event_dict.pop("signatures", {}).items()
|
|
}
|
|
|
|
unsigned = dict(event_dict.pop("unsigned", {}))
|
|
|
|
# We intern these strings because they turn up a lot (especially when
|
|
# caching).
|
|
event_dict = intern_dict(event_dict)
|
|
|
|
if USE_FROZEN_DICTS:
|
|
frozen_dict = freeze(event_dict)
|
|
else:
|
|
frozen_dict = event_dict
|
|
|
|
self._event_id = event_dict["event_id"]
|
|
|
|
super(FrozenEvent, self).__init__(
|
|
frozen_dict,
|
|
signatures=signatures,
|
|
unsigned=unsigned,
|
|
internal_metadata_dict=internal_metadata_dict,
|
|
rejected_reason=rejected_reason,
|
|
)
|
|
|
|
@property
|
|
def event_id(self) -> str:
|
|
return self._event_id
|
|
|
|
def __str__(self):
|
|
return self.__repr__()
|
|
|
|
def __repr__(self):
|
|
return "<FrozenEvent event_id='%s', type='%s', state_key='%s'>" % (
|
|
self.get("event_id", None),
|
|
self.get("type", None),
|
|
self.get("state_key", None),
|
|
)
|
|
|
|
|
|
class FrozenEventV2(EventBase):
|
|
format_version = EventFormatVersions.V2 # All events of this type are V2
|
|
|
|
def __init__(self, event_dict, internal_metadata_dict={}, rejected_reason=None):
|
|
event_dict = dict(event_dict)
|
|
|
|
# Signatures is a dict of dicts, and this is faster than doing a
|
|
# copy.deepcopy
|
|
signatures = {
|
|
name: {sig_id: sig for sig_id, sig in sigs.items()}
|
|
for name, sigs in event_dict.pop("signatures", {}).items()
|
|
}
|
|
|
|
assert "event_id" not in event_dict
|
|
|
|
unsigned = dict(event_dict.pop("unsigned", {}))
|
|
|
|
# We intern these strings because they turn up a lot (especially when
|
|
# caching).
|
|
event_dict = intern_dict(event_dict)
|
|
|
|
if USE_FROZEN_DICTS:
|
|
frozen_dict = freeze(event_dict)
|
|
else:
|
|
frozen_dict = event_dict
|
|
|
|
self._event_id = None
|
|
|
|
super(FrozenEventV2, self).__init__(
|
|
frozen_dict,
|
|
signatures=signatures,
|
|
unsigned=unsigned,
|
|
internal_metadata_dict=internal_metadata_dict,
|
|
rejected_reason=rejected_reason,
|
|
)
|
|
|
|
@property
|
|
def event_id(self):
|
|
# We have to import this here as otherwise we get an import loop which
|
|
# is hard to break.
|
|
from synapse.crypto.event_signing import compute_event_reference_hash
|
|
|
|
if self._event_id:
|
|
return self._event_id
|
|
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__()
|
|
|
|
def __repr__(self):
|
|
return "<%s event_id='%s', type='%s', state_key='%s'>" % (
|
|
self.__class__.__name__,
|
|
self.event_id,
|
|
self.get("type", None),
|
|
self.get("state_key", None),
|
|
)
|
|
|
|
|
|
class FrozenEventV3(FrozenEventV2):
|
|
"""FrozenEventV3, which differs from FrozenEventV2 only in the event_id format"""
|
|
|
|
format_version = EventFormatVersions.V3 # All events of this type are V3
|
|
|
|
@property
|
|
def event_id(self):
|
|
# We have to import this here as otherwise we get an import loop which
|
|
# is hard to break.
|
|
from synapse.crypto.event_signing import compute_event_reference_hash
|
|
|
|
if self._event_id:
|
|
return self._event_id
|
|
self._event_id = "$" + encode_base64(
|
|
compute_event_reference_hash(self)[1], urlsafe=True
|
|
)
|
|
return self._event_id
|
|
|
|
|
|
def event_type_from_format_version(format_version: int) -> Type[EventBase]:
|
|
"""Returns the python type to use to construct an Event object for the
|
|
given event format version.
|
|
|
|
Args:
|
|
format_version (int): The event format version
|
|
|
|
Returns:
|
|
type: A type that can be initialized as per the initializer of
|
|
`FrozenEvent`
|
|
"""
|
|
|
|
if format_version == EventFormatVersions.V1:
|
|
return FrozenEvent
|
|
elif format_version == EventFormatVersions.V2:
|
|
return FrozenEventV2
|
|
elif format_version == EventFormatVersions.V3:
|
|
return FrozenEventV3
|
|
else:
|
|
raise Exception("No event format %r" % (format_version,))
|
|
|
|
|
|
def make_event_from_dict(
|
|
event_dict: JsonDict,
|
|
room_version: RoomVersion = RoomVersions.V1,
|
|
internal_metadata_dict: JsonDict = {},
|
|
rejected_reason: Optional[str] = None,
|
|
) -> EventBase:
|
|
"""Construct an EventBase from the given event dict"""
|
|
event_type = event_type_from_format_version(room_version.event_format)
|
|
return event_type(event_dict, internal_metadata_dict, rejected_reason)
|