2015-03-20 13:52:56 +00:00
|
|
|
# -*- coding: utf-8 -*-
|
2016-01-07 04:26:29 +00:00
|
|
|
# Copyright 2014-2016 OpenMarket Ltd
|
2019-05-30 10:22:59 +00:00
|
|
|
# Copyright 2018-2019 New Vector Ltd
|
|
|
|
# Copyright 2019 The Matrix.org Foundation C.I.C.
|
2015-03-20 13:52:56 +00: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.
|
|
|
|
|
2018-04-17 17:30:53 +00:00
|
|
|
import itertools
|
2018-03-29 21:57:28 +00:00
|
|
|
import logging
|
2019-10-23 11:00:21 +00:00
|
|
|
from collections import Counter as c_counter, OrderedDict, namedtuple
|
2018-07-09 06:09:20 +00:00
|
|
|
from functools import wraps
|
|
|
|
|
2018-08-30 14:19:58 +00:00
|
|
|
from six import iteritems, text_type
|
2018-07-09 06:09:20 +00:00
|
|
|
from six.moves import range
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2019-10-08 13:31:43 +00:00
|
|
|
from canonicaljson import json
|
2019-10-23 11:00:21 +00:00
|
|
|
from prometheus_client import Counter
|
2018-06-28 13:49:57 +00:00
|
|
|
|
2018-02-23 11:01:21 +00:00
|
|
|
from twisted.internet import defer
|
|
|
|
|
2018-07-09 06:09:20 +00:00
|
|
|
import synapse.metrics
|
2019-11-01 10:39:14 +00:00
|
|
|
from synapse.api.constants import EventContentFields, EventTypes
|
2018-07-09 06:09:20 +00:00
|
|
|
from synapse.api.errors import SynapseError
|
|
|
|
from synapse.events import EventBase # noqa: F401
|
|
|
|
from synapse.events.snapshot import EventContext # noqa: F401
|
2019-08-29 16:38:51 +00:00
|
|
|
from synapse.events.utils import prune_event_dict
|
2019-07-03 14:07:04 +00:00
|
|
|
from synapse.logging.utils import log_function
|
2019-06-13 12:40:52 +00:00
|
|
|
from synapse.metrics import BucketCollector
|
2018-07-18 13:35:24 +00:00
|
|
|
from synapse.metrics.background_process_metrics import run_as_background_process
|
2019-10-02 18:07:07 +00:00
|
|
|
from synapse.storage._base import make_in_list_sql_clause
|
2018-07-31 12:11:04 +00:00
|
|
|
from synapse.storage.background_updates import BackgroundUpdateStore
|
2019-10-21 11:56:42 +00:00
|
|
|
from synapse.storage.data_stores.main.event_federation import EventFederationStore
|
|
|
|
from synapse.storage.data_stores.main.events_worker import EventsWorkerStore
|
|
|
|
from synapse.storage.data_stores.main.state import StateGroupWorkerStore
|
2018-07-09 06:09:20 +00:00
|
|
|
from synapse.types import RoomStreamToken, get_domain_from_id
|
2018-10-02 22:33:29 +00:00
|
|
|
from synapse.util import batch_iter
|
2018-07-09 06:09:20 +00:00
|
|
|
from synapse.util.caches.descriptors import cached, cachedInlineCallbacks
|
2018-03-29 21:57:28 +00:00
|
|
|
from synapse.util.frozenutils import frozendict_json_encoder
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2018-05-22 00:48:57 +00:00
|
|
|
logger = logging.getLogger(__name__)
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2018-05-22 00:48:57 +00:00
|
|
|
persist_event_counter = Counter("synapse_storage_events_persisted_events", "")
|
2019-03-28 13:37:16 +00:00
|
|
|
event_counter = Counter(
|
|
|
|
"synapse_storage_events_persisted_events_sep",
|
|
|
|
"",
|
|
|
|
["type", "origin_type", "origin_entity"],
|
|
|
|
)
|
2018-03-27 12:13:38 +00:00
|
|
|
|
2016-06-06 10:58:09 +00:00
|
|
|
|
2015-08-24 15:17:38 +00:00
|
|
|
def encode_json(json_object):
|
2018-08-01 14:54:06 +00:00
|
|
|
"""
|
|
|
|
Encode a Python object as JSON and return it in a Unicode string.
|
|
|
|
"""
|
|
|
|
out = frozendict_json_encoder.encode(json_object)
|
|
|
|
if isinstance(out, bytes):
|
2019-04-02 11:42:39 +00:00
|
|
|
out = out.decode("utf8")
|
2018-08-01 14:54:06 +00:00
|
|
|
return out
|
2015-08-24 15:17:38 +00:00
|
|
|
|
2016-11-15 11:22:29 +00:00
|
|
|
|
2016-06-03 16:55:32 +00:00
|
|
|
_EventCacheEntry = namedtuple("_EventCacheEntry", ("event", "redacted_event"))
|
|
|
|
|
|
|
|
|
2016-08-04 14:02:15 +00:00
|
|
|
def _retry_on_integrity_error(func):
|
|
|
|
"""Wraps a database function so that it gets retried on IntegrityError,
|
|
|
|
with `delete_existing=True` passed in.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
func: function that returns a Deferred and accepts a `delete_existing` arg
|
|
|
|
"""
|
2019-03-28 13:37:16 +00:00
|
|
|
|
2016-08-04 14:02:15 +00:00
|
|
|
@wraps(func)
|
|
|
|
@defer.inlineCallbacks
|
|
|
|
def f(self, *args, **kwargs):
|
|
|
|
try:
|
2019-10-30 18:05:00 +00:00
|
|
|
res = yield func(self, *args, delete_existing=False, **kwargs)
|
2016-08-04 14:02:15 +00:00
|
|
|
except self.database_engine.module.IntegrityError:
|
|
|
|
logger.exception("IntegrityError, retrying.")
|
|
|
|
res = yield func(self, *args, delete_existing=True, **kwargs)
|
2019-07-23 13:00:55 +00:00
|
|
|
return res
|
2016-08-04 14:02:15 +00:00
|
|
|
|
|
|
|
return f
|
|
|
|
|
|
|
|
|
2018-07-26 11:48:51 +00:00
|
|
|
# inherits from EventFederationStore so that we can call _update_backward_extremities
|
|
|
|
# and _handle_mult_prev_events (though arguably those could both be moved in here)
|
2019-03-28 13:37:16 +00:00
|
|
|
class EventsStore(
|
|
|
|
StateGroupWorkerStore,
|
|
|
|
EventFederationStore,
|
|
|
|
EventsWorkerStore,
|
|
|
|
BackgroundUpdateStore,
|
|
|
|
):
|
2017-11-09 18:51:27 +00:00
|
|
|
def __init__(self, db_conn, hs):
|
|
|
|
super(EventsStore, self).__init__(db_conn, hs)
|
2019-05-28 17:52:41 +00:00
|
|
|
|
2019-06-13 12:40:52 +00:00
|
|
|
# Collect metrics on the number of forward extremities that exist.
|
2019-06-14 13:07:32 +00:00
|
|
|
# Counter of number of extremities to count
|
|
|
|
self._current_forward_extremities_amount = c_counter()
|
2019-06-13 12:40:52 +00:00
|
|
|
|
|
|
|
BucketCollector(
|
|
|
|
"synapse_forward_extremities",
|
|
|
|
lambda: self._current_forward_extremities_amount,
|
2019-06-20 09:32:02 +00:00
|
|
|
buckets=[1, 2, 3, 5, 7, 10, 15, 20, 50, 100, 200, 500, "+Inf"],
|
2019-06-13 12:40:52 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
# Read the extrems every 60 minutes
|
2019-07-03 08:31:27 +00:00
|
|
|
def read_forward_extremities():
|
|
|
|
# run as a background process to make sure that the database transactions
|
|
|
|
# have a logcontext to report to
|
|
|
|
return run_as_background_process(
|
|
|
|
"read_forward_extremities", self._read_forward_extremities
|
|
|
|
)
|
|
|
|
|
|
|
|
hs.get_clock().looping_call(read_forward_extremities, 60 * 60 * 1000)
|
2019-06-13 12:40:52 +00:00
|
|
|
|
2019-08-29 16:38:51 +00:00
|
|
|
def _censor_redactions():
|
|
|
|
return run_as_background_process(
|
|
|
|
"_censor_redactions", self._censor_redactions
|
|
|
|
)
|
|
|
|
|
2019-09-09 12:24:24 +00:00
|
|
|
if self.hs.config.redaction_retention_period is not None:
|
2019-09-09 12:31:00 +00:00
|
|
|
hs.get_clock().looping_call(_censor_redactions, 5 * 60 * 1000)
|
2019-08-29 16:38:51 +00:00
|
|
|
|
2019-06-13 12:40:52 +00:00
|
|
|
@defer.inlineCallbacks
|
|
|
|
def _read_forward_extremities(self):
|
|
|
|
def fetch(txn):
|
|
|
|
txn.execute(
|
|
|
|
"""
|
|
|
|
select count(*) c from event_forward_extremities
|
|
|
|
group by room_id
|
|
|
|
"""
|
|
|
|
)
|
|
|
|
return txn.fetchall()
|
|
|
|
|
|
|
|
res = yield self.runInteraction("read_forward_extremities", fetch)
|
|
|
|
self._current_forward_extremities_amount = c_counter(list(x[0] for x in res))
|
|
|
|
|
2016-08-04 14:02:15 +00:00
|
|
|
@_retry_on_integrity_error
|
2016-05-06 13:31:38 +00:00
|
|
|
@defer.inlineCallbacks
|
2019-10-30 13:33:38 +00:00
|
|
|
def _persist_events_and_state_updates(
|
2019-10-23 11:00:21 +00:00
|
|
|
self,
|
|
|
|
events_and_contexts,
|
|
|
|
current_state_for_room,
|
|
|
|
state_delta_for_room,
|
|
|
|
new_forward_extremeties,
|
|
|
|
backfilled=False,
|
|
|
|
delete_existing=False,
|
2019-03-28 13:37:16 +00:00
|
|
|
):
|
2019-10-30 13:33:38 +00:00
|
|
|
"""Persist a set of events alongside updates to the current state and
|
|
|
|
forward extremities tables.
|
2017-03-17 11:51:13 +00:00
|
|
|
|
|
|
|
Args:
|
|
|
|
events_and_contexts (list[(EventBase, EventContext)]):
|
2019-10-30 13:33:38 +00:00
|
|
|
current_state_for_room (dict[str, dict]): Map from room_id to the
|
|
|
|
current state of the room based on forward extremities
|
|
|
|
state_delta_for_room (dict[str, tuple]): Map from room_id to tuple
|
|
|
|
of `(to_delete, to_insert)` where to_delete is a list
|
|
|
|
of type/state keys to remove from current state, and to_insert
|
|
|
|
is a map (type,key)->event_id giving the state delta in each
|
|
|
|
room.
|
|
|
|
new_forward_extremities (dict[str, list[str]]): Map from room_id
|
|
|
|
to list of event IDs that are the new forward extremities of
|
|
|
|
the room.
|
|
|
|
backfilled (bool)
|
2017-03-17 11:51:13 +00:00
|
|
|
delete_existing (bool):
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
Deferred: resolves when the events have been persisted
|
|
|
|
"""
|
2015-06-25 16:18:19 +00:00
|
|
|
|
2019-10-23 11:00:21 +00:00
|
|
|
# We want to calculate the stream orderings as late as possible, as
|
|
|
|
# we only notify after all events with a lesser stream ordering have
|
|
|
|
# been persisted. I.e. if we spend 10s inside the with block then
|
|
|
|
# that will delay all subsequent events from being notified about.
|
|
|
|
# Hence why we do it down here rather than wrapping the entire
|
|
|
|
# function.
|
|
|
|
#
|
|
|
|
# Its safe to do this after calculating the state deltas etc as we
|
|
|
|
# only need to protect the *persistence* of the events. This is to
|
|
|
|
# ensure that queries of the form "fetch events since X" don't
|
|
|
|
# return events and stream positions after events that are still in
|
|
|
|
# flight, as otherwise subsequent requests "fetch event since Y"
|
|
|
|
# will not return those events.
|
|
|
|
#
|
|
|
|
# Note: Multiple instances of this function cannot be in flight at
|
|
|
|
# the same time for the same room.
|
|
|
|
if backfilled:
|
|
|
|
stream_ordering_manager = self._backfill_id_gen.get_next_mult(
|
|
|
|
len(events_and_contexts)
|
|
|
|
)
|
|
|
|
else:
|
|
|
|
stream_ordering_manager = self._stream_id_gen.get_next_mult(
|
|
|
|
len(events_and_contexts)
|
|
|
|
)
|
2019-08-06 12:27:22 +00:00
|
|
|
|
2019-10-23 11:00:21 +00:00
|
|
|
with stream_ordering_manager as stream_orderings:
|
|
|
|
for (event, context), stream in zip(events_and_contexts, stream_orderings):
|
|
|
|
event.internal_metadata.stream_ordering = stream
|
2019-08-06 12:27:22 +00:00
|
|
|
|
2019-10-23 11:00:21 +00:00
|
|
|
yield self.runInteraction(
|
|
|
|
"persist_events",
|
|
|
|
self._persist_events_txn,
|
|
|
|
events_and_contexts=events_and_contexts,
|
|
|
|
backfilled=backfilled,
|
|
|
|
delete_existing=delete_existing,
|
|
|
|
state_delta_for_room=state_delta_for_room,
|
|
|
|
new_forward_extremeties=new_forward_extremeties,
|
|
|
|
)
|
|
|
|
persist_event_counter.inc(len(events_and_contexts))
|
2019-08-06 12:27:22 +00:00
|
|
|
|
|
|
|
if not backfilled:
|
2019-10-23 11:00:21 +00:00
|
|
|
# backfilled events have negative stream orderings, so we don't
|
|
|
|
# want to set the event_persisted_position to that.
|
|
|
|
synapse.metrics.event_persisted_position.set(
|
|
|
|
events_and_contexts[-1][0].internal_metadata.stream_ordering
|
2016-08-30 15:54:40 +00:00
|
|
|
)
|
2017-01-20 14:28:53 +00:00
|
|
|
|
2019-10-23 11:00:21 +00:00
|
|
|
for event, context in events_and_contexts:
|
|
|
|
if context.app_service:
|
|
|
|
origin_type = "local"
|
|
|
|
origin_entity = context.app_service.id
|
|
|
|
elif self.hs.is_mine_id(event.sender):
|
|
|
|
origin_type = "local"
|
|
|
|
origin_entity = "*client*"
|
|
|
|
else:
|
|
|
|
origin_type = "remote"
|
|
|
|
origin_entity = get_domain_from_id(event.sender)
|
|
|
|
|
|
|
|
event_counter.labels(event.type, origin_type, origin_entity).inc()
|
|
|
|
|
|
|
|
for room_id, new_state in iteritems(current_state_for_room):
|
|
|
|
self.get_current_state_ids.prefill((room_id,), new_state)
|
|
|
|
|
|
|
|
for room_id, latest_event_ids in iteritems(new_forward_extremeties):
|
|
|
|
self.get_latest_event_ids_in_room.prefill(
|
|
|
|
(room_id,), list(latest_event_ids)
|
|
|
|
)
|
2017-01-20 14:28:53 +00:00
|
|
|
|
2018-10-02 22:33:29 +00:00
|
|
|
@defer.inlineCallbacks
|
|
|
|
def _get_events_which_are_prevs(self, event_ids):
|
|
|
|
"""Filter the supplied list of event_ids to get those which are prev_events of
|
2018-10-03 09:19:41 +00:00
|
|
|
existing (non-outlier/rejected) events.
|
2018-10-02 22:33:29 +00:00
|
|
|
|
|
|
|
Args:
|
|
|
|
event_ids (Iterable[str]): event ids to filter
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
Deferred[List[str]]: filtered event ids
|
|
|
|
"""
|
|
|
|
results = []
|
|
|
|
|
2019-05-29 10:56:24 +00:00
|
|
|
def _get_events_which_are_prevs_txn(txn, batch):
|
2018-10-02 22:33:29 +00:00
|
|
|
sql = """
|
2019-05-21 15:10:54 +00:00
|
|
|
SELECT prev_event_id, internal_metadata
|
2018-10-02 22:33:29 +00:00
|
|
|
FROM event_edges
|
|
|
|
INNER JOIN events USING (event_id)
|
|
|
|
LEFT JOIN rejections USING (event_id)
|
2019-05-21 15:10:54 +00:00
|
|
|
LEFT JOIN event_json USING (event_id)
|
2018-10-02 22:33:29 +00:00
|
|
|
WHERE
|
2019-10-02 18:07:07 +00:00
|
|
|
NOT events.outlier
|
2018-10-02 22:33:29 +00:00
|
|
|
AND rejections.event_id IS NULL
|
2019-10-02 18:07:07 +00:00
|
|
|
AND
|
|
|
|
"""
|
|
|
|
|
|
|
|
clause, args = make_in_list_sql_clause(
|
|
|
|
self.database_engine, "prev_event_id", batch
|
2018-10-02 22:33:29 +00:00
|
|
|
)
|
2017-01-20 14:28:53 +00:00
|
|
|
|
2019-10-02 18:07:07 +00:00
|
|
|
txn.execute(sql + clause, args)
|
2019-06-13 12:40:52 +00:00
|
|
|
results.extend(r[0] for r in txn if not json.loads(r[1]).get("soft_failed"))
|
2018-10-02 22:33:29 +00:00
|
|
|
|
|
|
|
for chunk in batch_iter(event_ids, 100):
|
2019-05-29 10:56:24 +00:00
|
|
|
yield self.runInteraction(
|
2019-06-13 12:40:52 +00:00
|
|
|
"_get_events_which_are_prevs", _get_events_which_are_prevs_txn, chunk
|
2019-05-29 10:56:24 +00:00
|
|
|
)
|
2018-10-02 22:33:29 +00:00
|
|
|
|
2019-07-23 13:00:55 +00:00
|
|
|
return results
|
2017-01-20 14:28:53 +00:00
|
|
|
|
2019-05-29 10:56:24 +00:00
|
|
|
@defer.inlineCallbacks
|
|
|
|
def _get_prevs_before_rejected(self, event_ids):
|
|
|
|
"""Get soft-failed ancestors to remove from the extremities.
|
|
|
|
|
|
|
|
Given a set of events, find all those that have been soft-failed or
|
|
|
|
rejected. Returns those soft failed/rejected events and their prev
|
|
|
|
events (whether soft-failed/rejected or not), and recurses up the
|
|
|
|
prev-event graph until it finds no more soft-failed/rejected events.
|
|
|
|
|
|
|
|
This is used to find extremities that are ancestors of new events, but
|
|
|
|
are separated by soft failed events.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
event_ids (Iterable[str]): Events to find prev events for. Note
|
|
|
|
that these must have already been persisted.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
Deferred[set[str]]
|
|
|
|
"""
|
|
|
|
|
|
|
|
# The set of event_ids to return. This includes all soft-failed events
|
|
|
|
# and their prev events.
|
|
|
|
existing_prevs = set()
|
|
|
|
|
|
|
|
def _get_prevs_before_rejected_txn(txn, batch):
|
|
|
|
to_recursively_check = batch
|
|
|
|
|
|
|
|
while to_recursively_check:
|
|
|
|
sql = """
|
|
|
|
SELECT
|
|
|
|
event_id, prev_event_id, internal_metadata,
|
|
|
|
rejections.event_id IS NOT NULL
|
|
|
|
FROM event_edges
|
|
|
|
INNER JOIN events USING (event_id)
|
|
|
|
LEFT JOIN rejections USING (event_id)
|
|
|
|
LEFT JOIN event_json USING (event_id)
|
|
|
|
WHERE
|
2019-10-02 18:07:07 +00:00
|
|
|
NOT events.outlier
|
|
|
|
AND
|
|
|
|
"""
|
|
|
|
|
|
|
|
clause, args = make_in_list_sql_clause(
|
|
|
|
self.database_engine, "event_id", to_recursively_check
|
2019-05-29 10:56:24 +00:00
|
|
|
)
|
|
|
|
|
2019-10-02 18:07:07 +00:00
|
|
|
txn.execute(sql + clause, args)
|
2019-05-29 10:56:24 +00:00
|
|
|
to_recursively_check = []
|
|
|
|
|
|
|
|
for event_id, prev_event_id, metadata, rejected in txn:
|
|
|
|
if prev_event_id in existing_prevs:
|
|
|
|
continue
|
|
|
|
|
|
|
|
soft_failed = json.loads(metadata).get("soft_failed")
|
|
|
|
if soft_failed or rejected:
|
|
|
|
to_recursively_check.append(prev_event_id)
|
|
|
|
existing_prevs.add(prev_event_id)
|
|
|
|
|
|
|
|
for chunk in batch_iter(event_ids, 100):
|
|
|
|
yield self.runInteraction(
|
2019-06-13 12:40:52 +00:00
|
|
|
"_get_prevs_before_rejected", _get_prevs_before_rejected_txn, chunk
|
2019-05-29 10:56:24 +00:00
|
|
|
)
|
|
|
|
|
2019-07-23 13:00:55 +00:00
|
|
|
return existing_prevs
|
2019-05-29 10:56:24 +00:00
|
|
|
|
2015-06-25 16:18:19 +00:00
|
|
|
@log_function
|
2019-03-28 13:37:16 +00:00
|
|
|
def _persist_events_txn(
|
|
|
|
self,
|
|
|
|
txn,
|
|
|
|
events_and_contexts,
|
|
|
|
backfilled,
|
|
|
|
delete_existing=False,
|
|
|
|
state_delta_for_room={},
|
|
|
|
new_forward_extremeties={},
|
|
|
|
):
|
2016-07-26 09:49:52 +00:00
|
|
|
"""Insert some number of room events into the necessary database tables.
|
|
|
|
|
|
|
|
Rejected events are only inserted into the events table, the events_json table,
|
|
|
|
and the rejections table. Things reading from those table will need to check
|
|
|
|
whether the event was rejected.
|
2016-08-04 14:02:15 +00:00
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
Args:
|
|
|
|
txn (twisted.enterprise.adbapi.Connection): db connection
|
|
|
|
events_and_contexts (list[(EventBase, EventContext)]):
|
|
|
|
events to persist
|
|
|
|
backfilled (bool): True if the events were backfilled
|
|
|
|
delete_existing (bool): True to purge existing table rows for the
|
|
|
|
events from the database. This is useful when retrying due to
|
|
|
|
IntegrityError.
|
2018-07-24 10:59:16 +00:00
|
|
|
state_delta_for_room (dict[str, (list, dict)]):
|
2017-03-17 11:51:13 +00:00
|
|
|
The current-state delta for each room. For each room, a tuple
|
2018-07-24 10:59:16 +00:00
|
|
|
(to_delete, to_insert), being a list of type/state keys to be
|
|
|
|
removed from the current state, and a state set to be added to
|
2017-03-17 11:51:13 +00:00
|
|
|
the current state.
|
|
|
|
new_forward_extremeties (dict[str, list[str]]):
|
|
|
|
The new forward extremities for each room. For each room, a
|
|
|
|
list of the event ids which are the forward extremities.
|
|
|
|
|
2016-07-26 09:49:52 +00:00
|
|
|
"""
|
2018-02-20 12:33:04 +00:00
|
|
|
all_events_and_contexts = events_and_contexts
|
|
|
|
|
2019-04-02 11:42:39 +00:00
|
|
|
min_stream_order = events_and_contexts[0][0].internal_metadata.stream_ordering
|
2017-01-20 14:28:53 +00:00
|
|
|
max_stream_order = events_and_contexts[-1][0].internal_metadata.stream_ordering
|
2017-05-30 13:41:42 +00:00
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
self._update_forward_extremities_txn(
|
|
|
|
txn,
|
|
|
|
new_forward_extremities=new_forward_extremeties,
|
|
|
|
max_stream_order=max_stream_order,
|
|
|
|
)
|
|
|
|
|
|
|
|
# Ensure that we don't have the same event twice.
|
|
|
|
events_and_contexts = self._filter_events_and_contexts_for_duplicates(
|
2019-03-28 13:37:16 +00:00
|
|
|
events_and_contexts
|
2017-03-17 11:51:13 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
self._update_room_depths_txn(
|
2019-03-28 13:37:16 +00:00
|
|
|
txn, events_and_contexts=events_and_contexts, backfilled=backfilled
|
2017-03-17 11:51:13 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
# _update_outliers_txn filters out any events which have already been
|
|
|
|
# persisted, and returns the filtered list.
|
|
|
|
events_and_contexts = self._update_outliers_txn(
|
2019-03-28 13:37:16 +00:00
|
|
|
txn, events_and_contexts=events_and_contexts
|
2017-03-17 11:51:13 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
# From this point onwards the events are only events that we haven't
|
|
|
|
# seen before.
|
|
|
|
|
|
|
|
if delete_existing:
|
|
|
|
# For paranoia reasons, we go and delete all the existing entries
|
|
|
|
# for these events so we can reinsert them.
|
|
|
|
# This gets around any problems with some tables already having
|
|
|
|
# entries.
|
2019-03-28 13:37:16 +00:00
|
|
|
self._delete_existing_rows_txn(txn, events_and_contexts=events_and_contexts)
|
2017-03-17 11:51:13 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
self._store_event_txn(txn, events_and_contexts=events_and_contexts)
|
2017-03-17 11:51:13 +00:00
|
|
|
|
2018-02-06 14:31:24 +00:00
|
|
|
# Insert into event_to_state_groups.
|
|
|
|
self._store_event_state_mappings_txn(txn, events_and_contexts)
|
2017-03-17 14:30:16 +00:00
|
|
|
|
2018-10-16 13:01:53 +00:00
|
|
|
# We want to store event_auth mappings for rejected events, as they're
|
|
|
|
# used in state res v2.
|
|
|
|
# This is only necessary if the rejected event appears in an accepted
|
|
|
|
# event's auth chain, but its easier for now just to store them (and
|
|
|
|
# it doesn't take much storage compared to storing the entire event
|
|
|
|
# anyway).
|
|
|
|
self._simple_insert_many_txn(
|
|
|
|
txn,
|
|
|
|
table="event_auth",
|
|
|
|
values=[
|
|
|
|
{
|
|
|
|
"event_id": event.event_id,
|
|
|
|
"room_id": event.room_id,
|
|
|
|
"auth_id": auth_id,
|
|
|
|
}
|
|
|
|
for event, _ in events_and_contexts
|
2018-11-05 13:35:15 +00:00
|
|
|
for auth_id in event.auth_event_ids()
|
2018-10-16 13:01:53 +00:00
|
|
|
if event.is_state()
|
|
|
|
],
|
|
|
|
)
|
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
# _store_rejected_events_txn filters out any events which were
|
|
|
|
# rejected, and returns the filtered list.
|
|
|
|
events_and_contexts = self._store_rejected_events_txn(
|
2019-03-28 13:37:16 +00:00
|
|
|
txn, events_and_contexts=events_and_contexts
|
2017-03-17 11:51:13 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
# From this point onwards the events are only ones that weren't
|
|
|
|
# rejected.
|
|
|
|
|
|
|
|
self._update_metadata_tables_txn(
|
|
|
|
txn,
|
|
|
|
events_and_contexts=events_and_contexts,
|
2018-02-20 12:33:04 +00:00
|
|
|
all_events_and_contexts=all_events_and_contexts,
|
2017-03-17 11:51:13 +00:00
|
|
|
backfilled=backfilled,
|
|
|
|
)
|
|
|
|
|
2019-07-17 14:33:37 +00:00
|
|
|
# We call this last as it assumes we've inserted the events into
|
|
|
|
# room_memberships, where applicable.
|
|
|
|
self._update_current_state_txn(txn, state_delta_for_room, min_stream_order)
|
|
|
|
|
2019-04-02 11:42:39 +00:00
|
|
|
def _update_current_state_txn(self, txn, state_delta_by_room, stream_id):
|
2018-05-31 09:03:47 +00:00
|
|
|
for room_id, current_state_tuple in iteritems(state_delta_by_room):
|
2019-01-30 10:53:17 +00:00
|
|
|
to_delete, to_insert = current_state_tuple
|
2017-01-20 15:40:04 +00:00
|
|
|
|
2019-01-30 10:53:17 +00:00
|
|
|
# First we add entries to the current_state_delta_stream. We
|
|
|
|
# do this before updating the current_state_events table so
|
|
|
|
# that we can use it to calculate the `prev_event_id`. (This
|
|
|
|
# allows us to not have to pull out the existing state
|
|
|
|
# unnecessarily).
|
2019-04-02 11:42:39 +00:00
|
|
|
#
|
|
|
|
# The stream_id for the update is chosen to be the minimum of the stream_ids
|
|
|
|
# for the batch of the events that we are persisting; that means we do not
|
|
|
|
# end up in a situation where workers see events before the
|
|
|
|
# current_state_delta updates.
|
|
|
|
#
|
2019-01-30 10:53:17 +00:00
|
|
|
sql = """
|
|
|
|
INSERT INTO current_state_delta_stream
|
|
|
|
(stream_id, room_id, type, state_key, event_id, prev_event_id)
|
|
|
|
SELECT ?, ?, ?, ?, ?, (
|
|
|
|
SELECT event_id FROM current_state_events
|
|
|
|
WHERE room_id = ? AND type = ? AND state_key = ?
|
2017-01-20 15:40:04 +00:00
|
|
|
)
|
2019-01-30 10:53:17 +00:00
|
|
|
"""
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.executemany(
|
|
|
|
sql,
|
2019-01-30 10:53:17 +00:00
|
|
|
(
|
2019-03-28 13:37:16 +00:00
|
|
|
(
|
2019-04-02 11:42:39 +00:00
|
|
|
stream_id,
|
2019-03-28 13:37:16 +00:00
|
|
|
room_id,
|
|
|
|
etype,
|
|
|
|
state_key,
|
|
|
|
None,
|
|
|
|
room_id,
|
|
|
|
etype,
|
|
|
|
state_key,
|
|
|
|
)
|
|
|
|
for etype, state_key in to_delete
|
|
|
|
# We sanity check that we're deleting rather than updating
|
|
|
|
if (etype, state_key) not in to_insert
|
|
|
|
),
|
|
|
|
)
|
|
|
|
txn.executemany(
|
|
|
|
sql,
|
2019-01-30 10:53:17 +00:00
|
|
|
(
|
2019-03-28 13:37:16 +00:00
|
|
|
(
|
2019-04-02 11:42:39 +00:00
|
|
|
stream_id,
|
2019-03-28 13:37:16 +00:00
|
|
|
room_id,
|
|
|
|
etype,
|
|
|
|
state_key,
|
|
|
|
ev_id,
|
|
|
|
room_id,
|
|
|
|
etype,
|
|
|
|
state_key,
|
|
|
|
)
|
|
|
|
for (etype, state_key), ev_id in iteritems(to_insert)
|
|
|
|
),
|
|
|
|
)
|
2019-01-30 10:53:17 +00:00
|
|
|
|
|
|
|
# Now we actually update the current_state_events table
|
|
|
|
|
|
|
|
txn.executemany(
|
|
|
|
"DELETE FROM current_state_events"
|
|
|
|
" WHERE room_id = ? AND type = ? AND state_key = ?",
|
|
|
|
(
|
|
|
|
(room_id, etype, state_key)
|
|
|
|
for etype, state_key in itertools.chain(to_delete, to_insert)
|
|
|
|
),
|
|
|
|
)
|
2017-01-20 15:40:04 +00:00
|
|
|
|
2019-07-17 14:33:37 +00:00
|
|
|
# We include the membership in the current state table, hence we do
|
|
|
|
# a lookup when we insert. This assumes that all events have already
|
|
|
|
# been inserted into room_memberships.
|
|
|
|
txn.executemany(
|
|
|
|
"""INSERT INTO current_state_events
|
|
|
|
(room_id, type, state_key, event_id, membership)
|
|
|
|
VALUES (?, ?, ?, ?, (SELECT membership FROM room_memberships WHERE event_id = ?))
|
|
|
|
""",
|
|
|
|
[
|
|
|
|
(room_id, key[0], key[1], ev_id, ev_id)
|
2019-01-30 10:53:17 +00:00
|
|
|
for key, ev_id in iteritems(to_insert)
|
|
|
|
],
|
|
|
|
)
|
2017-01-20 15:40:04 +00:00
|
|
|
|
2019-01-30 10:53:17 +00:00
|
|
|
txn.call_after(
|
|
|
|
self._curr_state_delta_stream_cache.entity_has_changed,
|
2019-03-28 13:37:16 +00:00
|
|
|
room_id,
|
2019-04-02 11:42:39 +00:00
|
|
|
stream_id,
|
2019-01-30 10:53:17 +00:00
|
|
|
)
|
2017-06-13 08:56:18 +00:00
|
|
|
|
2019-01-30 10:53:17 +00:00
|
|
|
# Invalidate the various caches
|
|
|
|
|
|
|
|
# Figure out the changes of membership to invalidate the
|
|
|
|
# `get_rooms_for_user` cache.
|
|
|
|
# We find out which membership events we may have deleted
|
|
|
|
# and which we have added, then we invlidate the caches for all
|
|
|
|
# those users.
|
|
|
|
members_changed = set(
|
|
|
|
state_key
|
|
|
|
for ev_type, state_key in itertools.chain(to_delete, to_insert)
|
|
|
|
if ev_type == EventTypes.Member
|
|
|
|
)
|
|
|
|
|
2019-04-02 11:42:39 +00:00
|
|
|
for member in members_changed:
|
|
|
|
txn.call_after(
|
|
|
|
self.get_rooms_for_user_with_stream_ordering.invalidate, (member,)
|
|
|
|
)
|
|
|
|
|
2019-02-18 17:53:31 +00:00
|
|
|
self._invalidate_state_caches_and_stream(txn, room_id, members_changed)
|
2019-01-30 10:53:17 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
def _update_forward_extremities_txn(
|
|
|
|
self, txn, new_forward_extremities, max_stream_order
|
|
|
|
):
|
2018-05-31 09:03:47 +00:00
|
|
|
for room_id, new_extrem in iteritems(new_forward_extremities):
|
2017-01-20 14:28:53 +00:00
|
|
|
self._simple_delete_txn(
|
2019-03-28 13:37:16 +00:00
|
|
|
txn, table="event_forward_extremities", keyvalues={"room_id": room_id}
|
2017-01-20 14:28:53 +00:00
|
|
|
)
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.call_after(self.get_latest_event_ids_in_room.invalidate, (room_id,))
|
2017-01-20 14:28:53 +00:00
|
|
|
|
|
|
|
self._simple_insert_many_txn(
|
|
|
|
txn,
|
|
|
|
table="event_forward_extremities",
|
|
|
|
values=[
|
2019-03-28 13:37:16 +00:00
|
|
|
{"event_id": ev_id, "room_id": room_id}
|
2018-05-31 09:03:47 +00:00
|
|
|
for room_id, new_extrem in iteritems(new_forward_extremities)
|
2017-01-20 14:28:53 +00:00
|
|
|
for ev_id in new_extrem
|
|
|
|
],
|
|
|
|
)
|
|
|
|
# We now insert into stream_ordering_to_exterm a mapping from room_id,
|
|
|
|
# new stream_ordering to new forward extremeties in the room.
|
|
|
|
# This allows us to later efficiently look up the forward extremeties
|
|
|
|
# for a room before a given stream_ordering
|
|
|
|
self._simple_insert_many_txn(
|
|
|
|
txn,
|
|
|
|
table="stream_ordering_to_exterm",
|
|
|
|
values=[
|
|
|
|
{
|
|
|
|
"room_id": room_id,
|
|
|
|
"event_id": event_id,
|
|
|
|
"stream_ordering": max_stream_order,
|
|
|
|
}
|
2018-05-31 09:03:47 +00:00
|
|
|
for room_id, new_extrem in iteritems(new_forward_extremities)
|
2017-01-20 14:28:53 +00:00
|
|
|
for event_id in new_extrem
|
2019-03-28 13:37:16 +00:00
|
|
|
],
|
2017-01-20 14:28:53 +00:00
|
|
|
)
|
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
@classmethod
|
|
|
|
def _filter_events_and_contexts_for_duplicates(cls, events_and_contexts):
|
|
|
|
"""Ensure that we don't have the same event twice.
|
|
|
|
|
|
|
|
Pick the earliest non-outlier if there is one, else the earliest one.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
events_and_contexts (list[(EventBase, EventContext)]):
|
|
|
|
Returns:
|
|
|
|
list[(EventBase, EventContext)]: filtered list
|
|
|
|
"""
|
2016-08-03 10:23:39 +00:00
|
|
|
new_events_and_contexts = OrderedDict()
|
|
|
|
for event, context in events_and_contexts:
|
|
|
|
prev_event_context = new_events_and_contexts.get(event.event_id)
|
|
|
|
if prev_event_context:
|
|
|
|
if not event.internal_metadata.is_outlier():
|
|
|
|
if prev_event_context[0].internal_metadata.is_outlier():
|
|
|
|
# To ensure correct ordering we pop, as OrderedDict is
|
|
|
|
# ordered by first insertion.
|
|
|
|
new_events_and_contexts.pop(event.event_id, None)
|
|
|
|
new_events_and_contexts[event.event_id] = (event, context)
|
|
|
|
else:
|
|
|
|
new_events_and_contexts[event.event_id] = (event, context)
|
2018-05-31 09:03:47 +00:00
|
|
|
return list(new_events_and_contexts.values())
|
2016-08-03 10:23:39 +00:00
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
def _update_room_depths_txn(self, txn, events_and_contexts, backfilled):
|
|
|
|
"""Update min_depth for each room
|
2016-08-03 10:23:39 +00:00
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
Args:
|
|
|
|
txn (twisted.enterprise.adbapi.Connection): db connection
|
|
|
|
events_and_contexts (list[(EventBase, EventContext)]): events
|
|
|
|
we are persisting
|
|
|
|
backfilled (bool): True if the events were backfilled
|
|
|
|
"""
|
2016-02-09 16:19:15 +00:00
|
|
|
depth_updates = {}
|
|
|
|
for event, context in events_and_contexts:
|
|
|
|
# Remove the any existing cache entries for the event_ids
|
2015-06-25 16:18:19 +00:00
|
|
|
txn.call_after(self._invalidate_get_event_cache, event.event_id)
|
2016-01-28 15:02:37 +00:00
|
|
|
if not backfilled:
|
|
|
|
txn.call_after(
|
2016-01-28 16:37:41 +00:00
|
|
|
self._events_stream_cache.entity_has_changed,
|
2019-03-28 13:37:16 +00:00
|
|
|
event.room_id,
|
|
|
|
event.internal_metadata.stream_ordering,
|
2016-01-28 15:02:37 +00:00
|
|
|
)
|
|
|
|
|
2016-07-25 17:44:30 +00:00
|
|
|
if not event.internal_metadata.is_outlier() and not context.rejected:
|
2016-02-09 16:19:15 +00:00
|
|
|
depth_updates[event.room_id] = max(
|
|
|
|
event.depth, depth_updates.get(event.room_id, event.depth)
|
|
|
|
)
|
|
|
|
|
2018-05-31 09:03:47 +00:00
|
|
|
for room_id, depth in iteritems(depth_updates):
|
2015-06-25 16:18:19 +00:00
|
|
|
self._update_min_depth_for_room_txn(txn, room_id, depth)
|
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
def _update_outliers_txn(self, txn, events_and_contexts):
|
|
|
|
"""Update any outliers with new event info.
|
|
|
|
|
|
|
|
This turns outliers into ex-outliers (unless the new event was
|
|
|
|
rejected).
|
|
|
|
|
|
|
|
Args:
|
|
|
|
txn (twisted.enterprise.adbapi.Connection): db connection
|
|
|
|
events_and_contexts (list[(EventBase, EventContext)]): events
|
|
|
|
we are persisting
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
list[(EventBase, EventContext)] new list, without events which
|
|
|
|
are already in the events table.
|
|
|
|
"""
|
2015-06-25 16:18:19 +00:00
|
|
|
txn.execute(
|
2019-03-28 13:37:16 +00:00
|
|
|
"SELECT event_id, outlier FROM events WHERE event_id in (%s)"
|
|
|
|
% (",".join(["?"] * len(events_and_contexts)),),
|
|
|
|
[event.event_id for event, _ in events_and_contexts],
|
2015-03-20 13:52:56 +00:00
|
|
|
)
|
2016-07-25 17:44:30 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
have_persisted = {event_id: outlier for event_id, outlier in txn}
|
2015-06-25 16:18:19 +00:00
|
|
|
|
|
|
|
to_remove = set()
|
|
|
|
for event, context in events_and_contexts:
|
|
|
|
if event.event_id not in have_persisted:
|
|
|
|
continue
|
|
|
|
|
|
|
|
to_remove.add(event)
|
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
if context.rejected:
|
|
|
|
# If the event is rejected then we don't care if the event
|
|
|
|
# was an outlier or not.
|
|
|
|
continue
|
|
|
|
|
2015-06-25 16:18:19 +00:00
|
|
|
outlier_persisted = have_persisted[event.event_id]
|
|
|
|
if not event.internal_metadata.is_outlier() and outlier_persisted:
|
2016-07-26 09:49:52 +00:00
|
|
|
# We received a copy of an event that we had already stored as
|
|
|
|
# an outlier in the database. We now have some state at that
|
|
|
|
# so we need to update the state_groups table with that state.
|
|
|
|
|
2018-02-06 14:31:24 +00:00
|
|
|
# insert into event_to_state_groups.
|
2016-09-02 09:41:38 +00:00
|
|
|
try:
|
2018-02-06 14:31:24 +00:00
|
|
|
self._store_event_state_mappings_txn(txn, ((event, context),))
|
2016-09-02 09:41:38 +00:00
|
|
|
except Exception:
|
|
|
|
logger.exception("")
|
|
|
|
raise
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
metadata_json = encode_json(event.internal_metadata.get_dict())
|
2015-05-12 13:14:58 +00:00
|
|
|
|
2015-03-20 13:52:56 +00:00
|
|
|
sql = (
|
2019-03-28 13:37:16 +00:00
|
|
|
"UPDATE event_json SET internal_metadata = ?" " WHERE event_id = ?"
|
2015-03-20 13:52:56 +00:00
|
|
|
)
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.execute(sql, (metadata_json, event.event_id))
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2016-07-26 09:49:52 +00:00
|
|
|
# Add an entry to the ex_outlier_stream table to replicate the
|
|
|
|
# change in outlier status to our workers.
|
2016-03-30 16:19:56 +00:00
|
|
|
stream_order = event.internal_metadata.stream_ordering
|
2016-08-31 09:09:46 +00:00
|
|
|
state_group_id = context.state_group
|
2016-03-30 16:19:56 +00:00
|
|
|
self._simple_insert_txn(
|
|
|
|
txn,
|
|
|
|
table="ex_outlier_stream",
|
|
|
|
values={
|
|
|
|
"event_stream_ordering": stream_order,
|
|
|
|
"event_id": event.event_id,
|
|
|
|
"state_group": state_group_id,
|
2019-03-28 13:37:16 +00:00
|
|
|
},
|
2016-03-30 16:19:56 +00:00
|
|
|
)
|
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
sql = "UPDATE events SET outlier = ?" " WHERE event_id = ?"
|
|
|
|
txn.execute(sql, (False, event.event_id))
|
2016-07-25 17:44:30 +00:00
|
|
|
|
2016-07-26 09:49:52 +00:00
|
|
|
# Update the event_backward_extremities table now that this
|
|
|
|
# event isn't an outlier any more.
|
2017-01-20 14:40:31 +00:00
|
|
|
self._update_backward_extremeties(txn, [event])
|
2015-09-15 15:34:42 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
return [ec for ec in events_and_contexts if ec[0] not in to_remove]
|
2015-03-24 16:20:26 +00:00
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
@classmethod
|
|
|
|
def _delete_existing_rows_txn(cls, txn, events_and_contexts):
|
2015-06-25 16:18:19 +00:00
|
|
|
if not events_and_contexts:
|
2017-03-17 11:51:13 +00:00
|
|
|
# nothing to do here
|
2015-06-25 16:18:19 +00:00
|
|
|
return
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
logger.info("Deleting existing")
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
for table in (
|
2019-03-28 13:37:16 +00:00
|
|
|
"events",
|
|
|
|
"event_auth",
|
|
|
|
"event_json",
|
|
|
|
"event_edges",
|
|
|
|
"event_forward_extremities",
|
|
|
|
"event_reference_hashes",
|
|
|
|
"event_search",
|
|
|
|
"event_to_state_groups",
|
|
|
|
"local_invites",
|
|
|
|
"state_events",
|
|
|
|
"rejections",
|
|
|
|
"redactions",
|
|
|
|
"room_memberships",
|
2017-03-17 11:51:13 +00:00
|
|
|
):
|
|
|
|
txn.executemany(
|
|
|
|
"DELETE FROM %s WHERE event_id = ?" % (table,),
|
2019-03-28 13:37:16 +00:00
|
|
|
[(ev.event_id,) for ev, _ in events_and_contexts],
|
2017-03-17 11:51:13 +00:00
|
|
|
)
|
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
for table in ("event_push_actions",):
|
2016-12-29 16:54:03 +00:00
|
|
|
txn.executemany(
|
|
|
|
"DELETE FROM %s WHERE room_id = ? AND event_id = ?" % (table,),
|
2019-03-28 13:37:16 +00:00
|
|
|
[(ev.room_id, ev.event_id) for ev, _ in events_and_contexts],
|
2016-12-29 16:54:03 +00:00
|
|
|
)
|
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
def _store_event_txn(self, txn, events_and_contexts):
|
|
|
|
"""Insert new events into the event and event_json tables
|
|
|
|
|
|
|
|
Args:
|
|
|
|
txn (twisted.enterprise.adbapi.Connection): db connection
|
|
|
|
events_and_contexts (list[(EventBase, EventContext)]): events
|
|
|
|
we are persisting
|
|
|
|
"""
|
|
|
|
|
|
|
|
if not events_and_contexts:
|
|
|
|
# nothing to do here
|
|
|
|
return
|
|
|
|
|
|
|
|
def event_dict(event):
|
2017-03-24 10:57:02 +00:00
|
|
|
d = event.get_dict()
|
|
|
|
d.pop("redacted", None)
|
|
|
|
d.pop("redacted_because", None)
|
|
|
|
return d
|
2016-08-04 14:02:15 +00:00
|
|
|
|
2015-06-25 16:18:19 +00:00
|
|
|
self._simple_insert_many_txn(
|
|
|
|
txn,
|
|
|
|
table="event_json",
|
|
|
|
values=[
|
|
|
|
{
|
|
|
|
"event_id": event.event_id,
|
|
|
|
"room_id": event.room_id,
|
|
|
|
"internal_metadata": encode_json(
|
2015-08-24 15:17:38 +00:00
|
|
|
event.internal_metadata.get_dict()
|
2018-08-01 14:54:06 +00:00
|
|
|
),
|
|
|
|
"json": encode_json(event_dict(event)),
|
2019-01-23 11:11:52 +00:00
|
|
|
"format_version": event.format_version,
|
2015-06-25 16:18:19 +00:00
|
|
|
}
|
|
|
|
for event, _ in events_and_contexts
|
|
|
|
],
|
2015-04-15 09:24:24 +00:00
|
|
|
)
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2015-06-25 16:18:19 +00:00
|
|
|
self._simple_insert_many_txn(
|
|
|
|
txn,
|
|
|
|
table="events",
|
|
|
|
values=[
|
|
|
|
{
|
|
|
|
"stream_ordering": event.internal_metadata.stream_ordering,
|
|
|
|
"topological_ordering": event.depth,
|
|
|
|
"depth": event.depth,
|
|
|
|
"event_id": event.event_id,
|
|
|
|
"room_id": event.room_id,
|
|
|
|
"type": event.type,
|
|
|
|
"processed": True,
|
|
|
|
"outlier": event.internal_metadata.is_outlier(),
|
2015-11-30 17:45:31 +00:00
|
|
|
"origin_server_ts": int(event.origin_server_ts),
|
2016-04-19 13:24:36 +00:00
|
|
|
"received_ts": self._clock.time_msec(),
|
2016-07-14 14:15:22 +00:00
|
|
|
"sender": event.sender,
|
|
|
|
"contains_url": (
|
|
|
|
"url" in event.content
|
2018-08-30 14:19:58 +00:00
|
|
|
and isinstance(event.content["url"], text_type)
|
2016-07-14 14:15:22 +00:00
|
|
|
),
|
2015-06-25 16:18:19 +00:00
|
|
|
}
|
|
|
|
for event, _ in events_and_contexts
|
|
|
|
],
|
2015-03-20 13:52:56 +00:00
|
|
|
)
|
|
|
|
|
2019-10-01 10:05:48 +00:00
|
|
|
for event, _ in events_and_contexts:
|
|
|
|
if not event.internal_metadata.is_redacted():
|
|
|
|
# If we're persisting an unredacted event we go and ensure
|
|
|
|
# that we mark any redactions that reference this event as
|
|
|
|
# requiring censoring.
|
|
|
|
self._simple_update_txn(
|
|
|
|
txn,
|
|
|
|
table="redactions",
|
2019-10-01 12:23:34 +00:00
|
|
|
keyvalues={"redacts": event.event_id},
|
|
|
|
updatevalues={"have_censored": False},
|
2019-10-01 10:05:48 +00:00
|
|
|
)
|
|
|
|
|
2017-03-17 11:51:13 +00:00
|
|
|
def _store_rejected_events_txn(self, txn, events_and_contexts):
|
|
|
|
"""Add rows to the 'rejections' table for received events which were
|
|
|
|
rejected
|
|
|
|
|
|
|
|
Args:
|
|
|
|
txn (twisted.enterprise.adbapi.Connection): db connection
|
|
|
|
events_and_contexts (list[(EventBase, EventContext)]): events
|
|
|
|
we are persisting
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
list[(EventBase, EventContext)] new list, without the rejected
|
|
|
|
events.
|
|
|
|
"""
|
2016-07-26 09:49:52 +00:00
|
|
|
# Remove the rejected events from the list now that we've added them
|
|
|
|
# to the events table and the events_json table.
|
2016-07-25 17:44:30 +00:00
|
|
|
to_remove = set()
|
2016-07-25 15:12:16 +00:00
|
|
|
for event, context in events_and_contexts:
|
|
|
|
if context.rejected:
|
2016-07-26 09:49:52 +00:00
|
|
|
# Insert the event_id into the rejections table
|
2019-03-28 13:37:16 +00:00
|
|
|
self._store_rejections_txn(txn, event.event_id, context.rejected)
|
2016-07-26 09:49:52 +00:00
|
|
|
to_remove.add(event)
|
2016-07-25 17:44:30 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
return [ec for ec in events_and_contexts if ec[0] not in to_remove]
|
2016-07-25 17:44:30 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
def _update_metadata_tables_txn(
|
|
|
|
self, txn, events_and_contexts, all_events_and_contexts, backfilled
|
|
|
|
):
|
2017-03-17 11:51:13 +00:00
|
|
|
"""Update all the miscellaneous tables for new events
|
|
|
|
|
|
|
|
Args:
|
|
|
|
txn (twisted.enterprise.adbapi.Connection): db connection
|
|
|
|
events_and_contexts (list[(EventBase, EventContext)]): events
|
|
|
|
we are persisting
|
2018-02-20 12:33:04 +00:00
|
|
|
all_events_and_contexts (list[(EventBase, EventContext)]): all
|
|
|
|
events that we were going to persist. This includes events
|
|
|
|
we've already persisted, etc, that wouldn't appear in
|
|
|
|
events_and_context.
|
2017-03-17 11:51:13 +00:00
|
|
|
backfilled (bool): True if the events were backfilled
|
|
|
|
"""
|
|
|
|
|
2018-02-20 12:29:50 +00:00
|
|
|
# Insert all the push actions into the event_push_actions table.
|
|
|
|
self._set_push_actions_for_event_and_users_txn(
|
|
|
|
txn,
|
|
|
|
events_and_contexts=events_and_contexts,
|
2018-02-20 12:33:04 +00:00
|
|
|
all_events_and_contexts=all_events_and_contexts,
|
2018-02-20 12:29:50 +00:00
|
|
|
)
|
|
|
|
|
2016-07-25 17:44:30 +00:00
|
|
|
if not events_and_contexts:
|
2017-03-17 11:51:13 +00:00
|
|
|
# nothing to do here
|
2016-07-25 17:44:30 +00:00
|
|
|
return
|
|
|
|
|
|
|
|
for event, context in events_and_contexts:
|
2016-07-26 10:05:39 +00:00
|
|
|
if event.type == EventTypes.Redaction and event.redacts is not None:
|
|
|
|
# Remove the entries in the event_push_actions table for the
|
|
|
|
# redacted event.
|
|
|
|
self._remove_push_actions_for_event_id_txn(
|
|
|
|
txn, event.room_id, event.redacts
|
|
|
|
)
|
|
|
|
|
2019-05-20 09:13:05 +00:00
|
|
|
# Remove from relations table.
|
|
|
|
self._handle_redaction(txn, event.redacts)
|
|
|
|
|
2016-07-26 09:49:52 +00:00
|
|
|
# Update the event_forward_extremities, event_backward_extremities and
|
|
|
|
# event_edges tables.
|
2016-07-25 17:44:30 +00:00
|
|
|
self._handle_mult_prev_events(
|
2019-03-28 13:37:16 +00:00
|
|
|
txn, events=[event for event, _ in events_and_contexts]
|
2016-07-25 17:44:30 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
for event, _ in events_and_contexts:
|
|
|
|
if event.type == EventTypes.Name:
|
2019-08-21 12:16:28 +00:00
|
|
|
# Insert into the event_search table.
|
2016-07-25 17:44:30 +00:00
|
|
|
self._store_room_name_txn(txn, event)
|
|
|
|
elif event.type == EventTypes.Topic:
|
2019-08-21 12:16:28 +00:00
|
|
|
# Insert into the event_search table.
|
2016-07-25 17:44:30 +00:00
|
|
|
self._store_room_topic_txn(txn, event)
|
|
|
|
elif event.type == EventTypes.Message:
|
2016-07-26 09:49:52 +00:00
|
|
|
# Insert into the event_search table.
|
2016-07-25 17:44:30 +00:00
|
|
|
self._store_room_message_txn(txn, event)
|
|
|
|
elif event.type == EventTypes.Redaction:
|
2016-07-26 09:49:52 +00:00
|
|
|
# Insert into the redactions table.
|
2016-07-25 17:44:30 +00:00
|
|
|
self._store_redaction(txn, event)
|
|
|
|
|
2019-05-14 15:59:21 +00:00
|
|
|
self._handle_event_relations(txn, event)
|
|
|
|
|
2019-10-29 18:35:49 +00:00
|
|
|
# Store the labels for this event.
|
2019-11-01 16:22:44 +00:00
|
|
|
labels = event.content.get(EventContentFields.LABELS)
|
2019-10-29 18:35:49 +00:00
|
|
|
if labels:
|
2019-11-01 11:47:28 +00:00
|
|
|
self.insert_labels_for_event_txn(
|
|
|
|
txn, event.event_id, labels, event.room_id, event.depth
|
|
|
|
)
|
2019-10-29 18:35:49 +00:00
|
|
|
|
2016-07-26 09:49:52 +00:00
|
|
|
# Insert into the room_memberships table.
|
2016-07-25 17:44:30 +00:00
|
|
|
self._store_room_members_txn(
|
|
|
|
txn,
|
|
|
|
[
|
|
|
|
event
|
|
|
|
for event, _ in events_and_contexts
|
|
|
|
if event.type == EventTypes.Member
|
|
|
|
],
|
|
|
|
backfilled=backfilled,
|
|
|
|
)
|
|
|
|
|
2016-07-26 09:49:52 +00:00
|
|
|
# Insert event_reference_hashes table.
|
2015-06-25 16:18:19 +00:00
|
|
|
self._store_event_reference_hashes_txn(
|
|
|
|
txn, [event for event, _ in events_and_contexts]
|
|
|
|
)
|
|
|
|
|
2016-03-31 14:00:42 +00:00
|
|
|
state_events_and_contexts = [
|
|
|
|
ec for ec in events_and_contexts if ec[0].is_state()
|
|
|
|
]
|
2015-04-27 12:22:30 +00:00
|
|
|
|
2015-06-25 16:18:19 +00:00
|
|
|
state_values = []
|
|
|
|
for event, context in state_events_and_contexts:
|
2015-03-20 13:52:56 +00:00
|
|
|
vals = {
|
|
|
|
"event_id": event.event_id,
|
|
|
|
"room_id": event.room_id,
|
|
|
|
"type": event.type,
|
|
|
|
"state_key": event.state_key,
|
|
|
|
}
|
|
|
|
|
|
|
|
# TODO: How does this work with backfilling?
|
|
|
|
if hasattr(event, "replaces_state"):
|
|
|
|
vals["prev_state"] = event.replaces_state
|
|
|
|
|
2015-06-25 16:18:19 +00:00
|
|
|
state_values.append(vals)
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
self._simple_insert_many_txn(txn, table="state_events", values=state_values)
|
2015-03-20 13:52:56 +00:00
|
|
|
|
2016-07-26 10:05:39 +00:00
|
|
|
# Prefill the event cache
|
2016-06-06 10:08:12 +00:00
|
|
|
self._add_to_cache(txn, events_and_contexts)
|
|
|
|
|
|
|
|
def _add_to_cache(self, txn, events_and_contexts):
|
|
|
|
to_prefill = []
|
|
|
|
|
|
|
|
rows = []
|
|
|
|
N = 200
|
|
|
|
for i in range(0, len(events_and_contexts), N):
|
2019-03-28 13:37:16 +00:00
|
|
|
ev_map = {e[0].event_id: e[0] for e in events_and_contexts[i : i + N]}
|
2016-06-06 10:08:12 +00:00
|
|
|
if not ev_map:
|
|
|
|
break
|
|
|
|
|
|
|
|
sql = (
|
|
|
|
"SELECT "
|
|
|
|
" e.event_id as event_id, "
|
|
|
|
" r.redacts as redacts,"
|
|
|
|
" rej.event_id as rejects "
|
|
|
|
" FROM events as e"
|
|
|
|
" LEFT JOIN rejections as rej USING (event_id)"
|
|
|
|
" LEFT JOIN redactions as r ON e.event_id = r.redacts"
|
2019-10-02 18:07:07 +00:00
|
|
|
" WHERE "
|
|
|
|
)
|
|
|
|
|
|
|
|
clause, args = make_in_list_sql_clause(
|
|
|
|
self.database_engine, "e.event_id", list(ev_map)
|
|
|
|
)
|
2016-06-06 10:08:12 +00:00
|
|
|
|
2019-10-02 18:07:07 +00:00
|
|
|
txn.execute(sql + clause, args)
|
2016-06-06 10:08:12 +00:00
|
|
|
rows = self.cursor_to_dict(txn)
|
|
|
|
for row in rows:
|
|
|
|
event = ev_map[row["event_id"]]
|
|
|
|
if not row["rejects"] and not row["redacts"]:
|
2019-03-28 13:37:16 +00:00
|
|
|
to_prefill.append(
|
|
|
|
_EventCacheEntry(event=event, redacted_event=None)
|
|
|
|
)
|
2016-06-06 10:08:12 +00:00
|
|
|
|
|
|
|
def prefill():
|
|
|
|
for cache_entry in to_prefill:
|
|
|
|
self._get_event_cache.prefill((cache_entry[0].event_id,), cache_entry)
|
2019-03-28 13:37:16 +00:00
|
|
|
|
2016-06-06 10:08:12 +00:00
|
|
|
txn.call_after(prefill)
|
|
|
|
|
2015-03-20 13:52:56 +00:00
|
|
|
def _store_redaction(self, txn, event):
|
|
|
|
# invalidate the cache for the redacted event
|
2015-05-05 16:32:21 +00:00
|
|
|
txn.call_after(self._invalidate_get_event_cache, event.redacts)
|
2019-10-01 12:23:34 +00:00
|
|
|
|
|
|
|
self._simple_insert_txn(
|
|
|
|
txn,
|
|
|
|
table="redactions",
|
|
|
|
values={
|
|
|
|
"event_id": event.event_id,
|
|
|
|
"redacts": event.redacts,
|
|
|
|
"received_ts": self._clock.time_msec(),
|
|
|
|
},
|
2015-03-20 13:52:56 +00:00
|
|
|
)
|
|
|
|
|
2019-08-29 16:38:51 +00:00
|
|
|
@defer.inlineCallbacks
|
|
|
|
def _censor_redactions(self):
|
2019-09-09 14:08:24 +00:00
|
|
|
"""Censors all redactions older than the configured period that haven't
|
|
|
|
been censored yet.
|
2019-08-29 16:38:51 +00:00
|
|
|
|
|
|
|
By censor we mean update the event_json table with the redacted event.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
Deferred
|
|
|
|
"""
|
|
|
|
|
2019-09-09 12:23:41 +00:00
|
|
|
if self.hs.config.redaction_retention_period is None:
|
2019-08-29 16:38:51 +00:00
|
|
|
return
|
|
|
|
|
2019-10-01 12:28:41 +00:00
|
|
|
before_ts = self._clock.time_msec() - self.hs.config.redaction_retention_period
|
2019-08-29 16:38:51 +00:00
|
|
|
|
2019-09-09 12:31:00 +00:00
|
|
|
# We fetch all redactions that:
|
2019-09-09 14:08:24 +00:00
|
|
|
# 1. point to an event we have,
|
2019-10-01 12:28:41 +00:00
|
|
|
# 2. has a received_ts from before the cut off, and
|
2019-09-09 12:31:00 +00:00
|
|
|
# 3. we haven't yet censored.
|
|
|
|
#
|
|
|
|
# This is limited to 100 events to ensure that we don't try and do too
|
|
|
|
# much at once. We'll get called again so this should eventually catch
|
|
|
|
# up.
|
2019-08-29 16:38:51 +00:00
|
|
|
sql = """
|
2019-10-01 12:28:41 +00:00
|
|
|
SELECT redactions.event_id, redacts FROM redactions
|
2019-10-01 10:05:48 +00:00
|
|
|
LEFT JOIN events AS original_event ON (
|
2019-10-01 12:28:41 +00:00
|
|
|
redacts = original_event.event_id
|
2019-09-09 12:33:38 +00:00
|
|
|
)
|
2019-08-29 16:38:51 +00:00
|
|
|
WHERE NOT have_censored
|
2019-10-01 12:28:41 +00:00
|
|
|
AND redactions.received_ts <= ?
|
|
|
|
ORDER BY redactions.received_ts ASC
|
2019-08-29 16:38:51 +00:00
|
|
|
LIMIT ?
|
|
|
|
"""
|
|
|
|
|
|
|
|
rows = yield self._execute(
|
2019-10-01 12:28:41 +00:00
|
|
|
"_censor_redactions_fetch", None, sql, before_ts, 100
|
2019-08-29 16:38:51 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
updates = []
|
|
|
|
|
|
|
|
for redaction_id, event_id in rows:
|
|
|
|
redaction_event = yield self.get_event(redaction_id, allow_none=True)
|
|
|
|
original_event = yield self.get_event(
|
|
|
|
event_id, allow_rejected=True, allow_none=True
|
|
|
|
)
|
|
|
|
|
|
|
|
# The SQL above ensures that we have both the redaction and
|
|
|
|
# original event, so if the `get_event` calls return None it
|
|
|
|
# means that the redaction wasn't allowed. Either way we know that
|
|
|
|
# the result won't change so we mark the fact that we've checked.
|
|
|
|
if (
|
|
|
|
redaction_event
|
|
|
|
and original_event
|
|
|
|
and original_event.internal_metadata.is_redacted()
|
|
|
|
):
|
|
|
|
# Redaction was allowed
|
2019-10-08 13:31:43 +00:00
|
|
|
pruned_json = encode_json(prune_event_dict(original_event.get_dict()))
|
2019-08-29 16:38:51 +00:00
|
|
|
else:
|
|
|
|
# Redaction wasn't allowed
|
|
|
|
pruned_json = None
|
|
|
|
|
|
|
|
updates.append((redaction_id, event_id, pruned_json))
|
|
|
|
|
|
|
|
def _update_censor_txn(txn):
|
|
|
|
for redaction_id, event_id, pruned_json in updates:
|
|
|
|
if pruned_json:
|
|
|
|
self._simple_update_one_txn(
|
|
|
|
txn,
|
|
|
|
table="event_json",
|
|
|
|
keyvalues={"event_id": event_id},
|
|
|
|
updatevalues={"json": pruned_json},
|
|
|
|
)
|
|
|
|
|
|
|
|
self._simple_update_one_txn(
|
|
|
|
txn,
|
|
|
|
table="redactions",
|
|
|
|
keyvalues={"event_id": redaction_id},
|
|
|
|
updatevalues={"have_censored": True},
|
|
|
|
)
|
|
|
|
|
|
|
|
yield self.runInteraction("_update_censor_txn", _update_censor_txn)
|
|
|
|
|
2015-09-22 11:57:40 +00:00
|
|
|
@defer.inlineCallbacks
|
|
|
|
def count_daily_messages(self):
|
2015-09-22 12:29:36 +00:00
|
|
|
"""
|
|
|
|
Returns an estimate of the number of messages sent in the last day.
|
|
|
|
|
|
|
|
If it has been significantly less or more than one day since the last
|
|
|
|
call to this function, it will return None.
|
|
|
|
"""
|
2019-03-28 13:37:16 +00:00
|
|
|
|
2015-09-22 11:57:40 +00:00
|
|
|
def _count_messages(txn):
|
2017-06-14 18:37:17 +00:00
|
|
|
sql = """
|
|
|
|
SELECT COALESCE(COUNT(*), 0) FROM events
|
|
|
|
WHERE type = 'm.room.message'
|
|
|
|
AND stream_ordering > ?
|
|
|
|
"""
|
|
|
|
txn.execute(sql, (self.stream_ordering_day_ago,))
|
2019-10-31 15:43:24 +00:00
|
|
|
(count,) = txn.fetchone()
|
2017-06-14 18:37:17 +00:00
|
|
|
return count
|
2015-09-22 11:57:40 +00:00
|
|
|
|
|
|
|
ret = yield self.runInteraction("count_messages", _count_messages)
|
2019-07-23 13:00:55 +00:00
|
|
|
return ret
|
2015-09-22 11:57:40 +00:00
|
|
|
|
2017-06-14 18:37:17 +00:00
|
|
|
@defer.inlineCallbacks
|
|
|
|
def count_daily_sent_messages(self):
|
|
|
|
def _count_messages(txn):
|
|
|
|
# This is good enough as if you have silly characters in your own
|
|
|
|
# hostname then thats your own fault.
|
|
|
|
like_clause = "%:" + self.hs.hostname
|
|
|
|
|
|
|
|
sql = """
|
|
|
|
SELECT COALESCE(COUNT(*), 0) FROM events
|
|
|
|
WHERE type = 'm.room.message'
|
|
|
|
AND sender LIKE ?
|
|
|
|
AND stream_ordering > ?
|
|
|
|
"""
|
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.execute(sql, (like_clause, self.stream_ordering_day_ago))
|
2019-10-31 15:43:24 +00:00
|
|
|
(count,) = txn.fetchone()
|
2017-06-14 18:37:17 +00:00
|
|
|
return count
|
|
|
|
|
|
|
|
ret = yield self.runInteraction("count_daily_sent_messages", _count_messages)
|
2019-07-23 13:00:55 +00:00
|
|
|
return ret
|
2015-09-22 11:57:40 +00:00
|
|
|
|
2017-06-15 08:39:39 +00:00
|
|
|
@defer.inlineCallbacks
|
|
|
|
def count_daily_active_rooms(self):
|
|
|
|
def _count(txn):
|
|
|
|
sql = """
|
|
|
|
SELECT COALESCE(COUNT(DISTINCT room_id), 0) FROM events
|
|
|
|
WHERE type = 'm.room.message'
|
|
|
|
AND stream_ordering > ?
|
|
|
|
"""
|
|
|
|
txn.execute(sql, (self.stream_ordering_day_ago,))
|
2019-10-31 15:43:24 +00:00
|
|
|
(count,) = txn.fetchone()
|
2017-06-15 08:39:39 +00:00
|
|
|
return count
|
|
|
|
|
|
|
|
ret = yield self.runInteraction("count_daily_active_rooms", _count)
|
2019-07-23 13:00:55 +00:00
|
|
|
return ret
|
2015-11-30 17:45:31 +00:00
|
|
|
|
2016-03-01 14:49:41 +00:00
|
|
|
def get_current_backfill_token(self):
|
|
|
|
"""The current minimum token that backfilled events have reached"""
|
2016-04-01 12:29:05 +00:00
|
|
|
return -self._backfill_id_gen.get_current_token()
|
2016-03-01 14:49:41 +00:00
|
|
|
|
2017-03-27 13:03:38 +00:00
|
|
|
def get_current_events_token(self):
|
|
|
|
"""The current maximum token that events have reached"""
|
|
|
|
return self._stream_id_gen.get_current_token()
|
|
|
|
|
|
|
|
def get_all_new_forward_event_rows(self, last_id, current_id, limit):
|
|
|
|
if last_id == current_id:
|
|
|
|
return defer.succeed([])
|
|
|
|
|
|
|
|
def get_all_new_forward_event_rows(txn):
|
|
|
|
sql = (
|
|
|
|
"SELECT e.stream_ordering, e.event_id, e.room_id, e.type,"
|
2019-05-16 09:18:53 +00:00
|
|
|
" state_key, redacts, relates_to_id"
|
2017-03-27 13:03:38 +00:00
|
|
|
" FROM events AS e"
|
|
|
|
" LEFT JOIN redactions USING (event_id)"
|
|
|
|
" LEFT JOIN state_events USING (event_id)"
|
2019-05-16 09:18:53 +00:00
|
|
|
" LEFT JOIN event_relations USING (event_id)"
|
2017-03-27 13:03:38 +00:00
|
|
|
" WHERE ? < stream_ordering AND stream_ordering <= ?"
|
|
|
|
" ORDER BY stream_ordering ASC"
|
|
|
|
" LIMIT ?"
|
|
|
|
)
|
|
|
|
txn.execute(sql, (last_id, current_id, limit))
|
|
|
|
new_event_updates = txn.fetchall()
|
|
|
|
|
|
|
|
if len(new_event_updates) == limit:
|
|
|
|
upper_bound = new_event_updates[-1][0]
|
|
|
|
else:
|
|
|
|
upper_bound = current_id
|
|
|
|
|
|
|
|
sql = (
|
|
|
|
"SELECT event_stream_ordering, e.event_id, e.room_id, e.type,"
|
2019-05-16 09:18:53 +00:00
|
|
|
" state_key, redacts, relates_to_id"
|
2017-03-27 13:03:38 +00:00
|
|
|
" FROM events AS e"
|
|
|
|
" INNER JOIN ex_outlier_stream USING (event_id)"
|
|
|
|
" LEFT JOIN redactions USING (event_id)"
|
|
|
|
" LEFT JOIN state_events USING (event_id)"
|
2019-05-16 09:18:53 +00:00
|
|
|
" LEFT JOIN event_relations USING (event_id)"
|
2017-03-27 13:03:38 +00:00
|
|
|
" WHERE ? < event_stream_ordering"
|
|
|
|
" AND event_stream_ordering <= ?"
|
|
|
|
" ORDER BY event_stream_ordering DESC"
|
|
|
|
)
|
|
|
|
txn.execute(sql, (last_id, upper_bound))
|
|
|
|
new_event_updates.extend(txn)
|
|
|
|
|
|
|
|
return new_event_updates
|
2019-03-28 13:37:16 +00:00
|
|
|
|
2017-03-27 13:03:38 +00:00
|
|
|
return self.runInteraction(
|
|
|
|
"get_all_new_forward_event_rows", get_all_new_forward_event_rows
|
|
|
|
)
|
|
|
|
|
|
|
|
def get_all_new_backfill_event_rows(self, last_id, current_id, limit):
|
|
|
|
if last_id == current_id:
|
|
|
|
return defer.succeed([])
|
|
|
|
|
|
|
|
def get_all_new_backfill_event_rows(txn):
|
|
|
|
sql = (
|
|
|
|
"SELECT -e.stream_ordering, e.event_id, e.room_id, e.type,"
|
2019-05-16 09:18:53 +00:00
|
|
|
" state_key, redacts, relates_to_id"
|
2017-03-27 13:03:38 +00:00
|
|
|
" FROM events AS e"
|
|
|
|
" LEFT JOIN redactions USING (event_id)"
|
|
|
|
" LEFT JOIN state_events USING (event_id)"
|
2019-05-16 09:18:53 +00:00
|
|
|
" LEFT JOIN event_relations USING (event_id)"
|
2017-03-27 13:03:38 +00:00
|
|
|
" WHERE ? > stream_ordering AND stream_ordering >= ?"
|
|
|
|
" ORDER BY stream_ordering ASC"
|
|
|
|
" LIMIT ?"
|
|
|
|
)
|
|
|
|
txn.execute(sql, (-last_id, -current_id, limit))
|
|
|
|
new_event_updates = txn.fetchall()
|
|
|
|
|
|
|
|
if len(new_event_updates) == limit:
|
|
|
|
upper_bound = new_event_updates[-1][0]
|
|
|
|
else:
|
|
|
|
upper_bound = current_id
|
|
|
|
|
|
|
|
sql = (
|
|
|
|
"SELECT -event_stream_ordering, e.event_id, e.room_id, e.type,"
|
2019-05-16 09:18:53 +00:00
|
|
|
" state_key, redacts, relates_to_id"
|
2017-03-27 13:03:38 +00:00
|
|
|
" FROM events AS e"
|
|
|
|
" INNER JOIN ex_outlier_stream USING (event_id)"
|
|
|
|
" LEFT JOIN redactions USING (event_id)"
|
|
|
|
" LEFT JOIN state_events USING (event_id)"
|
2019-05-16 09:18:53 +00:00
|
|
|
" LEFT JOIN event_relations USING (event_id)"
|
2017-03-27 13:03:38 +00:00
|
|
|
" WHERE ? > event_stream_ordering"
|
|
|
|
" AND event_stream_ordering >= ?"
|
|
|
|
" ORDER BY event_stream_ordering DESC"
|
|
|
|
)
|
|
|
|
txn.execute(sql, (-last_id, -upper_bound))
|
|
|
|
new_event_updates.extend(txn.fetchall())
|
|
|
|
|
|
|
|
return new_event_updates
|
2019-03-28 13:37:16 +00:00
|
|
|
|
2017-03-27 13:03:38 +00:00
|
|
|
return self.runInteraction(
|
|
|
|
"get_all_new_backfill_event_rows", get_all_new_backfill_event_rows
|
|
|
|
)
|
|
|
|
|
2017-02-01 10:42:37 +00:00
|
|
|
@cached(num_args=5, max_entries=10)
|
2019-03-28 13:37:16 +00:00
|
|
|
def get_all_new_events(
|
|
|
|
self,
|
|
|
|
last_backfill_id,
|
|
|
|
last_forward_id,
|
|
|
|
current_backfill_id,
|
|
|
|
current_forward_id,
|
|
|
|
limit,
|
|
|
|
):
|
2016-03-01 14:49:41 +00:00
|
|
|
"""Get all the new events that have arrived at the server either as
|
|
|
|
new events or as backfilled events"""
|
2016-04-27 10:54:13 +00:00
|
|
|
have_backfill_events = last_backfill_id != current_backfill_id
|
|
|
|
have_forward_events = last_forward_id != current_forward_id
|
|
|
|
|
|
|
|
if not have_backfill_events and not have_forward_events:
|
|
|
|
return defer.succeed(AllNewEventsResult([], [], [], [], []))
|
|
|
|
|
2016-03-01 14:49:41 +00:00
|
|
|
def get_all_new_events_txn(txn):
|
|
|
|
sql = (
|
2017-03-17 15:47:51 +00:00
|
|
|
"SELECT e.stream_ordering, e.event_id, e.room_id, e.type,"
|
|
|
|
" state_key, redacts"
|
|
|
|
" FROM events AS e"
|
|
|
|
" LEFT JOIN redactions USING (event_id)"
|
|
|
|
" LEFT JOIN state_events USING (event_id)"
|
|
|
|
" WHERE ? < stream_ordering AND stream_ordering <= ?"
|
|
|
|
" ORDER BY stream_ordering ASC"
|
2016-03-01 14:49:41 +00:00
|
|
|
" LIMIT ?"
|
|
|
|
)
|
2016-04-27 10:54:13 +00:00
|
|
|
if have_forward_events:
|
2016-03-01 14:49:41 +00:00
|
|
|
txn.execute(sql, (last_forward_id, current_forward_id, limit))
|
|
|
|
new_forward_events = txn.fetchall()
|
2016-03-30 16:19:56 +00:00
|
|
|
|
|
|
|
if len(new_forward_events) == limit:
|
|
|
|
upper_bound = new_forward_events[-1][0]
|
|
|
|
else:
|
|
|
|
upper_bound = current_forward_id
|
|
|
|
|
|
|
|
sql = (
|
2016-04-06 13:12:51 +00:00
|
|
|
"SELECT event_stream_ordering, event_id, state_group"
|
2016-03-30 16:19:56 +00:00
|
|
|
" FROM ex_outlier_stream"
|
|
|
|
" WHERE ? > event_stream_ordering"
|
|
|
|
" AND event_stream_ordering >= ?"
|
|
|
|
" ORDER BY event_stream_ordering DESC"
|
|
|
|
)
|
|
|
|
txn.execute(sql, (last_forward_id, upper_bound))
|
|
|
|
forward_ex_outliers = txn.fetchall()
|
2016-03-01 14:49:41 +00:00
|
|
|
else:
|
|
|
|
new_forward_events = []
|
2016-03-30 16:19:56 +00:00
|
|
|
forward_ex_outliers = []
|
2016-03-01 14:49:41 +00:00
|
|
|
|
|
|
|
sql = (
|
2017-03-17 15:47:51 +00:00
|
|
|
"SELECT -e.stream_ordering, e.event_id, e.room_id, e.type,"
|
|
|
|
" state_key, redacts"
|
|
|
|
" FROM events AS e"
|
|
|
|
" LEFT JOIN redactions USING (event_id)"
|
|
|
|
" LEFT JOIN state_events USING (event_id)"
|
|
|
|
" WHERE ? > stream_ordering AND stream_ordering >= ?"
|
|
|
|
" ORDER BY stream_ordering DESC"
|
2016-03-01 14:49:41 +00:00
|
|
|
" LIMIT ?"
|
|
|
|
)
|
2016-04-27 10:54:13 +00:00
|
|
|
if have_backfill_events:
|
2016-03-01 14:49:41 +00:00
|
|
|
txn.execute(sql, (-last_backfill_id, -current_backfill_id, limit))
|
|
|
|
new_backfill_events = txn.fetchall()
|
2016-03-30 16:19:56 +00:00
|
|
|
|
|
|
|
if len(new_backfill_events) == limit:
|
|
|
|
upper_bound = new_backfill_events[-1][0]
|
|
|
|
else:
|
|
|
|
upper_bound = current_backfill_id
|
|
|
|
|
|
|
|
sql = (
|
|
|
|
"SELECT -event_stream_ordering, event_id, state_group"
|
|
|
|
" FROM ex_outlier_stream"
|
|
|
|
" WHERE ? > event_stream_ordering"
|
|
|
|
" AND event_stream_ordering >= ?"
|
|
|
|
" ORDER BY event_stream_ordering DESC"
|
|
|
|
)
|
|
|
|
txn.execute(sql, (-last_backfill_id, -upper_bound))
|
|
|
|
backward_ex_outliers = txn.fetchall()
|
2016-03-01 14:49:41 +00:00
|
|
|
else:
|
|
|
|
new_backfill_events = []
|
2016-03-30 16:19:56 +00:00
|
|
|
backward_ex_outliers = []
|
2016-03-01 14:49:41 +00:00
|
|
|
|
2016-03-31 09:33:02 +00:00
|
|
|
return AllNewEventsResult(
|
2019-03-28 13:37:16 +00:00
|
|
|
new_forward_events,
|
|
|
|
new_backfill_events,
|
|
|
|
forward_ex_outliers,
|
|
|
|
backward_ex_outliers,
|
2016-03-30 16:19:56 +00:00
|
|
|
)
|
2019-03-28 13:37:16 +00:00
|
|
|
|
2016-03-01 14:49:41 +00:00
|
|
|
return self.runInteraction("get_all_new_events", get_all_new_events_txn)
|
2016-03-31 09:33:02 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
def purge_history(self, room_id, token, delete_local_events):
|
2018-02-07 17:27:08 +00:00
|
|
|
"""Deletes room history before a certain point
|
2018-02-08 18:44:52 +00:00
|
|
|
|
|
|
|
Args:
|
|
|
|
room_id (str):
|
|
|
|
|
2018-05-15 15:06:30 +00:00
|
|
|
token (str): A topological token to delete events before
|
2016-07-05 09:28:51 +00:00
|
|
|
|
2018-02-08 18:44:52 +00:00
|
|
|
delete_local_events (bool):
|
|
|
|
if True, we will delete local events as well as remote ones
|
|
|
|
(instead of just marking them as outliers and deleting their
|
|
|
|
state groups).
|
2019-10-30 15:12:49 +00:00
|
|
|
|
|
|
|
Returns:
|
2019-10-31 15:25:21 +00:00
|
|
|
Deferred[set[int]]: The set of state groups that are referenced by
|
|
|
|
deleted events.
|
2016-07-04 15:02:50 +00:00
|
|
|
"""
|
|
|
|
|
2016-07-05 09:28:51 +00:00
|
|
|
return self.runInteraction(
|
2018-02-07 17:27:08 +00:00
|
|
|
"purge_history",
|
2019-03-28 13:37:16 +00:00
|
|
|
self._purge_history_txn,
|
|
|
|
room_id,
|
|
|
|
token,
|
2018-02-08 18:44:52 +00:00
|
|
|
delete_local_events,
|
2016-07-05 09:28:51 +00:00
|
|
|
)
|
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
def _purge_history_txn(self, txn, room_id, token_str, delete_local_events):
|
2018-05-16 09:52:06 +00:00
|
|
|
token = RoomStreamToken.parse(token_str)
|
|
|
|
|
2016-07-04 15:02:50 +00:00
|
|
|
# Tables that should be pruned:
|
|
|
|
# event_auth
|
|
|
|
# event_backward_extremities
|
|
|
|
# event_edges
|
|
|
|
# event_forward_extremities
|
|
|
|
# event_json
|
|
|
|
# event_push_actions
|
|
|
|
# event_reference_hashes
|
|
|
|
# event_search
|
|
|
|
# event_to_state_groups
|
|
|
|
# events
|
|
|
|
# rejections
|
|
|
|
# room_depth
|
|
|
|
# state_groups
|
|
|
|
# state_groups_state
|
|
|
|
|
2018-02-14 16:41:12 +00:00
|
|
|
# we will build a temporary table listing the events so that we don't
|
|
|
|
# have to keep shovelling the list back and forth across the
|
|
|
|
# connection. Annoyingly the python sqlite driver commits the
|
|
|
|
# transaction on CREATE, so let's do this first.
|
|
|
|
#
|
|
|
|
# furthermore, we might already have the table from a previous (failed)
|
|
|
|
# purge attempt, so let's drop the table first.
|
|
|
|
|
|
|
|
txn.execute("DROP TABLE IF EXISTS events_to_purge")
|
|
|
|
|
|
|
|
txn.execute(
|
|
|
|
"CREATE TEMPORARY TABLE events_to_purge ("
|
|
|
|
" event_id TEXT NOT NULL,"
|
|
|
|
" should_delete BOOLEAN NOT NULL"
|
|
|
|
")"
|
|
|
|
)
|
|
|
|
|
2016-07-04 15:02:50 +00:00
|
|
|
# First ensure that we're not about to delete all the forward extremeties
|
|
|
|
txn.execute(
|
|
|
|
"SELECT e.event_id, e.depth FROM events as e "
|
|
|
|
"INNER JOIN event_forward_extremities as f "
|
|
|
|
"ON e.event_id = f.event_id "
|
|
|
|
"AND e.room_id = f.room_id "
|
|
|
|
"WHERE f.room_id = ?",
|
2019-03-28 13:37:16 +00:00
|
|
|
(room_id,),
|
2016-07-04 15:02:50 +00:00
|
|
|
)
|
|
|
|
rows = txn.fetchall()
|
2018-08-30 14:19:58 +00:00
|
|
|
max_depth = max(row[1] for row in rows)
|
2016-07-04 15:02:50 +00:00
|
|
|
|
2018-08-30 14:19:58 +00:00
|
|
|
if max_depth < token.topological:
|
2018-08-15 15:35:22 +00:00
|
|
|
# We need to ensure we don't delete all the events from the database
|
2016-07-07 10:42:15 +00:00
|
|
|
# otherwise we wouldn't be able to send any events (due to not
|
|
|
|
# having any backwards extremeties)
|
2016-07-07 10:41:07 +00:00
|
|
|
raise SynapseError(
|
|
|
|
400, "topological_ordering is greater than forward extremeties"
|
|
|
|
)
|
2016-07-04 15:02:50 +00:00
|
|
|
|
2018-02-07 17:34:35 +00:00
|
|
|
logger.info("[purge] looking for events to delete")
|
2017-05-11 11:06:28 +00:00
|
|
|
|
2018-02-14 11:02:22 +00:00
|
|
|
should_delete_expr = "state_key IS NULL"
|
|
|
|
should_delete_params = ()
|
|
|
|
if not delete_local_events:
|
|
|
|
should_delete_expr += " AND event_id NOT LIKE ?"
|
2018-09-13 15:10:56 +00:00
|
|
|
|
|
|
|
# We include the parameter twice since we use the expression twice
|
2019-03-28 13:37:16 +00:00
|
|
|
should_delete_params += ("%:" + self.hs.hostname, "%:" + self.hs.hostname)
|
2018-02-14 11:02:22 +00:00
|
|
|
|
2018-05-15 15:06:30 +00:00
|
|
|
should_delete_params += (room_id, token.topological)
|
2018-02-14 11:02:22 +00:00
|
|
|
|
2018-09-13 11:48:10 +00:00
|
|
|
# Note that we insert events that are outliers and aren't going to be
|
|
|
|
# deleted, as nothing will happen to them.
|
2018-02-14 11:02:22 +00:00
|
|
|
txn.execute(
|
|
|
|
"INSERT INTO events_to_purge"
|
|
|
|
" SELECT event_id, %s"
|
|
|
|
" FROM events AS e LEFT JOIN state_events USING (event_id)"
|
2018-09-13 11:48:10 +00:00
|
|
|
" WHERE (NOT outlier OR (%s)) AND e.room_id = ? AND topological_ordering < ?"
|
2019-03-28 13:37:16 +00:00
|
|
|
% (should_delete_expr, should_delete_expr),
|
2018-02-14 11:02:22 +00:00
|
|
|
should_delete_params,
|
|
|
|
)
|
2018-09-13 14:05:52 +00:00
|
|
|
|
|
|
|
# We create the indices *after* insertion as that's a lot faster.
|
|
|
|
|
|
|
|
# create an index on should_delete because later we'll be looking for
|
|
|
|
# the should_delete / shouldn't_delete subsets
|
|
|
|
txn.execute(
|
|
|
|
"CREATE INDEX events_to_purge_should_delete"
|
2019-03-28 13:37:16 +00:00
|
|
|
" ON events_to_purge(should_delete)"
|
2018-09-13 14:05:52 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
# We do joins against events_to_purge for e.g. calculating state
|
|
|
|
# groups to purge, etc., so lets make an index.
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.execute("CREATE INDEX events_to_purge_id" " ON events_to_purge(event_id)")
|
2018-09-13 14:05:52 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.execute("SELECT event_id, should_delete FROM events_to_purge")
|
2018-02-14 11:02:22 +00:00
|
|
|
event_rows = txn.fetchall()
|
2017-05-11 11:06:28 +00:00
|
|
|
logger.info(
|
2018-02-08 18:44:52 +00:00
|
|
|
"[purge] found %i events before cutoff, of which %i can be deleted",
|
2019-03-28 13:37:16 +00:00
|
|
|
len(event_rows),
|
|
|
|
sum(1 for e in event_rows if e[1]),
|
2018-02-08 18:44:52 +00:00
|
|
|
)
|
2016-09-02 09:41:38 +00:00
|
|
|
|
2018-02-07 17:34:35 +00:00
|
|
|
logger.info("[purge] Finding new backward extremities")
|
2017-05-10 16:46:41 +00:00
|
|
|
|
2016-07-04 15:02:50 +00:00
|
|
|
# We calculate the new entries for the backward extremeties by finding
|
2018-05-16 10:47:26 +00:00
|
|
|
# events to be purged that are pointed to by events we're not going to
|
|
|
|
# purge.
|
2016-07-04 15:02:50 +00:00
|
|
|
txn.execute(
|
2018-02-14 11:02:22 +00:00
|
|
|
"SELECT DISTINCT e.event_id FROM events_to_purge AS e"
|
|
|
|
" INNER JOIN event_edges AS ed ON e.event_id = ed.prev_event_id"
|
2018-05-15 14:48:40 +00:00
|
|
|
" LEFT JOIN events_to_purge AS ep2 ON ed.event_id = ep2.event_id"
|
2019-03-28 13:37:16 +00:00
|
|
|
" WHERE ep2.event_id IS NULL"
|
2016-07-04 15:02:50 +00:00
|
|
|
)
|
|
|
|
new_backwards_extrems = txn.fetchall()
|
|
|
|
|
2018-02-07 17:34:35 +00:00
|
|
|
logger.info("[purge] replacing backward extremities: %r", new_backwards_extrems)
|
2017-05-10 16:46:41 +00:00
|
|
|
|
2016-07-15 13:23:15 +00:00
|
|
|
txn.execute(
|
2019-03-28 13:37:16 +00:00
|
|
|
"DELETE FROM event_backward_extremities WHERE room_id = ?", (room_id,)
|
2016-07-15 13:23:15 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
# Update backward extremeties
|
|
|
|
txn.executemany(
|
|
|
|
"INSERT INTO event_backward_extremities (room_id, event_id)"
|
|
|
|
" VALUES (?, ?)",
|
2019-03-28 13:37:16 +00:00
|
|
|
[(room_id, event_id) for event_id, in new_backwards_extrems],
|
2016-07-15 13:23:15 +00:00
|
|
|
)
|
|
|
|
|
2019-10-31 15:45:48 +00:00
|
|
|
logger.info("[purge] finding state groups referenced by deleted events")
|
2017-05-10 16:46:41 +00:00
|
|
|
|
2018-10-12 19:43:18 +00:00
|
|
|
# Get all state groups that are referenced by events that are to be
|
2019-11-01 11:32:20 +00:00
|
|
|
# deleted.
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.execute(
|
|
|
|
"""
|
2018-10-12 19:43:18 +00:00
|
|
|
SELECT DISTINCT state_group FROM events_to_purge
|
|
|
|
INNER JOIN event_to_state_groups USING (event_id)
|
2019-03-28 13:37:16 +00:00
|
|
|
"""
|
|
|
|
)
|
2016-09-05 13:49:08 +00:00
|
|
|
|
2018-10-19 15:06:59 +00:00
|
|
|
referenced_state_groups = set(sg for sg, in txn)
|
2018-10-12 19:43:18 +00:00
|
|
|
logger.info(
|
2019-03-28 13:37:16 +00:00
|
|
|
"[purge] found %i referenced state groups", len(referenced_state_groups)
|
2018-10-12 19:43:18 +00:00
|
|
|
)
|
2018-10-04 14:18:52 +00:00
|
|
|
|
2018-02-07 17:34:35 +00:00
|
|
|
logger.info("[purge] removing events from event_to_state_groups")
|
2018-02-14 11:02:22 +00:00
|
|
|
txn.execute(
|
|
|
|
"DELETE FROM event_to_state_groups "
|
|
|
|
"WHERE event_id IN (SELECT event_id from events_to_purge)"
|
2016-07-04 15:02:50 +00:00
|
|
|
)
|
2018-02-07 17:40:29 +00:00
|
|
|
for event_id, _ in event_rows:
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.call_after(self._get_state_group_for_event.invalidate, (event_id,))
|
2016-07-04 15:02:50 +00:00
|
|
|
|
|
|
|
# Delete all remote non-state events
|
|
|
|
for table in (
|
|
|
|
"events",
|
|
|
|
"event_json",
|
|
|
|
"event_auth",
|
|
|
|
"event_edges",
|
|
|
|
"event_forward_extremities",
|
|
|
|
"event_reference_hashes",
|
|
|
|
"event_search",
|
|
|
|
"rejections",
|
|
|
|
):
|
2018-02-13 16:51:21 +00:00
|
|
|
logger.info("[purge] removing events from %s", table)
|
2017-05-10 16:46:41 +00:00
|
|
|
|
2018-02-14 11:02:22 +00:00
|
|
|
txn.execute(
|
|
|
|
"DELETE FROM %s WHERE event_id IN ("
|
|
|
|
" SELECT event_id FROM events_to_purge WHERE should_delete"
|
2019-03-28 13:37:16 +00:00
|
|
|
")" % (table,)
|
2016-07-04 15:02:50 +00:00
|
|
|
)
|
|
|
|
|
2018-02-14 15:44:51 +00:00
|
|
|
# event_push_actions lacks an index on event_id, and has one on
|
|
|
|
# (room_id, event_id) instead.
|
2019-03-28 13:37:16 +00:00
|
|
|
for table in ("event_push_actions",):
|
2018-02-14 15:44:51 +00:00
|
|
|
logger.info("[purge] removing events from %s", table)
|
|
|
|
|
|
|
|
txn.execute(
|
|
|
|
"DELETE FROM %s WHERE room_id = ? AND event_id IN ("
|
|
|
|
" SELECT event_id FROM events_to_purge WHERE should_delete"
|
|
|
|
")" % (table,),
|
2019-03-28 13:37:16 +00:00
|
|
|
(room_id,),
|
2018-02-14 15:44:51 +00:00
|
|
|
)
|
|
|
|
|
2016-07-04 15:02:50 +00:00
|
|
|
# Mark all state and own events as outliers
|
2018-02-07 17:34:35 +00:00
|
|
|
logger.info("[purge] marking remaining events as outliers")
|
2018-02-14 11:02:22 +00:00
|
|
|
txn.execute(
|
2016-07-04 15:02:50 +00:00
|
|
|
"UPDATE events SET outlier = ?"
|
2018-02-14 11:02:22 +00:00
|
|
|
" WHERE event_id IN ("
|
|
|
|
" SELECT event_id FROM events_to_purge "
|
|
|
|
" WHERE NOT should_delete"
|
|
|
|
")",
|
|
|
|
(True,),
|
|
|
|
)
|
|
|
|
|
2018-02-09 12:13:34 +00:00
|
|
|
# synapse tries to take out an exclusive lock on room_depth whenever it
|
|
|
|
# persists events (because upsert), and once we run this update, we
|
|
|
|
# will block that for the rest of our transaction.
|
|
|
|
#
|
|
|
|
# So, let's stick it at the end so that we don't block event
|
|
|
|
# persistence.
|
2018-05-16 10:13:31 +00:00
|
|
|
#
|
|
|
|
# We do this by calculating the minimum depth of the backwards
|
|
|
|
# extremities. However, the events in event_backward_extremities
|
|
|
|
# are ones we don't have yet so we need to look at the events that
|
|
|
|
# point to it via event_edges table.
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.execute(
|
|
|
|
"""
|
2018-05-15 14:48:40 +00:00
|
|
|
SELECT COALESCE(MIN(depth), 0)
|
|
|
|
FROM event_backward_extremities AS eb
|
|
|
|
INNER JOIN event_edges AS eg ON eg.prev_event_id = eb.event_id
|
|
|
|
INNER JOIN events AS e ON e.event_id = eg.event_id
|
|
|
|
WHERE eb.room_id = ?
|
2019-03-28 13:37:16 +00:00
|
|
|
""",
|
|
|
|
(room_id,),
|
|
|
|
)
|
2019-10-31 15:43:24 +00:00
|
|
|
(min_depth,) = txn.fetchone()
|
2018-05-15 14:48:40 +00:00
|
|
|
|
|
|
|
logger.info("[purge] updating room_depth to %d", min_depth)
|
|
|
|
|
2018-02-09 12:13:34 +00:00
|
|
|
txn.execute(
|
|
|
|
"UPDATE room_depth SET min_depth = ? WHERE room_id = ?",
|
2019-03-28 13:37:16 +00:00
|
|
|
(min_depth, room_id),
|
2018-02-09 12:13:34 +00:00
|
|
|
)
|
|
|
|
|
2018-02-14 16:41:12 +00:00
|
|
|
# finally, drop the temp table. this will commit the txn in sqlite,
|
|
|
|
# so make sure to keep this actually last.
|
2019-03-28 13:37:16 +00:00
|
|
|
txn.execute("DROP TABLE events_to_purge")
|
2018-02-14 16:41:12 +00:00
|
|
|
|
2017-05-11 11:06:28 +00:00
|
|
|
logger.info("[purge] done")
|
2017-05-10 16:46:41 +00:00
|
|
|
|
2019-10-30 15:12:49 +00:00
|
|
|
return referenced_state_groups
|
2018-10-29 14:23:34 +00:00
|
|
|
|
2019-08-22 09:42:59 +00:00
|
|
|
def purge_room(self, room_id):
|
|
|
|
"""Deletes all record of a room
|
|
|
|
|
|
|
|
Args:
|
2019-11-04 13:36:57 +00:00
|
|
|
room_id (str)
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
Deferred[List[int]]: The list of state groups to delete.
|
2019-08-22 09:42:59 +00:00
|
|
|
"""
|
|
|
|
|
|
|
|
return self.runInteraction("purge_room", self._purge_room_txn, room_id)
|
|
|
|
|
|
|
|
def _purge_room_txn(self, txn, room_id):
|
2019-11-06 17:02:05 +00:00
|
|
|
# First we fetch all the state groups that should be deleted, before
|
|
|
|
# we delete that information.
|
|
|
|
txn.execute(
|
|
|
|
"""
|
|
|
|
SELECT DISTINCT state_group FROM events
|
|
|
|
INNER JOIN event_to_state_groups USING(event_id)
|
|
|
|
WHERE events.room_id = ?
|
|
|
|
""",
|
|
|
|
(room_id,),
|
|
|
|
)
|
|
|
|
|
|
|
|
state_groups = [row[0] for row in txn]
|
|
|
|
|
|
|
|
# Now we delete tables which lack an index on room_id but have one on event_id
|
2019-08-22 09:42:59 +00:00
|
|
|
for table in (
|
|
|
|
"event_auth",
|
|
|
|
"event_edges",
|
|
|
|
"event_push_actions_staging",
|
|
|
|
"event_reference_hashes",
|
|
|
|
"event_relations",
|
|
|
|
"event_to_state_groups",
|
|
|
|
"redactions",
|
|
|
|
"rejections",
|
|
|
|
"state_events",
|
|
|
|
):
|
|
|
|
logger.info("[purge] removing %s from %s", room_id, table)
|
|
|
|
|
|
|
|
txn.execute(
|
|
|
|
"""
|
|
|
|
DELETE FROM %s WHERE event_id IN (
|
|
|
|
SELECT event_id FROM events WHERE room_id=?
|
|
|
|
)
|
|
|
|
"""
|
|
|
|
% (table,),
|
|
|
|
(room_id,),
|
|
|
|
)
|
|
|
|
|
|
|
|
# and finally, the tables with an index on room_id (or no useful index)
|
|
|
|
for table in (
|
|
|
|
"current_state_events",
|
|
|
|
"event_backward_extremities",
|
|
|
|
"event_forward_extremities",
|
|
|
|
"event_json",
|
|
|
|
"event_push_actions",
|
|
|
|
"event_search",
|
|
|
|
"events",
|
|
|
|
"group_rooms",
|
|
|
|
"public_room_list_stream",
|
|
|
|
"receipts_graph",
|
|
|
|
"receipts_linearized",
|
|
|
|
"room_aliases",
|
|
|
|
"room_depth",
|
|
|
|
"room_memberships",
|
2019-09-04 12:04:27 +00:00
|
|
|
"room_stats_state",
|
|
|
|
"room_stats_current",
|
|
|
|
"room_stats_historical",
|
2019-08-22 09:42:59 +00:00
|
|
|
"room_stats_earliest_token",
|
|
|
|
"rooms",
|
|
|
|
"stream_ordering_to_exterm",
|
|
|
|
"users_in_public_rooms",
|
|
|
|
"users_who_share_private_rooms",
|
|
|
|
# no useful index, but let's clear them anyway
|
|
|
|
"appservice_room_list",
|
|
|
|
"e2e_room_keys",
|
|
|
|
"event_push_summary",
|
|
|
|
"pusher_throttle",
|
|
|
|
"group_summary_rooms",
|
|
|
|
"local_invites",
|
|
|
|
"room_account_data",
|
|
|
|
"room_tags",
|
|
|
|
):
|
|
|
|
logger.info("[purge] removing %s from %s", room_id, table)
|
|
|
|
txn.execute("DELETE FROM %s WHERE room_id=?" % (table,), (room_id,))
|
|
|
|
|
|
|
|
# Other tables we do NOT need to clear out:
|
|
|
|
#
|
|
|
|
# - blocked_rooms
|
|
|
|
# This is important, to make sure that we don't accidentally rejoin a blocked
|
|
|
|
# room after it was purged
|
|
|
|
#
|
|
|
|
# - user_directory
|
|
|
|
# This has a room_id column, but it is unused
|
|
|
|
#
|
|
|
|
|
|
|
|
# Other tables that we might want to consider clearing out include:
|
|
|
|
#
|
|
|
|
# - event_reports
|
|
|
|
# Given that these are intended for abuse management my initial
|
|
|
|
# inclination is to leave them in place.
|
|
|
|
#
|
|
|
|
# - current_state_delta_stream
|
|
|
|
# - ex_outlier_stream
|
|
|
|
# - room_tags_revisions
|
|
|
|
# The problem with these is that they are largeish and there is no room_id
|
|
|
|
# index on them. In any case we should be clearing out 'stream' tables
|
|
|
|
# periodically anyway (#5888)
|
|
|
|
|
|
|
|
# TODO: we could probably usefully do a bunch of cache invalidation here
|
|
|
|
|
|
|
|
logger.info("[purge] done")
|
|
|
|
|
2019-11-04 13:36:57 +00:00
|
|
|
return state_groups
|
|
|
|
|
2019-10-31 15:25:21 +00:00
|
|
|
def purge_unreferenced_state_groups(
|
2019-11-08 09:50:48 +00:00
|
|
|
self, room_id: str, state_groups_to_delete
|
2019-10-31 15:25:21 +00:00
|
|
|
) -> defer.Deferred:
|
2019-10-30 15:12:49 +00:00
|
|
|
"""Deletes no longer referenced state groups and de-deltas any state
|
|
|
|
groups that reference them.
|
2019-10-31 15:25:21 +00:00
|
|
|
|
|
|
|
Args:
|
|
|
|
room_id: The room the state groups belong to (must all be in the
|
|
|
|
same room).
|
2019-11-08 09:50:48 +00:00
|
|
|
state_groups_to_delete (Collection[int]): Set of all state groups
|
|
|
|
to delete.
|
2019-10-30 15:12:49 +00:00
|
|
|
"""
|
|
|
|
|
|
|
|
return self.runInteraction(
|
|
|
|
"purge_unreferenced_state_groups",
|
|
|
|
self._purge_unreferenced_state_groups,
|
|
|
|
room_id,
|
|
|
|
state_groups_to_delete,
|
|
|
|
)
|
|
|
|
|
|
|
|
def _purge_unreferenced_state_groups(self, txn, room_id, state_groups_to_delete):
|
|
|
|
logger.info(
|
|
|
|
"[purge] found %i state groups to delete", len(state_groups_to_delete)
|
|
|
|
)
|
|
|
|
|
|
|
|
rows = self._simple_select_many_txn(
|
|
|
|
txn,
|
|
|
|
table="state_group_edges",
|
|
|
|
column="prev_state_group",
|
|
|
|
iterable=state_groups_to_delete,
|
|
|
|
keyvalues={},
|
|
|
|
retcols=("state_group",),
|
|
|
|
)
|
|
|
|
|
|
|
|
remaining_state_groups = set(
|
|
|
|
row["state_group"]
|
|
|
|
for row in rows
|
|
|
|
if row["state_group"] not in state_groups_to_delete
|
|
|
|
)
|
|
|
|
|
|
|
|
logger.info(
|
|
|
|
"[purge] de-delta-ing %i remaining state groups",
|
|
|
|
len(remaining_state_groups),
|
|
|
|
)
|
|
|
|
|
|
|
|
# Now we turn the state groups that reference to-be-deleted state
|
|
|
|
# groups to non delta versions.
|
|
|
|
for sg in remaining_state_groups:
|
|
|
|
logger.info("[purge] de-delta-ing remaining state group %s", sg)
|
|
|
|
curr_state = self._get_state_groups_from_groups_txn(txn, [sg])
|
|
|
|
curr_state = curr_state[sg]
|
|
|
|
|
|
|
|
self._simple_delete_txn(
|
|
|
|
txn, table="state_groups_state", keyvalues={"state_group": sg}
|
|
|
|
)
|
|
|
|
|
|
|
|
self._simple_delete_txn(
|
|
|
|
txn, table="state_group_edges", keyvalues={"state_group": sg}
|
|
|
|
)
|
|
|
|
|
|
|
|
self._simple_insert_many_txn(
|
|
|
|
txn,
|
|
|
|
table="state_groups_state",
|
|
|
|
values=[
|
|
|
|
{
|
|
|
|
"state_group": sg,
|
|
|
|
"room_id": room_id,
|
|
|
|
"type": key[0],
|
|
|
|
"state_key": key[1],
|
|
|
|
"event_id": state_id,
|
|
|
|
}
|
|
|
|
for key, state_id in iteritems(curr_state)
|
|
|
|
],
|
|
|
|
)
|
|
|
|
|
|
|
|
logger.info("[purge] removing redundant state groups")
|
|
|
|
txn.executemany(
|
|
|
|
"DELETE FROM state_groups_state WHERE state_group = ?",
|
|
|
|
((sg,) for sg in state_groups_to_delete),
|
|
|
|
)
|
|
|
|
txn.executemany(
|
|
|
|
"DELETE FROM state_groups WHERE id = ?",
|
|
|
|
((sg,) for sg in state_groups_to_delete),
|
|
|
|
)
|
|
|
|
|
|
|
|
@defer.inlineCallbacks
|
|
|
|
def get_previous_state_groups(self, state_groups):
|
|
|
|
"""Fetch the previous groups of the given state groups.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
state_groups (Iterable[int])
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
Deferred[dict[int, int]]: mapping from state group to previous
|
|
|
|
state group.
|
|
|
|
"""
|
|
|
|
|
|
|
|
rows = yield self._simple_select_many_batch(
|
|
|
|
table="state_group_edges",
|
|
|
|
column="prev_state_group",
|
|
|
|
iterable=state_groups,
|
|
|
|
keyvalues={},
|
|
|
|
retcols=("prev_state_group", "state_group"),
|
|
|
|
desc="get_previous_state_groups",
|
|
|
|
)
|
|
|
|
|
|
|
|
return {row["state_group"]: row["prev_state_group"] for row in rows}
|
|
|
|
|
2019-11-04 13:36:57 +00:00
|
|
|
def purge_room_state(self, room_id, state_groups_to_delete):
|
2019-10-30 15:12:49 +00:00
|
|
|
"""Deletes all record of a room from state tables
|
|
|
|
|
|
|
|
Args:
|
|
|
|
room_id (str):
|
2019-11-04 13:36:57 +00:00
|
|
|
state_groups_to_delete (list[int]): State groups to delete
|
2019-10-30 15:12:49 +00:00
|
|
|
"""
|
|
|
|
|
|
|
|
return self.runInteraction(
|
2019-11-04 13:36:57 +00:00
|
|
|
"purge_room_state",
|
|
|
|
self._purge_room_state_txn,
|
|
|
|
room_id,
|
|
|
|
state_groups_to_delete,
|
2019-10-30 15:12:49 +00:00
|
|
|
)
|
|
|
|
|
2019-11-04 13:36:57 +00:00
|
|
|
def _purge_room_state_txn(self, txn, room_id, state_groups_to_delete):
|
2019-10-30 15:12:49 +00:00
|
|
|
# first we have to delete the state groups states
|
|
|
|
logger.info("[purge] removing %s from state_groups_state", room_id)
|
|
|
|
|
2019-11-04 13:36:57 +00:00
|
|
|
self._simple_delete_many_txn(
|
|
|
|
txn,
|
|
|
|
table="state_groups_state",
|
|
|
|
column="state_group",
|
|
|
|
iterable=state_groups_to_delete,
|
|
|
|
keyvalues={},
|
2019-10-30 15:12:49 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
# ... and the state group edges
|
|
|
|
logger.info("[purge] removing %s from state_group_edges", room_id)
|
|
|
|
|
2019-11-04 13:36:57 +00:00
|
|
|
self._simple_delete_many_txn(
|
|
|
|
txn,
|
|
|
|
table="state_group_edges",
|
|
|
|
column="state_group",
|
|
|
|
iterable=state_groups_to_delete,
|
|
|
|
keyvalues={},
|
2019-10-30 15:12:49 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
# ... and the state groups
|
|
|
|
logger.info("[purge] removing %s from state_groups", room_id)
|
|
|
|
|
2019-11-04 13:36:57 +00:00
|
|
|
self._simple_delete_many_txn(
|
|
|
|
txn,
|
|
|
|
table="state_groups",
|
|
|
|
column="id",
|
|
|
|
iterable=state_groups_to_delete,
|
|
|
|
keyvalues={},
|
2019-10-30 15:12:49 +00:00
|
|
|
)
|
|
|
|
|
2019-10-29 15:08:22 +00:00
|
|
|
async def is_event_after(self, event_id1, event_id2):
|
2017-04-12 13:36:20 +00:00
|
|
|
"""Returns True if event_id1 is after event_id2 in the stream
|
|
|
|
"""
|
2019-10-29 15:08:22 +00:00
|
|
|
to_1, so_1 = await self._get_event_ordering(event_id1)
|
|
|
|
to_2, so_2 = await self._get_event_ordering(event_id2)
|
2019-07-23 13:00:55 +00:00
|
|
|
return (to_1, so_1) > (to_2, so_2)
|
2017-04-11 16:34:09 +00:00
|
|
|
|
2018-03-01 15:30:57 +00:00
|
|
|
@cachedInlineCallbacks(max_entries=5000)
|
2017-04-11 16:34:09 +00:00
|
|
|
def _get_event_ordering(self, event_id):
|
|
|
|
res = yield self._simple_select_one(
|
|
|
|
table="events",
|
|
|
|
retcols=["topological_ordering", "stream_ordering"],
|
|
|
|
keyvalues={"event_id": event_id},
|
2019-03-28 13:37:16 +00:00
|
|
|
allow_none=True,
|
2017-04-11 16:34:09 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
if not res:
|
|
|
|
raise SynapseError(404, "Could not find event %s" % (event_id,))
|
|
|
|
|
2019-07-23 13:00:55 +00:00
|
|
|
return (int(res["topological_ordering"]), int(res["stream_ordering"]))
|
2016-03-31 09:33:02 +00:00
|
|
|
|
2017-06-15 11:47:05 +00:00
|
|
|
def get_all_updated_current_state_deltas(self, from_token, to_token, limit):
|
|
|
|
def get_all_updated_current_state_deltas_txn(txn):
|
|
|
|
sql = """
|
|
|
|
SELECT stream_id, room_id, type, state_key, event_id
|
|
|
|
FROM current_state_delta_stream
|
|
|
|
WHERE ? < stream_id AND stream_id <= ?
|
|
|
|
ORDER BY stream_id ASC LIMIT ?
|
|
|
|
"""
|
|
|
|
txn.execute(sql, (from_token, to_token, limit))
|
|
|
|
return txn.fetchall()
|
2019-03-28 13:37:16 +00:00
|
|
|
|
2017-06-15 11:47:05 +00:00
|
|
|
return self.runInteraction(
|
|
|
|
"get_all_updated_current_state_deltas",
|
|
|
|
get_all_updated_current_state_deltas_txn,
|
|
|
|
)
|
|
|
|
|
2019-11-01 11:47:28 +00:00
|
|
|
def insert_labels_for_event_txn(
|
|
|
|
self, txn, event_id, labels, room_id, topological_ordering
|
|
|
|
):
|
2019-11-01 10:30:51 +00:00
|
|
|
"""Store the mapping between an event's ID and its labels, with one row per
|
|
|
|
(event_id, label) tuple.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
txn (LoggingTransaction): The transaction to execute.
|
|
|
|
event_id (str): The event's ID.
|
|
|
|
labels (list[str]): A list of text labels.
|
2019-11-01 11:47:28 +00:00
|
|
|
room_id (str): The ID of the room the event was sent to.
|
|
|
|
topological_ordering (int): The position of the event in the room's topology.
|
2019-11-01 10:30:51 +00:00
|
|
|
"""
|
2019-10-29 18:35:49 +00:00
|
|
|
return self._simple_insert_many_txn(
|
|
|
|
txn=txn,
|
|
|
|
table="event_labels",
|
2019-11-01 11:47:28 +00:00
|
|
|
values=[
|
|
|
|
{
|
|
|
|
"event_id": event_id,
|
|
|
|
"label": label,
|
|
|
|
"room_id": room_id,
|
|
|
|
"topological_ordering": topological_ordering,
|
|
|
|
}
|
|
|
|
for label in labels
|
|
|
|
],
|
2019-10-29 18:35:49 +00:00
|
|
|
)
|
|
|
|
|
2017-04-11 17:35:45 +00:00
|
|
|
|
2019-03-28 13:37:16 +00:00
|
|
|
AllNewEventsResult = namedtuple(
|
|
|
|
"AllNewEventsResult",
|
|
|
|
[
|
|
|
|
"new_forward_events",
|
|
|
|
"new_backfill_events",
|
|
|
|
"forward_ex_outliers",
|
|
|
|
"backward_ex_outliers",
|
|
|
|
],
|
|
|
|
)
|