synapse-old/synapse/handlers/events.py

182 lines
6.2 KiB
Python
Raw Normal View History

2014-08-12 08:10:52 -06:00
# -*- coding: utf-8 -*-
2016-01-06 21:26:29 -07:00
# Copyright 2014-2016 OpenMarket Ltd
2014-08-12 08:10:52 -06: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-07-09 00:09:20 -06:00
import logging
import random
from synapse.api.constants import EventTypes, Membership
from synapse.api.errors import AuthError, SynapseError
2016-02-15 10:10:40 -07:00
from synapse.events import EventBase
from synapse.logging.utils import log_function
2018-07-09 00:09:20 -06:00
from synapse.types import UserID
from synapse.visibility import filter_events_for_client
2014-08-12 08:10:52 -06:00
from ._base import BaseHandler
logger = logging.getLogger(__name__)
class EventStreamHandler(BaseHandler):
2014-08-12 08:10:52 -06:00
def __init__(self, hs):
super(EventStreamHandler, self).__init__(hs)
# Count of active streams per user
self._streams_per_user = {}
# Grace timers per user to delay the "stopped" signal
self._stop_timer_per_user = {}
self.distributor = hs.get_distributor()
self.distributor.declare("started_user_eventstream")
self.distributor.declare("stopped_user_eventstream")
self.clock = hs.get_clock()
self.notifier = hs.get_notifier()
self.state = hs.get_state_handler()
self._server_notices_sender = hs.get_server_notices_sender()
self._event_serializer = hs.get_event_client_serializer()
2014-08-12 08:10:52 -06:00
@log_function
2019-12-05 10:58:25 -07:00
async def get_stream(
2019-06-20 03:32:02 -06:00
self,
auth_user_id,
pagin_config,
timeout=0,
as_client_event=True,
affect_presence=True,
only_keys=None,
room_id=None,
is_guest=False,
):
"""Fetches the events stream for a given user.
If `only_keys` is not None, events from keys will be sent down.
"""
if room_id:
2019-12-05 10:58:25 -07:00
blocked = await self.store.is_room_blocked(room_id)
if blocked:
raise SynapseError(403, "This room has been blocked on this server")
# send any outstanding server notices to the user.
2019-12-05 10:58:25 -07:00
await self._server_notices_sender.on_user_syncing(auth_user_id)
auth_user = UserID.from_string(auth_user_id)
presence_handler = self.hs.get_presence_handler()
2014-08-12 08:10:52 -06:00
2019-12-05 10:58:25 -07:00
context = await presence_handler.user_syncing(
2019-06-20 03:32:02 -06:00
auth_user_id, affect_presence=affect_presence
2016-02-15 10:10:40 -07:00
)
with context:
if timeout:
# If they've set a timeout set a minimum limit.
timeout = max(timeout, 500)
# Add some randomness to this value to try and mitigate against
# thundering herds on restart.
2016-02-02 10:18:50 -07:00
timeout = random.randint(int(timeout * 0.9), int(timeout * 1.1))
2019-12-05 10:58:25 -07:00
events, tokens = await self.notifier.get_events_for(
2019-06-20 03:32:02 -06:00
auth_user,
pagin_config,
timeout,
only_keys=only_keys,
2019-06-20 03:32:02 -06:00
is_guest=is_guest,
explicit_room_id=room_id,
)
2016-02-15 10:10:40 -07:00
# When the user joins a new room, or another user joins a currently
# joined room, we need to send down presence for those users.
to_add = []
for event in events:
if not isinstance(event, EventBase):
continue
if event.type == EventTypes.Member:
if event.membership != Membership.JOIN:
continue
# Send down presence.
if event.state_key == auth_user_id:
# Send down presence for everyone in the room.
2019-12-05 10:58:25 -07:00
users = await self.state.get_current_users_in_room(
2019-06-20 03:32:02 -06:00
event.room_id
2016-02-15 10:10:40 -07:00
)
2019-12-05 10:58:25 -07:00
states = await presence_handler.get_states(users, as_event=True)
2016-02-15 10:10:40 -07:00
to_add.extend(states)
else:
2019-12-05 10:58:25 -07:00
ev = await presence_handler.get_state(
2019-06-20 03:32:02 -06:00
UserID.from_string(event.state_key), as_event=True
2016-02-15 10:10:40 -07:00
)
to_add.append(ev)
events.extend(to_add)
time_now = self.clock.time_msec()
2019-12-05 10:58:25 -07:00
chunks = await self._event_serializer.serialize_events(
2019-06-20 03:32:02 -06:00
events,
time_now,
as_client_event=as_client_event,
# We don't bundle "live" events, as otherwise clients
# will end up double counting annotations.
bundle_aggregations=False,
)
chunk = {
"chunk": chunks,
"start": tokens[0].to_string(),
"end": tokens[1].to_string(),
}
return chunk
class EventHandler(BaseHandler):
2019-10-23 10:25:54 -06:00
def __init__(self, hs):
super(EventHandler, self).__init__(hs)
self.storage = hs.get_storage()
2019-12-05 10:58:25 -07:00
async def get_event(self, user, room_id, event_id):
"""Retrieve a single specified event.
Args:
user (synapse.types.UserID): The user requesting the event
room_id (str|None): The expected room id. We'll return None if the
event's room does not match.
event_id (str): The event ID to obtain.
Returns:
dict: An event, or None if there is no event matching this ID.
Raises:
SynapseError if there was a problem retrieving this event, or
AuthError if the user does not have the rights to inspect this
event.
"""
2019-12-05 10:58:25 -07:00
event = await self.store.get_event(event_id, check_room_id=room_id)
if not event:
return None
2019-12-05 10:58:25 -07:00
users = await self.store.get_users_in_room(event.room_id)
is_peeking = user.to_string() not in users
2019-12-05 10:58:25 -07:00
filtered = await filter_events_for_client(
2019-10-23 10:25:54 -06:00
self.storage, user.to_string(), [event], is_peeking=is_peeking
)
if not filtered:
2019-06-20 03:32:02 -06:00
raise AuthError(403, "You don't have permission to access that event.")
return event