synapse-product/synapse/events/__init__.py

281 lines
8.7 KiB
Python
Raw Normal View History

2014-12-02 06:40:22 -05:00
# -*- coding: utf-8 -*-
2016-01-06 23:26:29 -05:00
# Copyright 2014-2016 OpenMarket Ltd
2014-12-02 06:40:22 -05:00
#
# 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
import six
from synapse.api.constants import (
KNOWN_EVENT_FORMAT_VERSIONS,
KNOWN_ROOM_VERSIONS,
EventFormatVersions,
)
2016-03-23 12:13:05 -04:00
from synapse.util.caches import intern_dict
2018-07-09 02:09:20 -04:00
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"))
2014-12-02 06:40:22 -05:00
class _EventInternalMetadata(object):
def __init__(self, internal_metadata_dict):
self.__dict__ = dict(internal_metadata_dict)
2014-12-02 06:40:22 -05:00
def get_dict(self):
return dict(self.__dict__)
2014-12-10 07:00:05 -05:00
def is_outlier(self):
return getattr(self, "outlier", False)
2014-12-10 07:00:05 -05:00
def is_out_of_band_membership(self):
"""Whether this is an out of band membership, like an invite or an invite
2019-01-23 15:05:44 -05:00
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).
2019-01-23 15:05:44 -05:00
"""
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)
2014-12-02 06:40:22 -05:00
2014-12-03 11:07:21 -05:00
def _event_dict_property(key):
2018-04-30 03:49:10 -04:00
# 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
2014-12-16 10:24:03 -05:00
def getter(self):
try:
return self._event_dict[key]
except KeyError:
raise AttributeError(key)
2014-12-02 06:40:22 -05:00
2014-12-16 10:24:03 -05:00
def setter(self, v):
try:
self._event_dict[key] = v
except KeyError:
raise AttributeError(key)
2014-12-02 06:40:22 -05:00
2014-12-16 10:24:03 -05:00
def delete(self):
try:
del self._event_dict[key]
except KeyError:
raise AttributeError(key)
2014-12-02 06:40:22 -05:00
2014-12-16 10:24:03 -05:00
return property(
getter,
setter,
delete,
)
2014-12-02 06:40:22 -05:00
2014-12-03 11:07:21 -05:00
class EventBase(object):
def __init__(self, event_dict, signatures={}, unsigned={},
internal_metadata_dict={}, rejected_reason=None):
2015-01-06 13:51:03 -05:00
self.signatures = signatures
self.unsigned = unsigned
self.rejected_reason = rejected_reason
2014-12-02 06:40:22 -05:00
2015-01-06 13:51:03 -05:00
self._event_dict = event_dict
2014-12-02 06:40:22 -05:00
2014-12-03 11:07:21 -05:00
self.internal_metadata = _EventInternalMetadata(
internal_metadata_dict
)
2014-12-02 06:40:22 -05:00
2014-12-03 11:07:21 -05:00
auth_events = _event_dict_property("auth_events")
depth = _event_dict_property("depth")
2014-12-03 11:07:21 -05:00
content = _event_dict_property("content")
hashes = _event_dict_property("hashes")
origin = _event_dict_property("origin")
origin_server_ts = _event_dict_property("origin_server_ts")
2014-12-03 11:07:21 -05:00
prev_events = _event_dict_property("prev_events")
prev_state = _event_dict_property("prev_state")
2014-12-11 08:25:19 -05:00
redacts = _event_dict_property("redacts")
2014-12-03 11:07:21 -05:00
room_id = _event_dict_property("room_id")
sender = _event_dict_property("sender")
user_id = _event_dict_property("sender")
2014-12-02 06:40:22 -05:00
@property
def membership(self):
return self.content["membership"]
def is_state(self):
return hasattr(self, "state_key") and self.state_key is not None
2014-12-02 06:40:22 -05:00
def get_dict(self):
d = dict(self._event_dict)
2014-12-02 06:40:22 -05:00
d.update({
"signatures": self.signatures,
"unsigned": dict(self.unsigned),
2014-12-02 06:40:22 -05:00
})
return d
2016-08-26 06:20:59 -04:00
def get(self, key, default=None):
return self._event_dict.get(key, default)
2014-12-02 06:40:22 -05:00
def get_internal_metadata_dict(self):
return self.internal_metadata.get_dict()
def get_pdu_json(self, time_now=None):
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)
2014-12-03 11:07:21 -05:00
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]
2014-12-03 11:07:21 -05:00
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):
2015-01-06 13:51:03 -05:00
event_dict = dict(event_dict)
2014-12-03 11:07:21 -05:00
2015-01-06 13:51:03 -05:00
# 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", {}))
2014-12-03 11:07:21 -05:00
2016-03-23 10:58:08 -04:00
# We intern these strings because they turn up a lot (especially when
# caching).
2016-03-23 12:13:05 -04:00
event_dict = intern_dict(event_dict)
2016-03-23 10:58:08 -04:00
if USE_FROZEN_DICTS:
frozen_dict = freeze(event_dict)
else:
2015-05-29 10:02:55 -04:00
frozen_dict = event_dict
2014-12-03 11:07:21 -05:00
2017-01-13 08:16:54 -05:00
self.event_id = event_dict["event_id"]
self.type = event_dict["type"]
if "state_key" in event_dict:
self.state_key = event_dict["state_key"]
2014-12-03 11:07:21 -05:00
super(FrozenEvent, self).__init__(
frozen_dict,
signatures=signatures,
2014-12-16 08:17:09 -05:00
unsigned=unsigned,
internal_metadata_dict=internal_metadata_dict,
rejected_reason=rejected_reason,
2014-12-03 11:07:21 -05:00
)
@staticmethod
def from_event(event):
e = FrozenEvent(
event.get_pdu_json()
2014-12-03 11:07:21 -05:00
)
e.internal_metadata = event.internal_metadata
return e
2014-12-10 06:38:08 -05:00
def __str__(self):
return self.__repr__()
def __repr__(self):
2014-12-10 06:38:08 -05:00
return "<FrozenEvent event_id='%s', type='%s', state_key='%s'>" % (
self.get("event_id", None),
self.get("type", None),
self.get("state_key", None),
2014-12-15 11:14:34 -05:00
)
def room_version_to_event_format(room_version):
"""Converts a room version string to the event format
Args:
room_version (str)
Returns:
int
"""
if room_version not in KNOWN_ROOM_VERSIONS:
2019-01-24 13:28:00 -05:00
# We should have already checked version, so this should not happen
raise RuntimeError("Unrecognized room version %s" % (room_version,))
return EventFormatVersions.V1
def event_type_from_format_version(format_version):
"""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 not in KNOWN_EVENT_FORMAT_VERSIONS:
raise Exception(
"No event format %r" % (format_version,)
)
return FrozenEvent