MatrixSynapse/synapse/storage/state.py

271 lines
8.7 KiB
Python
Raw Normal View History

2014-10-15 11:04:55 +02:00
# -*- coding: utf-8 -*-
2015-01-06 14:21:39 +01:00
# Copyright 2014, 2015 OpenMarket Ltd
2014-10-15 11:04:55 +02: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.
from ._base import SQLBaseStore, cached
2014-10-15 11:04:55 +02:00
2015-03-20 14:52:56 +01:00
from twisted.internet import defer
from synapse.util.stringutils import random_string
2015-01-06 12:18:12 +01:00
import logging
logger = logging.getLogger(__name__)
2014-10-15 11:04:55 +02:00
class StateStore(SQLBaseStore):
""" Keeps track of the state at a given event.
This is done by the concept of `state groups`. Every event is a assigned
a state group (identified by an arbitrary string), which references a
collection of state events. The current state of an event is then the
collection of state events referenced by the event's state group.
Hence, every change in the current state causes a new state group to be
generated. However, if no change happens (e.g., if we get a message event
with only one parent it inherits the state group from its parent.)
There are three tables:
* `state_groups`: Stores group name, first event with in the group and
room id.
* `event_to_state_groups`: Maps events to state groups.
* `state_groups_state`: Maps state group to state events.
"""
2014-10-15 11:04:55 +02:00
2015-05-13 12:13:31 +02:00
@defer.inlineCallbacks
2014-10-15 11:04:55 +02:00
def get_state_groups(self, event_ids):
""" Get the state groups for the given list of event_ids
The return value is a dict mapping group names to lists of events.
"""
def f(txn):
groups = set()
for event_id in event_ids:
group = self._simple_select_one_onecol_txn(
txn,
table="event_to_state_groups",
keyvalues={"event_id": event_id},
retcol="state_group",
2014-10-15 11:04:55 +02:00
allow_none=True,
)
if group:
groups.add(group)
2014-10-15 11:04:55 +02:00
res = {}
for group in groups:
state_ids = self._simple_select_onecol_txn(
txn,
table="state_groups_state",
keyvalues={"state_group": group},
retcol="event_id",
)
2015-01-06 12:18:12 +01:00
2015-05-13 12:13:31 +02:00
res[group] = state_ids
return res
2014-10-15 11:04:55 +02:00
2015-05-13 12:13:31 +02:00
states = yield self.runInteraction(
"get_state_groups",
f,
)
2014-10-15 11:04:55 +02:00
2015-06-03 15:45:55 +02:00
state_list = yield defer.gatherResults(
[
2015-06-03 15:45:55 +02:00
self._fetch_events_for_group(group, vals)
for group, vals in states.items()
],
2015-05-13 12:29:03 +02:00
consumeErrors=True,
)
2015-06-03 15:45:55 +02:00
defer.returnValue(dict(state_list))
@cached(num_args=1)
def _fetch_events_for_group(self, key, events):
2015-06-03 15:45:55 +02:00
return self._get_events(
events, get_prev_content=False
).addCallback(
lambda evs: (key, evs)
2015-06-03 15:45:55 +02:00
)
2015-05-13 12:13:31 +02:00
def _store_state_groups_txn(self, txn, event, context):
2015-06-25 18:18:19 +02:00
return self._store_mult_state_groups_txn(txn, [(event, context)])
2015-06-25 18:18:19 +02:00
def _store_mult_state_groups_txn(self, txn, events_and_contexts):
state_groups = {}
for event, context in events_and_contexts:
if context.current_state is None:
continue
2015-06-25 18:18:19 +02:00
if context.state_group is not None:
state_groups[event.event_id] = context.state_group
continue
state_events = dict(context.current_state)
if event.is_state():
state_events[(event.type, event.state_key)] = event
state_group = self._state_groups_id_gen.get_next_txn(txn)
self._simple_insert_txn(
2014-10-15 11:04:55 +02:00
txn,
table="state_groups",
values={
"id": state_group,
2014-10-15 11:04:55 +02:00
"room_id": event.room_id,
"event_id": event.event_id,
},
2014-10-15 11:04:55 +02:00
)
2015-05-05 16:13:25 +02:00
self._simple_insert_many_txn(
txn,
table="state_groups_state",
values=[
{
2014-10-15 11:04:55 +02:00
"state_group": state_group,
"room_id": state.room_id,
"type": state.type,
"state_key": state.state_key,
"event_id": state.event_id,
2015-05-05 16:13:25 +02:00
}
for state in state_events.values()
],
)
2015-06-25 18:18:19 +02:00
state_groups[event.event_id] = state_group
2014-10-15 11:04:55 +02:00
2015-06-25 18:18:19 +02:00
self._simple_insert_many_txn(
2014-10-15 11:04:55 +02:00
txn,
table="event_to_state_groups",
2015-06-25 18:18:19 +02:00
values=[
{
"state_group": state_groups[event.event_id],
"event_id": event.event_id,
}
for event, context in events_and_contexts
if context.current_state is not None
],
2014-10-15 11:04:55 +02:00
)
2015-03-20 14:52:56 +01:00
@defer.inlineCallbacks
def get_current_state(self, room_id, event_type=None, state_key=""):
if event_type and state_key is not None:
result = yield self.get_current_state_for_key(
room_id, event_type, state_key
)
defer.returnValue(result)
def f(txn):
sql = (
2015-04-30 19:49:26 +02:00
"SELECT event_id FROM current_state_events"
" WHERE room_id = ? "
)
if event_type and state_key is not None:
2015-04-30 19:49:26 +02:00
sql += " AND type = ? AND state_key = ? "
args = (room_id, event_type, state_key)
elif event_type:
2015-04-30 19:49:26 +02:00
sql += " AND type = ?"
args = (room_id, event_type)
else:
args = (room_id, )
2015-03-20 14:52:56 +01:00
txn.execute(sql, args)
results = txn.fetchall()
2015-03-20 14:52:56 +01:00
return [r[0] for r in results]
2015-03-20 14:52:56 +01:00
event_ids = yield self.runInteraction("get_current_state", f)
events = yield self._get_events(event_ids, get_prev_content=False)
2015-03-20 14:52:56 +01:00
defer.returnValue(events)
@cached(num_args=3)
@defer.inlineCallbacks
def get_current_state_for_key(self, room_id, event_type, state_key):
def f(txn):
sql = (
"SELECT event_id FROM current_state_events"
" WHERE room_id = ? AND type = ? AND state_key = ?"
)
args = (room_id, event_type, state_key)
txn.execute(sql, args)
results = txn.fetchall()
return [r[0] for r in results]
event_ids = yield self.runInteraction("get_current_state_for_key", f)
events = yield self._get_events(event_ids, get_prev_content=False)
defer.returnValue(events)
@defer.inlineCallbacks
def get_state_for_events(self, room_id, event_ids):
def f(txn):
groups = set()
event_to_group = {}
for event_id in event_ids:
# TODO: Remove this loop.
group = self._simple_select_one_onecol_txn(
txn,
table="event_to_state_groups",
keyvalues={"event_id": event_id},
retcol="state_group",
allow_none=True,
)
if group:
event_to_group[event_id] = group
groups.add(group)
group_to_state_ids = {}
for group in groups:
state_ids = self._simple_select_onecol_txn(
txn,
table="state_groups_state",
keyvalues={"state_group": group},
retcol="event_id",
)
group_to_state_ids[group] = state_ids
return event_to_group, group_to_state_ids
res = yield self.runInteraction(
"annotate_events_with_state_groups",
f,
)
event_to_group, group_to_state_ids = res
state_list = yield defer.gatherResults(
[
self._fetch_events_for_group(group, vals)
for group, vals in group_to_state_ids.items()
],
consumeErrors=True,
)
state_dict = {
group: {
(ev.type, ev.state_key): ev
for ev in state
}
for group, state in state_list
}
defer.returnValue([
state_dict.get(event_to_group.get(event, None), None)
for event in event_ids
])
def _make_group_id(clock):
return str(int(clock.time_msec())) + random_string(5)