synapse-old/synapse/handlers/presence.py

1330 lines
48 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.
2016-02-15 10:10:40 -07:00
"""This module is responsible for keeping track of presence status of local
and remote users.
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
The methods that define policy are:
- PresenceHandler._update_states
- PresenceHandler._handle_timeouts
- should_notify
"""
2018-07-09 00:09:20 -06:00
import logging
2016-02-15 10:10:40 -07:00
from contextlib import contextmanager
from typing import Dict, Set
2016-02-15 10:10:40 -07:00
2018-07-09 00:09:20 -06:00
from six import iteritems, itervalues
from prometheus_client import Counter
from twisted.internet import defer
import synapse.metrics
from synapse.api.constants import EventTypes, Membership, PresenceState
2018-07-09 00:09:20 -06:00
from synapse.api.errors import SynapseError
from synapse.logging.context import run_in_background
from synapse.logging.utils import log_function
2018-07-09 00:09:20 -06:00
from synapse.metrics import LaterGauge
from synapse.metrics.background_process_metrics import run_as_background_process
2016-02-15 10:10:40 -07:00
from synapse.storage.presence import UserPresenceState
2018-07-09 00:09:20 -06:00
from synapse.types import UserID, get_domain_from_id
from synapse.util.async_helpers import Linearizer
2018-07-09 00:09:20 -06:00
from synapse.util.caches.descriptors import cachedInlineCallbacks
2016-02-19 04:50:48 -07:00
from synapse.util.metrics import Measure
2016-02-15 10:10:40 -07:00
from synapse.util.wheel_timer import WheelTimer
2018-05-21 18:47:37 -06:00
2014-08-12 08:10:52 -06:00
logger = logging.getLogger(__name__)
2018-05-21 18:47:37 -06:00
notified_presence_counter = Counter("synapse_handler_presence_notified_presence", "")
2018-05-22 16:32:57 -06:00
federation_presence_out_counter = Counter(
2019-06-20 03:32:02 -06:00
"synapse_handler_presence_federation_presence_out", ""
)
2018-05-21 18:47:37 -06:00
presence_updates_counter = Counter("synapse_handler_presence_presence_updates", "")
timers_fired_counter = Counter("synapse_handler_presence_timers_fired", "")
2019-06-20 03:32:02 -06:00
federation_presence_counter = Counter(
"synapse_handler_presence_federation_presence", ""
)
2018-05-21 18:47:37 -06:00
bump_active_time_counter = Counter("synapse_handler_presence_bump_active_time", "")
2016-02-19 02:50:54 -07:00
2018-05-21 18:47:37 -06:00
get_updates_counter = Counter("synapse_handler_presence_get_updates", "", ["type"])
2018-05-22 16:32:57 -06:00
notify_reason_counter = Counter(
2019-06-20 03:32:02 -06:00
"synapse_handler_presence_notify_reason", "", ["reason"]
)
2018-05-22 16:32:57 -06:00
state_transition_counter = Counter(
"synapse_handler_presence_state_transition", "", ["from", "to"]
2016-09-06 04:31:01 -06:00
)
2016-09-05 07:12:11 -06:00
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
# If a user was last active in the last LAST_ACTIVE_GRANULARITY, consider them
# "currently_active"
2016-02-02 10:18:50 -07:00
LAST_ACTIVE_GRANULARITY = 60 * 1000
2016-02-15 10:10:40 -07:00
# How long to wait until a new /events or /sync request before assuming
# the client has gone.
SYNC_ONLINE_TIMEOUT = 30 * 1000
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
# How long to wait before marking the user as idle. Compared against last active
IDLE_TIMER = 5 * 60 * 1000
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
# How often we expect remote servers to resend us presence.
FEDERATION_TIMEOUT = 30 * 60 * 1000
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
# How often to resend presence to remote servers
FEDERATION_PING_INTERVAL = 25 * 60 * 1000
2014-08-12 08:10:52 -06:00
# How long we will wait before assuming that the syncs from an external process
# are dead.
EXTERNAL_PROCESS_EXPIRY = 5 * 60 * 1000
2016-02-15 10:10:40 -07:00
assert LAST_ACTIVE_GRANULARITY < IDLE_TIMER
2014-08-12 08:10:52 -06:00
class PresenceHandler(object):
2014-08-12 08:10:52 -06:00
def __init__(self, hs):
"""
Args:
hs (synapse.server.HomeServer):
"""
2018-08-13 00:47:46 -06:00
self.hs = hs
self.is_mine = hs.is_mine
self.is_mine_id = hs.is_mine_id
self.server_name = hs.hostname
self.clock = hs.get_clock()
2016-02-15 10:10:40 -07:00
self.store = hs.get_datastore()
self.wheel_timer = WheelTimer()
self.notifier = hs.get_notifier()
2016-11-16 07:28:03 -07:00
self.federation = hs.get_federation_sender()
self.state = hs.get_state_handler()
federation_registry = hs.get_federation_registry()
2019-06-20 03:32:02 -06:00
federation_registry.register_edu_handler("m.presence", self.incoming_presence)
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
active_presence = self.store.take_presence_startup_info()
# A dictionary of the current state of users. This is prefilled with
# non-offline presence from the DB. We should fetch from the DB if
# we can't find a users presence in here.
2019-06-20 03:32:02 -06:00
self.user_to_current_state = {state.user_id: state for state in active_presence}
2016-02-15 10:10:40 -07:00
2018-05-21 18:47:37 -06:00
LaterGauge(
2019-06-20 03:32:02 -06:00
"synapse_handlers_presence_user_to_current_state_size",
"",
[],
lambda: len(self.user_to_current_state),
2018-05-22 09:56:03 -06:00
)
2016-02-15 10:10:40 -07:00
now = self.clock.time_msec()
for state in active_presence:
self.wheel_timer.insert(
2019-06-20 03:32:02 -06:00
now=now, obj=state.user_id, then=state.last_active_ts + IDLE_TIMER
2016-02-15 10:10:40 -07:00
)
self.wheel_timer.insert(
now=now,
obj=state.user_id,
2016-02-18 03:11:43 -07:00
then=state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT,
2016-02-15 10:10:40 -07:00
)
if self.is_mine_id(state.user_id):
2016-02-15 10:10:40 -07:00
self.wheel_timer.insert(
now=now,
obj=state.user_id,
2016-02-18 03:11:43 -07:00
then=state.last_federation_update_ts + FEDERATION_PING_INTERVAL,
2016-02-15 10:10:40 -07:00
)
else:
self.wheel_timer.insert(
now=now,
obj=state.user_id,
2016-02-18 03:11:43 -07:00
then=state.last_federation_update_ts + FEDERATION_TIMEOUT,
2016-02-15 10:10:40 -07:00
)
# Set of users who have presence in the `user_to_current_state` that
# have not yet been persisted
self.unpersisted_users_changes = set()
hs.get_reactor().addSystemEventTrigger(
"before",
"shutdown",
run_as_background_process,
"presence.on_shutdown",
self._on_shutdown,
)
2016-02-15 10:10:40 -07:00
self.serial_to_user = {}
self._next_serial = 1
# Keeps track of the number of *ongoing* syncs on this process. While
# this is non zero a user will never go offline.
2016-02-15 10:10:40 -07:00
self.user_to_num_current_syncs = {}
# Keeps track of the number of *ongoing* syncs on other processes.
# While any sync is ongoing on another process the user will never
# go offline.
# Each process has a unique identifier and an update frequency. If
# no update is received from that process within the update period then
# we assume that all the sync requests on that process have stopped.
# Stored as a dict from process_id to set of user_id, and a dict of
# process_id to millisecond timestamp last updated.
self.external_process_to_current_syncs = {} # type: Dict[int, Set[str]]
self.external_process_last_updated_ms = {} # type: Dict[int, int]
self.external_sync_linearizer = Linearizer(name="external_sync_linearizer")
2016-02-15 10:10:40 -07:00
# Start a LoopingCall in 30s that fires every 5s.
# The initial delay is to allow disconnected clients a chance to
# reconnect before we treat them as offline.
def run_timeout_handler():
return run_as_background_process(
"handle_presence_timeouts", self._handle_timeouts
)
2019-06-20 03:32:02 -06:00
self.clock.call_later(30, self.clock.looping_call, run_timeout_handler, 5000)
def run_persister():
return run_as_background_process(
"persist_presence_changes", self._persist_unpersisted_changes
)
2019-06-20 03:32:02 -06:00
self.clock.call_later(60, self.clock.looping_call, run_persister, 60 * 1000)
2019-06-20 03:32:02 -06:00
LaterGauge(
"synapse_handlers_presence_wheel_timer_size",
"",
[],
lambda: len(self.wheel_timer),
)
2016-02-19 02:50:54 -07:00
# Used to handle sending of presence to newly joined users/servers
if hs.config.use_presence:
self.notifier.add_replication_callback(self.notify_new_event)
# Presence is best effort and quickly heals itself, so lets just always
# stream from the current state when we restart.
self._event_pos = self.store.get_current_events_token()
self._event_processing = False
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
def _on_shutdown(self):
"""Gets called when shutting down. This lets us persist any updates that
we haven't yet persisted, e.g. updates that only changes some internal
timers. This allows changes to persist across startup without having to
persist every single change.
If this does not run it simply means that some of the timers will fire
earlier than they should when synapse is restarted. This affect of this
is some spurious presence changes that will self-correct.
"""
2018-08-13 00:47:46 -06:00
# If the DB pool has already terminated, don't try updating
if not self.hs.get_db_pool().running:
return
2016-02-15 10:10:40 -07:00
logger.info(
2016-09-13 06:26:33 -06:00
"Performing _on_shutdown. Persisting %d unpersisted changes",
2019-06-20 03:32:02 -06:00
len(self.user_to_current_state),
2016-02-15 10:10:40 -07:00
)
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
if self.unpersisted_users_changes:
2019-06-20 03:32:02 -06:00
yield self.store.update_presence(
[
self.user_to_current_state[user_id]
for user_id in self.unpersisted_users_changes
]
)
2016-02-15 10:10:40 -07:00
logger.info("Finished _on_shutdown")
2014-08-12 08:10:52 -06:00
@defer.inlineCallbacks
def _persist_unpersisted_changes(self):
"""We periodically persist the unpersisted changes, as otherwise they
may stack up and slow down shutdown times.
"""
unpersisted = self.unpersisted_users_changes
self.unpersisted_users_changes = set()
2016-08-30 08:50:20 -06:00
if unpersisted:
2019-09-03 05:44:14 -06:00
logger.info("Persisting %d unpersisted presence updates", len(unpersisted))
2019-06-20 03:32:02 -06:00
yield self.store.update_presence(
[self.user_to_current_state[user_id] for user_id in unpersisted]
)
2014-08-12 08:10:52 -06:00
@defer.inlineCallbacks
2016-02-15 10:10:40 -07:00
def _update_states(self, new_states):
"""Updates presence of users. Sets the appropriate timeouts. Pokes
the notifier and federation if and only if the changed presence state
should be sent to clients/servers.
"""
now = self.clock.time_msec()
2014-08-12 08:10:52 -06:00
2016-02-19 04:50:48 -07:00
with Measure(self.clock, "presence_update_states"):
2014-08-12 08:10:52 -06:00
2016-02-19 04:50:48 -07:00
# NOTE: We purposefully don't yield between now and when we've
# calculated what we want to do with the new states, to avoid races.
2016-02-19 04:50:48 -07:00
to_notify = {} # Changes we want to notify everyone about
to_federation_ping = {} # These need sending keep-alives
2014-09-02 06:30:36 -06:00
2016-09-09 07:26:05 -06:00
# Only bother handling the last presence change for each user
new_states_dict = {}
for new_state in new_states:
new_states_dict[new_state.user_id] = new_state
new_state = new_states_dict.values()
2016-02-19 04:50:48 -07:00
for new_state in new_states:
user_id = new_state.user_id
2015-08-18 03:30:07 -06:00
2016-02-19 04:50:48 -07:00
# Its fine to not hit the database here, as the only thing not in
# the current state cache are OFFLINE states, where the only field
# of interest is last_active which is safe enough to assume is 0
# here.
prev_state = self.user_to_current_state.get(
user_id, UserPresenceState.default(user_id)
)
2014-08-12 08:10:52 -06:00
2016-02-19 04:50:48 -07:00
new_state, should_notify, should_ping = handle_update(
2019-06-20 03:32:02 -06:00
prev_state,
new_state,
is_mine=self.is_mine_id(user_id),
2016-02-19 04:50:48 -07:00
wheel_timer=self.wheel_timer,
2019-06-20 03:32:02 -06:00
now=now,
2016-02-19 04:50:48 -07:00
)
2016-02-15 10:10:40 -07:00
2016-02-19 04:50:48 -07:00
self.user_to_current_state[user_id] = new_state
2016-02-19 04:50:48 -07:00
if should_notify:
to_notify[user_id] = new_state
elif should_ping:
to_federation_ping[user_id] = new_state
2016-02-19 02:50:54 -07:00
2016-02-19 04:50:48 -07:00
# TODO: We should probably ensure there are no races hereafter
2016-02-15 10:10:40 -07:00
2018-05-21 18:47:37 -06:00
presence_updates_counter.inc(len(new_states))
2016-02-15 10:10:40 -07:00
2016-02-19 04:50:48 -07:00
if to_notify:
2018-05-21 18:47:37 -06:00
notified_presence_counter.inc(len(to_notify))
yield self._persist_and_notify(list(to_notify.values()))
2016-02-19 04:50:48 -07:00
self.unpersisted_users_changes |= set(s.user_id for s in new_states)
self.unpersisted_users_changes -= set(to_notify.keys())
2016-02-19 04:50:48 -07:00
to_federation_ping = {
2019-06-20 03:32:02 -06:00
user_id: state
for user_id, state in to_federation_ping.items()
2016-02-19 04:50:48 -07:00
if user_id not in to_notify
}
if to_federation_ping:
2018-05-21 18:47:37 -06:00
federation_presence_out_counter.inc(len(to_federation_ping))
self._push_to_remotes(to_federation_ping.values())
2016-02-15 10:10:40 -07:00
def _handle_timeouts(self):
"""Checks the presence of users that have timed out and updates as
appropriate.
"""
logger.debug("Handling presence timeouts")
2016-02-15 10:10:40 -07:00
now = self.clock.time_msec()
# Fetch the list of users that *may* have timed out. Things may have
# changed since the timeout was set, so we won't necessarily have to
# take any action.
users_to_check = set(self.wheel_timer.fetch(now))
# Check whether the lists of syncing processes from an external
# process have expired.
expired_process_ids = [
2019-06-20 03:32:02 -06:00
process_id
for process_id, last_update in self.external_process_last_updated_ms.items()
if now - last_update > EXTERNAL_PROCESS_EXPIRY
]
for process_id in expired_process_ids:
# For each expired process drop tracking info and check the users
# that were syncing on that process to see if they need to be timed
# out.
users_to_check.update(
self.external_process_to_current_syncs.pop(process_id, ())
)
self.external_process_last_updated_ms.pop(process_id)
states = [
2019-06-20 03:32:02 -06:00
self.user_to_current_state.get(user_id, UserPresenceState.default(user_id))
for user_id in users_to_check
]
timers_fired_counter.inc(len(states))
changes = handle_timeouts(
states,
is_mine_fn=self.is_mine_id,
syncing_user_ids=self.get_currently_syncing_users(),
now=now,
)
2015-08-18 03:30:07 -06:00
return self._update_states(changes)
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
def bump_presence_active_time(self, user):
"""We've seen the user do something that indicates they're interacting
with the app.
2015-08-18 03:30:07 -06:00
"""
# If presence is disabled, no-op
if not self.hs.config.use_presence:
return
2016-02-15 10:10:40 -07:00
user_id = user.to_string()
2016-02-19 04:32:04 -07:00
bump_active_time_counter.inc()
2016-02-15 10:10:40 -07:00
prev_state = yield self.current_state_for_user(user_id)
2019-06-20 03:32:02 -06:00
new_fields = {"last_active_ts": self.clock.time_msec()}
if prev_state.state == PresenceState.UNAVAILABLE:
new_fields["state"] = PresenceState.ONLINE
yield self._update_states([prev_state.copy_and_replace(**new_fields)])
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
def user_syncing(self, user_id, affect_presence=True):
"""Returns a context manager that should surround any stream requests
from the user.
2016-02-15 10:10:40 -07:00
This allows us to keep track of who is currently streaming and who isn't
without having to have timers outside of this module to avoid flickering
when users disconnect/reconnect.
2016-02-15 10:10:40 -07:00
Args:
user_id (str)
affect_presence (bool): If false this function will be a no-op.
Useful for streams that are not associated with an actual
client that is being used by a user.
"""
# Override if it should affect the user's presence, if presence is
# disabled.
if not self.hs.config.use_presence:
affect_presence = False
2016-02-15 10:10:40 -07:00
if affect_presence:
curr_sync = self.user_to_num_current_syncs.get(user_id, 0)
self.user_to_num_current_syncs[user_id] = curr_sync + 1
prev_state = yield self.current_state_for_user(user_id)
if prev_state.state == PresenceState.OFFLINE:
# If they're currently offline then bring them online, otherwise
# just update the last sync times.
2019-06-20 03:32:02 -06:00
yield self._update_states(
[
prev_state.copy_and_replace(
state=PresenceState.ONLINE,
last_active_ts=self.clock.time_msec(),
last_user_sync_ts=self.clock.time_msec(),
)
]
)
2016-02-15 10:10:40 -07:00
else:
2019-06-20 03:32:02 -06:00
yield self._update_states(
[
prev_state.copy_and_replace(
last_user_sync_ts=self.clock.time_msec()
)
]
)
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
def _end():
try:
2016-02-15 10:10:40 -07:00
self.user_to_num_current_syncs[user_id] -= 1
2016-02-15 10:10:40 -07:00
prev_state = yield self.current_state_for_user(user_id)
2019-06-20 03:32:02 -06:00
yield self._update_states(
[
prev_state.copy_and_replace(
last_user_sync_ts=self.clock.time_msec()
)
]
)
except Exception:
logger.exception("Error updating presence after sync")
2016-02-15 10:10:40 -07:00
@contextmanager
def _user_syncing():
try:
yield
finally:
if affect_presence:
run_in_background(_end)
return _user_syncing()
def get_currently_syncing_users(self):
"""Get the set of user ids that are currently syncing on this HS.
Returns:
set(str): A set of user_id strings.
"""
if self.hs.config.use_presence:
syncing_user_ids = {
2019-06-20 03:32:02 -06:00
user_id
for user_id, count in self.user_to_num_current_syncs.items()
if count
}
for user_ids in self.external_process_to_current_syncs.values():
syncing_user_ids.update(user_ids)
return syncing_user_ids
else:
return set()
@defer.inlineCallbacks
2019-06-20 03:32:02 -06:00
def update_external_syncs_row(
self, process_id, user_id, is_syncing, sync_time_msec
):
"""Update the syncing users for an external process as a delta.
Args:
process_id (str): An identifier for the process the users are
syncing against. This allows synapse to process updates
as user start and stop syncing against a given process.
user_id (str): The user who has started or stopped syncing
is_syncing (bool): Whether or not the user is now syncing
sync_time_msec(int): Time in ms when the user was last syncing
"""
with (yield self.external_sync_linearizer.queue(process_id)):
prev_state = yield self.current_state_for_user(user_id)
process_presence = self.external_process_to_current_syncs.setdefault(
process_id, set()
)
updates = []
if is_syncing and user_id not in process_presence:
if prev_state.state == PresenceState.OFFLINE:
2019-06-20 03:32:02 -06:00
updates.append(
prev_state.copy_and_replace(
state=PresenceState.ONLINE,
last_active_ts=sync_time_msec,
last_user_sync_ts=sync_time_msec,
)
)
else:
2019-06-20 03:32:02 -06:00
updates.append(
prev_state.copy_and_replace(last_user_sync_ts=sync_time_msec)
)
process_presence.add(user_id)
elif user_id in process_presence:
2019-06-20 03:32:02 -06:00
updates.append(
prev_state.copy_and_replace(last_user_sync_ts=sync_time_msec)
)
2017-03-31 04:36:32 -06:00
if not is_syncing:
process_presence.discard(user_id)
if updates:
yield self._update_states(updates)
self.external_process_last_updated_ms[process_id] = self.clock.time_msec()
@defer.inlineCallbacks
def update_external_syncs_clear(self, process_id):
"""Marks all users that had been marked as syncing by a given process
as offline.
Used when the process has stopped/disappeared.
"""
with (yield self.external_sync_linearizer.queue(process_id)):
process_presence = self.external_process_to_current_syncs.pop(
process_id, set()
)
prev_states = yield self.current_state_for_users(process_presence)
time_now_ms = self.clock.time_msec()
2019-06-20 03:32:02 -06:00
yield self._update_states(
[
prev_state.copy_and_replace(last_user_sync_ts=time_now_ms)
for prev_state in itervalues(prev_states)
]
)
self.external_process_last_updated_ms.pop(process_id, None)
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
def current_state_for_user(self, user_id):
"""Get the current presence state for a user.
"""
res = yield self.current_state_for_users([user_id])
return res[user_id]
2014-08-12 08:10:52 -06:00
@defer.inlineCallbacks
2016-02-15 10:10:40 -07:00
def current_state_for_users(self, user_ids):
"""Get the current presence state for multiple users.
2014-08-22 11:02:45 -06:00
2016-02-15 10:10:40 -07:00
Returns:
dict: `user_id` -> `UserPresenceState`
"""
states = {
user_id: self.user_to_current_state.get(user_id, None)
for user_id in user_ids
}
missing = [user_id for user_id, state in iteritems(states) if not state]
2016-02-15 10:10:40 -07:00
if missing:
# There are things not in our in memory cache. Lets pull them out of
# the database.
res = yield self.store.get_presence_for_users(missing)
2017-02-13 06:50:03 -07:00
states.update(res)
2016-02-15 10:10:40 -07:00
missing = [user_id for user_id, state in iteritems(states) if not state]
2016-02-15 10:10:40 -07:00
if missing:
new = {
2019-06-20 03:32:02 -06:00
user_id: UserPresenceState.default(user_id) for user_id in missing
}
states.update(new)
self.user_to_current_state.update(new)
2014-08-12 08:10:52 -06:00
return states
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
def _persist_and_notify(self, states):
"""Persist states in the database, poke the notifier and send to
interested remote servers
"""
stream_id, max_token = yield self.store.update_presence(states)
2014-08-12 08:10:52 -06:00
2017-04-11 08:30:02 -06:00
parties = yield get_interested_parties(self.store, states)
room_ids_to_states, users_to_states = parties
2016-02-15 10:10:40 -07:00
self.notifier.on_new_event(
2019-06-20 03:32:02 -06:00
"presence_key",
stream_id,
rooms=room_ids_to_states.keys(),
users=[UserID.from_string(u) for u in users_to_states],
)
2014-08-12 08:10:52 -06:00
self._push_to_remotes(states)
2016-02-15 10:10:40 -07:00
2016-08-12 08:31:44 -06:00
@defer.inlineCallbacks
def notify_for_states(self, state, stream_id):
2017-04-11 08:30:02 -06:00
parties = yield get_interested_parties(self.store, [state])
room_ids_to_states, users_to_states = parties
2016-08-12 08:31:44 -06:00
self.notifier.on_new_event(
2019-06-20 03:32:02 -06:00
"presence_key",
stream_id,
rooms=room_ids_to_states.keys(),
users=[UserID.from_string(u) for u in users_to_states],
2016-08-12 08:31:44 -06:00
)
def _push_to_remotes(self, states):
2016-02-15 10:10:40 -07:00
"""Sends state updates to remote servers.
Args:
2017-04-12 03:11:43 -06:00
states (list(UserPresenceState))
2016-02-15 10:10:40 -07:00
"""
self.federation.send_presence(states)
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
def incoming_presence(self, origin, content):
"""Called when we receive a `m.presence` EDU from a remote server.
"""
now = self.clock.time_msec()
updates = []
for push in content.get("push", []):
# A "push" contains a list of presence that we are probably interested
# in.
# TODO: Actually check if we're interested, rather than blindly
# accepting presence updates.
user_id = push.get("user_id", None)
if not user_id:
logger.info(
2019-06-20 03:32:02 -06:00
"Got presence update from %r with no 'user_id': %r", origin, push
2016-02-15 10:10:40 -07:00
)
continue
if get_domain_from_id(user_id) != origin:
logger.info(
"Got presence update from %r with bad 'user_id': %r",
2019-06-20 03:32:02 -06:00
origin,
user_id,
)
continue
2016-02-15 10:10:40 -07:00
presence_state = push.get("presence", None)
if not presence_state:
logger.info(
"Got presence update from %r with no 'presence_state': %r",
2019-06-20 03:32:02 -06:00
origin,
push,
2016-02-15 10:10:40 -07:00
)
continue
2014-08-12 08:10:52 -06:00
2019-06-20 03:32:02 -06:00
new_fields = {"state": presence_state, "last_federation_update_ts": now}
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
last_active_ago = push.get("last_active_ago", None)
if last_active_ago is not None:
2016-02-18 03:11:43 -07:00
new_fields["last_active_ts"] = now - last_active_ago
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
new_fields["status_msg"] = push.get("status_msg", None)
new_fields["currently_active"] = push.get("currently_active", False)
2016-02-15 10:10:40 -07:00
prev_state = yield self.current_state_for_user(user_id)
updates.append(prev_state.copy_and_replace(**new_fields))
2016-02-15 10:10:40 -07:00
if updates:
2018-05-21 18:47:37 -06:00
federation_presence_counter.inc(len(updates))
2016-02-15 10:10:40 -07:00
yield self._update_states(updates)
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
def get_state(self, target_user, as_event=False):
2019-06-20 03:32:02 -06:00
results = yield self.get_states([target_user.to_string()], as_event=as_event)
2016-02-15 10:10:40 -07:00
return results[0]
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
def get_states(self, target_user_ids, as_event=False):
"""Get the presence state for users.
Args:
2016-02-15 10:10:40 -07:00
target_user_ids (list)
as_event (bool): Whether to format it as a client event or not.
Returns:
2016-02-15 10:10:40 -07:00
list
"""
2016-02-15 10:10:40 -07:00
updates = yield self.current_state_for_users(target_user_ids)
updates = list(updates.values())
2016-02-15 10:10:40 -07:00
for user_id in set(target_user_ids) - set(u.user_id for u in updates):
updates.append(UserPresenceState.default(user_id))
2016-02-15 10:10:40 -07:00
now = self.clock.time_msec()
if as_event:
return [
{
"type": "m.presence",
"content": format_user_presence_state(state, now),
}
for state in updates
]
2016-02-15 10:10:40 -07:00
else:
return updates
2016-02-15 10:10:40 -07:00
@defer.inlineCallbacks
2016-08-10 05:57:30 -06:00
def set_state(self, target_user, state, ignore_status_msg=False):
2016-02-15 10:10:40 -07:00
"""Set the presence state of the user.
"""
2016-02-15 10:10:40 -07:00
status_msg = state.get("status_msg", None)
presence = state["presence"]
2014-08-12 08:10:52 -06:00
2016-02-18 02:16:32 -07:00
valid_presence = (
2019-06-20 03:32:02 -06:00
PresenceState.ONLINE,
PresenceState.UNAVAILABLE,
PresenceState.OFFLINE,
2016-02-18 02:16:32 -07:00
)
if presence not in valid_presence:
raise SynapseError(400, "Invalid presence state")
2016-02-15 10:10:40 -07:00
user_id = target_user.to_string()
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
prev_state = yield self.current_state_for_user(user_id)
2019-06-20 03:32:02 -06:00
new_fields = {"state": presence}
2016-02-15 10:10:40 -07:00
2016-08-10 05:57:30 -06:00
if not ignore_status_msg:
msg = status_msg if presence != PresenceState.OFFLINE else None
new_fields["status_msg"] = msg
2016-02-15 10:10:40 -07:00
if presence == PresenceState.ONLINE:
2016-02-18 03:11:43 -07:00
new_fields["last_active_ts"] = self.clock.time_msec()
2016-02-15 10:10:40 -07:00
yield self._update_states([prev_state.copy_and_replace(**new_fields)])
2014-08-12 08:10:52 -06:00
@defer.inlineCallbacks
2016-02-15 10:10:40 -07:00
def is_visible(self, observed_user, observer_user):
2016-02-18 02:09:50 -07:00
"""Returns whether a user can see another user's presence.
"""
2017-03-16 05:51:46 -06:00
observer_room_ids = yield self.store.get_rooms_for_user(
observer_user.to_string()
)
observed_room_ids = yield self.store.get_rooms_for_user(
observed_user.to_string()
)
2016-02-15 10:10:40 -07:00
if observer_room_ids & observed_room_ids:
return True
return False
@defer.inlineCallbacks
def get_all_presence_updates(self, last_id, current_id):
"""
Gets a list of presence update rows from between the given stream ids.
Each row has:
- stream_id(str)
- user_id(str)
- state(str)
- last_active_ts(int)
- last_federation_update_ts(int)
- last_user_sync_ts(int)
- status_msg(int)
- currently_active(int)
"""
# TODO(markjh): replicate the unpersisted changes.
# This could use the in-memory stores for recent changes.
rows = yield self.store.get_all_presence_updates(last_id, current_id)
return rows
def notify_new_event(self):
"""Called when new events have happened. Handles users and servers
joining rooms and require being sent presence.
"""
2019-03-28 07:48:41 -06:00
if self._event_processing:
return
@defer.inlineCallbacks
def _process_presence():
2019-03-28 07:55:21 -06:00
assert not self._event_processing
self._event_processing = True
try:
yield self._unsafe_process()
finally:
self._event_processing = False
run_as_background_process("presence.notify_new_event", _process_presence)
@defer.inlineCallbacks
def _unsafe_process(self):
# Loop round handling deltas until we're up to date
while True:
with Measure(self.clock, "presence_delta"):
room_max_stream_ordering = self.store.get_room_max_stream_ordering()
if self._event_pos == room_max_stream_ordering:
return
logger.debug(
"Processing presence stats %s->%s",
self._event_pos,
room_max_stream_ordering,
)
max_pos, deltas = yield self.store.get_current_state_deltas(
self._event_pos, room_max_stream_ordering
)
yield self._handle_state_delta(deltas)
self._event_pos = max_pos
# Expose current event processing position to prometheus
synapse.metrics.event_processing_positions.labels("presence").set(
max_pos
)
@defer.inlineCallbacks
def _handle_state_delta(self, deltas):
"""Process current state deltas to find new joins that need to be
handled.
"""
for delta in deltas:
typ = delta["type"]
state_key = delta["state_key"]
room_id = delta["room_id"]
event_id = delta["event_id"]
prev_event_id = delta["prev_event_id"]
logger.debug("Handling: %r %r, %s", typ, state_key, event_id)
if typ != EventTypes.Member:
continue
if event_id is None:
# state has been deleted, so this is not a join. We only care about
# joins.
continue
event = yield self.store.get_event(event_id, allow_none=True)
if not event or event.content.get("membership") != Membership.JOIN:
# We only care about joins
continue
if prev_event_id:
prev_event = yield self.store.get_event(prev_event_id, allow_none=True)
if (
prev_event
and prev_event.content.get("membership") == Membership.JOIN
):
# Ignore changes to join events.
continue
2019-03-28 07:48:41 -06:00
yield self._on_user_joined_room(room_id, state_key)
2019-03-28 07:48:41 -06:00
@defer.inlineCallbacks
def _on_user_joined_room(self, room_id, user_id):
"""Called when we detect a user joining the room via the current state
delta stream.
2019-03-28 07:48:41 -06:00
Args:
room_id (str)
user_id (str)
2019-03-28 07:48:41 -06:00
Returns:
Deferred
"""
2019-03-28 07:48:41 -06:00
if self.is_mine_id(user_id):
# If this is a local user then we need to send their presence
# out to hosts in the room (who don't already have it)
2019-03-28 07:48:41 -06:00
# TODO: We should be able to filter the hosts down to those that
# haven't previously seen the user
2019-03-28 07:48:41 -06:00
state = yield self.current_state_for_user(user_id)
hosts = yield self.state.get_current_hosts_in_room(room_id)
2019-03-28 07:48:41 -06:00
# Filter out ourselves.
hosts = set(host for host in hosts if host != self.server_name)
2019-03-28 07:48:41 -06:00
self.federation.send_presence_to_destinations(
2019-06-20 03:32:02 -06:00
states=[state], destinations=hosts
2019-03-28 07:48:41 -06:00
)
else:
# A remote user has joined the room, so we need to:
# 1. Check if this is a new server in the room
# 2. If so send any presence they don't already have for
# local users in the room.
# TODO: We should be able to filter the users down to those that
# the server hasn't previously seen
# TODO: Check that this is actually a new server joining the
# room.
user_ids = yield self.state.get_current_users_in_room(room_id)
2019-03-28 07:48:41 -06:00
user_ids = list(filter(self.is_mine_id, user_ids))
states = yield self.current_state_for_users(user_ids)
# Filter out old presence, i.e. offline presence states where
# the user hasn't been active for a week. We can change this
# depending on what we want the UX to be, but at the least we
# should filter out offline presence where the state is just the
# default state.
now = self.clock.time_msec()
states = [
2019-06-20 03:32:02 -06:00
state
for state in states.values()
2019-03-28 07:48:41 -06:00
if state.state != PresenceState.OFFLINE
or now - state.last_active_ts < 7 * 24 * 60 * 60 * 1000
or state.status_msg is not None
]
if states:
self.federation.send_presence_to_destinations(
2019-06-20 03:32:02 -06:00
states=states, destinations=[get_domain_from_id(user_id)]
2019-03-28 07:48:41 -06:00
)
2016-02-15 10:10:40 -07:00
def should_notify(old_state, new_state):
"""Decides if a presence state change should be sent to interested parties.
"""
2016-09-06 03:28:35 -06:00
if old_state == new_state:
return False
2016-02-15 10:10:40 -07:00
if old_state.status_msg != new_state.status_msg:
2018-05-21 18:47:37 -06:00
notify_reason_counter.labels("status_msg_change").inc()
2016-02-15 10:10:40 -07:00
return True
if old_state.state != new_state.state:
2018-05-21 18:47:37 -06:00
notify_reason_counter.labels("state_change").inc()
state_transition_counter.labels(old_state.state, new_state.state).inc()
return True
if old_state.state == PresenceState.ONLINE:
2016-02-15 10:10:40 -07:00
if new_state.currently_active != old_state.currently_active:
2018-05-21 18:47:37 -06:00
notify_reason_counter.labels("current_active_change").inc()
2016-02-15 10:10:40 -07:00
return True
2019-06-20 03:32:02 -06:00
if (
new_state.last_active_ts - old_state.last_active_ts
> LAST_ACTIVE_GRANULARITY
):
# Only notify about last active bumps if we're not currently acive
if not new_state.currently_active:
2018-05-21 18:47:37 -06:00
notify_reason_counter.labels("last_active_change_online").inc()
return True
elif new_state.last_active_ts - old_state.last_active_ts > LAST_ACTIVE_GRANULARITY:
2016-02-15 10:10:40 -07:00
# Always notify for a transition where last active gets bumped.
2018-05-21 18:47:37 -06:00
notify_reason_counter.labels("last_active_change_not_online").inc()
2016-02-15 10:10:40 -07:00
return True
2016-02-15 10:10:40 -07:00
return False
2015-05-14 08:29:58 -06:00
def format_user_presence_state(state, now, include_user_id=True):
2016-02-15 10:10:40 -07:00
"""Convert UserPresenceState to a format that can be sent down to clients
and to other servers.
2017-03-15 08:50:33 -06:00
The "user_id" is optional so that this function can be used to format presence
updates for client /sync responses and for federation /send requests.
2016-02-15 10:10:40 -07:00
"""
2019-06-20 03:32:02 -06:00
content = {"presence": state.state}
if include_user_id:
content["user_id"] = state.user_id
2016-02-18 03:11:43 -07:00
if state.last_active_ts:
content["last_active_ago"] = now - state.last_active_ts
2016-02-15 10:10:40 -07:00
if state.status_msg and state.state != PresenceState.OFFLINE:
content["status_msg"] = state.status_msg
if state.state == PresenceState.ONLINE:
content["currently_active"] = state.currently_active
2015-05-14 08:29:58 -06:00
2016-02-15 10:10:40 -07:00
return content
2015-05-14 08:29:58 -06:00
2014-08-12 08:10:52 -06:00
class PresenceEventSource(object):
def __init__(self, hs):
# We can't call get_presence_handler here because there's a cycle:
#
# Presence -> Notifier -> PresenceEventSource -> Presence
#
self.get_presence_handler = hs.get_presence_handler
self.clock = hs.get_clock()
2016-02-15 10:10:40 -07:00
self.store = hs.get_datastore()
self.state = hs.get_state_handler()
@defer.inlineCallbacks
@log_function
2019-06-20 03:32:02 -06:00
def get_new_events(
self,
user,
from_key,
room_ids=None,
include_offline=True,
explicit_room_id=None,
**kwargs
):
2016-02-15 10:10:40 -07:00
# The process for getting presence events are:
# 1. Get the rooms the user is in.
# 2. Get the list of user in the rooms.
# 3. Get the list of users that are in the user's presence list.
# 4. If there is a from_key set, cross reference the list of users
# with the `presence_stream_cache` to see which ones we actually
# need to check.
# 5. Load current state for the users.
#
# We don't try and limit the presence updates by the current token, as
# sending down the rare duplicate is not a concern.
with Measure(self.clock, "presence.get_new_events"):
if from_key is not None:
from_key = int(from_key)
max_token = self.store.get_current_presence_token()
if from_key == max_token:
# This is necessary as due to the way stream ID generators work
# we may get updates that have a stream ID greater than the max
2019-07-01 03:22:42 -06:00
# token (e.g. max_token is N but stream generator may return
# results for N+2, due to N+1 not having finished being
# persisted yet).
#
# This is usually fine, as it just means that we may send down
# some presence updates multiple times. However, we need to be
# careful that the sync stream either actually does make some
# progress or doesn't return, otherwise clients will end up
# tight looping calling /sync due to it immediately returning
# the same token repeatedly.
#
# Hence this guard where we just return nothing so that the sync
# doesn't return. C.f. #5503.
return [], max_token
presence = self.get_presence_handler()
stream_change_cache = self.store.presence_stream_cache
users_interested_in = yield self._get_interested_in(user, explicit_room_id)
user_ids_changed = set()
changed = None
if from_key:
changed = stream_change_cache.get_all_entities_changed(from_key)
2016-06-03 06:49:16 -06:00
if changed is not None and len(changed) < 500:
# For small deltas, its quicker to get all changes and then
# work out if we share a room or they're in our presence list
2018-05-21 18:47:37 -06:00
get_updates_counter.labels("stream").inc()
for other_user_id in changed:
if other_user_id in users_interested_in:
user_ids_changed.add(other_user_id)
else:
2016-02-23 07:57:45 -07:00
# Too many possible updates. Find all users we can see and check
# if any of them have changed.
2018-05-21 18:47:37 -06:00
get_updates_counter.labels("full").inc()
if from_key:
user_ids_changed = stream_change_cache.get_entities_changed(
2019-06-20 03:32:02 -06:00
users_interested_in, from_key
)
else:
user_ids_changed = users_interested_in
updates = yield presence.current_state_for_users(user_ids_changed)
2014-08-12 08:10:52 -06:00
if include_offline:
return (list(updates.values()), max_token)
else:
return (
[s for s in itervalues(updates) if s.state != PresenceState.OFFLINE],
max_token,
2019-06-20 03:32:02 -06:00
)
2014-08-12 08:10:52 -06:00
2016-02-15 10:10:40 -07:00
def get_current_key(self):
return self.store.get_current_presence_token()
2016-02-15 10:10:40 -07:00
def get_pagination_rows(self, user, pagination_config, key):
return self.get_new_events(user, from_key=None, include_offline=False)
2016-02-18 04:52:33 -07:00
@cachedInlineCallbacks(num_args=2, cache_context=True)
def _get_interested_in(self, user, explicit_room_id, cache_context):
"""Returns the set of users that the given user should see presence
updates for
"""
user_id = user.to_string()
users_interested_in = set()
users_interested_in.add(user_id) # So that we receive our own presence
users_who_share_room = yield self.store.get_users_who_share_room_with_user(
2019-06-20 03:32:02 -06:00
user_id, on_invalidate=cache_context.invalidate
)
users_interested_in.update(users_who_share_room)
if explicit_room_id:
user_ids = yield self.store.get_users_in_room(
2019-06-20 03:32:02 -06:00
explicit_room_id, on_invalidate=cache_context.invalidate
)
users_interested_in.update(user_ids)
return users_interested_in
2016-02-18 04:52:33 -07:00
def handle_timeouts(user_states, is_mine_fn, syncing_user_ids, now):
2016-02-18 04:52:33 -07:00
"""Checks the presence of users that have timed out and updates as
appropriate.
Args:
user_states(list): List of UserPresenceState's to check.
is_mine_fn (fn): Function that returns if a user_id is ours
syncing_user_ids (set): Set of user_ids with active syncs.
2016-02-18 04:52:33 -07:00
now (int): Current time in ms.
Returns:
List of UserPresenceState updates
"""
changes = {} # Actual changes we need to notify people about
for state in user_states:
is_mine = is_mine_fn(state.user_id)
new_state = handle_timeout(state, is_mine, syncing_user_ids, now)
2016-02-18 04:52:33 -07:00
if new_state:
changes[state.user_id] = new_state
return list(changes.values())
2016-02-18 04:52:33 -07:00
def handle_timeout(state, is_mine, syncing_user_ids, now):
2016-02-18 04:52:33 -07:00
"""Checks the presence of the user to see if any of the timers have elapsed
Args:
state (UserPresenceState)
is_mine (bool): Whether the user is ours
syncing_user_ids (set): Set of user_ids with active syncs.
2016-02-18 04:52:33 -07:00
now (int): Current time in ms.
Returns:
A UserPresenceState update or None if no update.
"""
if state.state == PresenceState.OFFLINE:
# No timeouts are associated with offline states.
return None
changed = False
user_id = state.user_id
if is_mine:
if state.state == PresenceState.ONLINE:
if now - state.last_active_ts > IDLE_TIMER:
# Currently online, but last activity ages ago so auto
# idle
2019-06-20 03:32:02 -06:00
state = state.copy_and_replace(state=PresenceState.UNAVAILABLE)
2016-02-18 04:52:33 -07:00
changed = True
elif now - state.last_active_ts > LAST_ACTIVE_GRANULARITY:
# So that we send down a notification that we've
# stopped updating.
changed = True
if now - state.last_federation_update_ts > FEDERATION_PING_INTERVAL:
# Need to send ping to other servers to ensure they don't
# timeout and set us to offline
changed = True
# If there are have been no sync for a while (and none ongoing),
# set presence to offline
if user_id not in syncing_user_ids:
# If the user has done something recently but hasn't synced,
# don't set them as offline.
sync_or_active = max(state.last_user_sync_ts, state.last_active_ts)
if now - sync_or_active > SYNC_ONLINE_TIMEOUT:
2016-02-18 04:52:33 -07:00
state = state.copy_and_replace(
2019-06-20 03:32:02 -06:00
state=PresenceState.OFFLINE, status_msg=None
2016-02-18 04:52:33 -07:00
)
changed = True
else:
2017-11-16 18:53:50 -07:00
# We expect to be poked occasionally by the other side.
2016-02-18 04:52:33 -07:00
# This is to protect against forgetful/buggy servers, so that
# no one gets stuck online forever.
if now - state.last_federation_update_ts > FEDERATION_TIMEOUT:
# The other side seems to have disappeared.
2019-06-20 03:32:02 -06:00
state = state.copy_and_replace(state=PresenceState.OFFLINE, status_msg=None)
2016-02-18 04:52:33 -07:00
changed = True
return state if changed else None
def handle_update(prev_state, new_state, is_mine, wheel_timer, now):
"""Given a presence update:
1. Add any appropriate timers.
2. Check if we should notify anyone.
Args:
prev_state (UserPresenceState)
new_state (UserPresenceState)
is_mine (bool): Whether the user is ours
wheel_timer (WheelTimer)
now (int): Time now in ms
Returns:
3-tuple: `(new_state, persist_and_notify, federation_ping)` where:
- new_state: is the state to actually persist
- persist_and_notify (bool): whether to persist and notify people
- federation_ping (bool): whether we should send a ping over federation
"""
user_id = new_state.user_id
persist_and_notify = False
federation_ping = False
# If the users are ours then we want to set up a bunch of timers
# to time things out.
if is_mine:
if new_state.state == PresenceState.ONLINE:
# Idle timer
wheel_timer.insert(
2019-06-20 03:32:02 -06:00
now=now, obj=user_id, then=new_state.last_active_ts + IDLE_TIMER
2016-02-18 04:52:33 -07:00
)
active = now - new_state.last_active_ts < LAST_ACTIVE_GRANULARITY
2019-06-20 03:32:02 -06:00
new_state = new_state.copy_and_replace(currently_active=active)
if active:
wheel_timer.insert(
now=now,
obj=user_id,
2019-06-20 03:32:02 -06:00
then=new_state.last_active_ts + LAST_ACTIVE_GRANULARITY,
)
2016-02-18 04:52:33 -07:00
if new_state.state != PresenceState.OFFLINE:
# User has stopped syncing
wheel_timer.insert(
now=now,
obj=user_id,
2019-06-20 03:32:02 -06:00
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT,
2016-02-18 04:52:33 -07:00
)
last_federate = new_state.last_federation_update_ts
if now - last_federate > FEDERATION_PING_INTERVAL:
# Been a while since we've poked remote servers
2019-06-20 03:32:02 -06:00
new_state = new_state.copy_and_replace(last_federation_update_ts=now)
2016-02-18 04:52:33 -07:00
federation_ping = True
else:
wheel_timer.insert(
now=now,
obj=user_id,
2019-06-20 03:32:02 -06:00
then=new_state.last_federation_update_ts + FEDERATION_TIMEOUT,
2016-02-18 04:52:33 -07:00
)
# Check whether the change was something worth notifying about
if should_notify(prev_state, new_state):
2019-06-20 03:32:02 -06:00
new_state = new_state.copy_and_replace(last_federation_update_ts=now)
2016-02-18 04:52:33 -07:00
persist_and_notify = True
return new_state, persist_and_notify, federation_ping
2017-04-11 08:30:02 -06:00
@defer.inlineCallbacks
def get_interested_parties(store, states):
"""Given a list of states return which entities (rooms, users)
are interested in the given states.
Args:
states (list(UserPresenceState))
Returns:
2-tuple: `(room_ids_to_states, users_to_states)`,
with each item being a dict of `entity_name` -> `[UserPresenceState]`
"""
room_ids_to_states = {}
users_to_states = {}
for state in states:
room_ids = yield store.get_rooms_for_user(state.user_id)
for room_id in room_ids:
room_ids_to_states.setdefault(room_id, []).append(state)
# Always notify self
users_to_states.setdefault(state.user_id, []).append(state)
return room_ids_to_states, users_to_states
2017-04-11 08:30:02 -06:00
@defer.inlineCallbacks
def get_interested_remotes(store, states, state_handler):
"""Given a list of presence states figure out which remote servers
should be sent which.
All the presence states should be for local users only.
Args:
store (DataStore)
states (list(UserPresenceState))
Returns:
Deferred list of ([destinations], [UserPresenceState]), where for
each row the list of UserPresenceState should be sent to each
destination
"""
2017-04-12 03:11:43 -06:00
hosts_and_states = []
2017-04-11 08:28:24 -06:00
# First we look up the rooms each user is in (as well as any explicit
# subscriptions), then for each distinct room we look up the remote
# hosts in those rooms.
2017-04-12 03:11:43 -06:00
room_ids_to_states, users_to_states = yield get_interested_parties(store, states)
for room_id, states in iteritems(room_ids_to_states):
hosts = yield state_handler.get_current_hosts_in_room(room_id)
2017-04-11 08:30:02 -06:00
hosts_and_states.append((hosts, states))
for user_id, states in iteritems(users_to_states):
host = get_domain_from_id(user_id)
2017-04-11 08:30:02 -06:00
hosts_and_states.append(([host], states))
return hosts_and_states