2018-05-17 06:34:28 -04:00
|
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright 2018 New Vector Ltd
|
|
|
|
#
|
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
# you may not use this file except in compliance with the License.
|
|
|
|
# You may obtain a copy of the License at
|
|
|
|
#
|
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
#
|
|
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
# See the License for the specific language governing permissions and
|
|
|
|
# limitations under the License.
|
|
|
|
import logging
|
2020-07-31 16:22:06 -04:00
|
|
|
from typing import Optional
|
2018-05-17 06:34:28 -04:00
|
|
|
|
|
|
|
from synapse.api.constants import EventTypes, Membership, RoomCreationPreset
|
2020-07-31 16:22:06 -04:00
|
|
|
from synapse.events import EventBase
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
from synapse.types import UserID, create_requester
|
2020-05-01 10:15:36 -04:00
|
|
|
from synapse.util.caches.descriptors import cached
|
2018-05-17 06:34:28 -04:00
|
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
2018-08-16 12:02:04 -04:00
|
|
|
SERVER_NOTICE_ROOM_TAG = "m.server_notice"
|
|
|
|
|
2018-05-17 06:34:28 -04:00
|
|
|
|
2020-09-04 06:54:56 -04:00
|
|
|
class ServerNoticesManager:
|
2018-05-17 06:34:28 -04:00
|
|
|
def __init__(self, hs):
|
|
|
|
"""
|
|
|
|
|
|
|
|
Args:
|
|
|
|
hs (synapse.server.HomeServer):
|
|
|
|
"""
|
|
|
|
|
|
|
|
self._store = hs.get_datastore()
|
|
|
|
self._config = hs.config
|
2021-01-20 05:44:52 -05:00
|
|
|
self._account_data_handler = hs.get_account_data_handler()
|
2018-05-17 06:34:28 -04:00
|
|
|
self._room_creation_handler = hs.get_room_creation_handler()
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
self._room_member_handler = hs.get_room_member_handler()
|
2018-05-17 06:34:28 -04:00
|
|
|
self._event_creation_handler = hs.get_event_creation_handler()
|
2018-05-23 09:30:47 -04:00
|
|
|
self._is_mine_id = hs.is_mine_id
|
2020-11-17 05:51:25 -05:00
|
|
|
self._server_name = hs.hostname
|
2018-05-17 06:34:28 -04:00
|
|
|
|
2018-08-24 09:50:03 -04:00
|
|
|
self._notifier = hs.get_notifier()
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
self.server_notices_mxid = self._config.server_notices_mxid
|
2018-08-24 09:50:03 -04:00
|
|
|
|
2018-05-17 06:34:28 -04:00
|
|
|
def is_enabled(self):
|
2018-05-18 06:22:12 -04:00
|
|
|
"""Checks if server notices are enabled on this server.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
bool
|
|
|
|
"""
|
2018-05-17 06:34:28 -04:00
|
|
|
return self._config.server_notices_mxid is not None
|
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
async def send_notice(
|
2020-07-31 16:22:06 -04:00
|
|
|
self,
|
|
|
|
user_id: str,
|
|
|
|
event_content: dict,
|
|
|
|
type: str = EventTypes.Message,
|
2021-03-24 06:48:46 -04:00
|
|
|
state_key: Optional[str] = None,
|
2020-07-31 16:22:06 -04:00
|
|
|
) -> EventBase:
|
2018-05-18 06:22:12 -04:00
|
|
|
"""Send a notice to the given user
|
|
|
|
|
|
|
|
Creates the server notices room, if none exists.
|
|
|
|
|
|
|
|
Args:
|
2020-07-31 16:22:06 -04:00
|
|
|
user_id: mxid of user to send event to.
|
|
|
|
event_content: content of event to send
|
|
|
|
type: type of event
|
|
|
|
is_state_event: Is the event a state event
|
2018-05-18 06:22:12 -04:00
|
|
|
"""
|
2020-05-01 10:15:36 -04:00
|
|
|
room_id = await self.get_or_create_notice_room_for_user(user_id)
|
|
|
|
await self.maybe_invite_user_to_room(user_id, room_id)
|
2018-05-17 06:34:28 -04:00
|
|
|
|
|
|
|
system_mxid = self._config.server_notices_mxid
|
2020-11-17 05:51:25 -05:00
|
|
|
requester = create_requester(
|
|
|
|
system_mxid, authenticated_entity=self._server_name
|
|
|
|
)
|
2018-05-17 06:34:28 -04:00
|
|
|
|
|
|
|
logger.info("Sending server notice to %s", user_id)
|
|
|
|
|
2018-08-15 10:04:52 -04:00
|
|
|
event_dict = {
|
|
|
|
"type": type,
|
|
|
|
"room_id": room_id,
|
|
|
|
"sender": system_mxid,
|
|
|
|
"content": event_content,
|
|
|
|
}
|
2018-08-16 06:10:19 -04:00
|
|
|
|
|
|
|
if state_key is not None:
|
2019-06-20 05:32:02 -04:00
|
|
|
event_dict["state_key"] = state_key
|
2018-08-15 10:04:52 -04:00
|
|
|
|
2020-05-22 09:21:54 -04:00
|
|
|
event, _ = await self._event_creation_handler.create_and_send_nonmember_event(
|
2019-06-20 05:32:02 -04:00
|
|
|
requester, event_dict, ratelimit=False
|
2018-05-17 06:34:28 -04:00
|
|
|
)
|
2020-05-22 09:21:54 -04:00
|
|
|
return event
|
2018-05-17 06:34:28 -04:00
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
@cached()
|
2020-07-31 16:22:06 -04:00
|
|
|
async def get_or_create_notice_room_for_user(self, user_id: str) -> str:
|
2018-05-17 06:34:28 -04:00
|
|
|
"""Get the room for notices for a given user
|
|
|
|
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
If we have not yet created a notice room for this user, create it, but don't
|
|
|
|
invite the user to it.
|
2018-05-17 06:34:28 -04:00
|
|
|
|
|
|
|
Args:
|
2020-07-31 16:22:06 -04:00
|
|
|
user_id: complete user id for the user we want a room for
|
2018-05-17 06:34:28 -04:00
|
|
|
|
|
|
|
Returns:
|
2020-07-31 16:22:06 -04:00
|
|
|
room id of notice room.
|
2018-05-17 06:34:28 -04:00
|
|
|
"""
|
|
|
|
if not self.is_enabled():
|
|
|
|
raise Exception("Server notices not enabled")
|
|
|
|
|
2019-06-20 05:32:02 -04:00
|
|
|
assert self._is_mine_id(user_id), "Cannot send server notices to remote users"
|
2018-05-23 09:30:47 -04:00
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
rooms = await self._store.get_rooms_for_local_user_where_membership_is(
|
2019-06-20 05:32:02 -04:00
|
|
|
user_id, [Membership.INVITE, Membership.JOIN]
|
2018-05-17 06:34:28 -04:00
|
|
|
)
|
|
|
|
for room in rooms:
|
2018-05-18 06:18:39 -04:00
|
|
|
# it's worth noting that there is an asymmetry here in that we
|
|
|
|
# expect the user to be invited or joined, but the system user must
|
|
|
|
# be joined. This is kinda deliberate, in that if somebody somehow
|
|
|
|
# manages to invite the system user to a room, that doesn't make it
|
|
|
|
# the server notices room.
|
2020-05-01 10:15:36 -04:00
|
|
|
user_ids = await self._store.get_users_in_room(room.room_id)
|
2020-11-11 09:23:16 -05:00
|
|
|
if len(user_ids) <= 2 and self.server_notices_mxid in user_ids:
|
2018-05-17 06:34:28 -04:00
|
|
|
# we found a room which our user shares with the system notice
|
|
|
|
# user
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
logger.info(
|
|
|
|
"Using existing server notices room %s for user %s",
|
|
|
|
room.room_id,
|
|
|
|
user_id,
|
|
|
|
)
|
2019-07-23 09:00:55 -04:00
|
|
|
return room.room_id
|
2018-05-17 06:34:28 -04:00
|
|
|
|
|
|
|
# apparently no existing notice room: create a new one
|
|
|
|
logger.info("Creating server notices room for %s", user_id)
|
|
|
|
|
2018-05-23 12:43:30 -04:00
|
|
|
# see if we want to override the profile info for the server user.
|
|
|
|
# note that if we want to override either the display name or the
|
|
|
|
# avatar, we have to use both.
|
|
|
|
join_profile = None
|
|
|
|
if (
|
2019-06-20 05:32:02 -04:00
|
|
|
self._config.server_notices_mxid_display_name is not None
|
|
|
|
or self._config.server_notices_mxid_avatar_url is not None
|
2018-05-23 12:43:30 -04:00
|
|
|
):
|
|
|
|
join_profile = {
|
|
|
|
"displayname": self._config.server_notices_mxid_display_name,
|
|
|
|
"avatar_url": self._config.server_notices_mxid_avatar_url,
|
|
|
|
}
|
|
|
|
|
2020-11-17 05:51:25 -05:00
|
|
|
requester = create_requester(
|
|
|
|
self.server_notices_mxid, authenticated_entity=self._server_name
|
|
|
|
)
|
2020-05-22 09:21:54 -04:00
|
|
|
info, _ = await self._room_creation_handler.create_room(
|
2018-05-17 06:34:28 -04:00
|
|
|
requester,
|
|
|
|
config={
|
|
|
|
"preset": RoomCreationPreset.PRIVATE_CHAT,
|
|
|
|
"name": self._config.server_notices_room_name,
|
2019-06-20 05:32:02 -04:00
|
|
|
"power_level_content_override": {"users_default": -10},
|
2018-05-17 06:34:28 -04:00
|
|
|
},
|
|
|
|
ratelimit=False,
|
2018-05-23 12:43:30 -04:00
|
|
|
creator_join_profile=join_profile,
|
2018-05-17 06:34:28 -04:00
|
|
|
)
|
2019-06-20 05:32:02 -04:00
|
|
|
room_id = info["room_id"]
|
2018-08-24 09:50:03 -04:00
|
|
|
|
2021-01-20 05:44:52 -05:00
|
|
|
max_id = await self._account_data_handler.add_tag_to_room(
|
2019-06-20 05:32:02 -04:00
|
|
|
user_id, room_id, SERVER_NOTICE_ROOM_TAG, {}
|
2018-08-24 09:50:03 -04:00
|
|
|
)
|
2019-06-20 05:32:02 -04:00
|
|
|
self._notifier.on_new_event("account_data_key", max_id, users=[user_id])
|
2018-05-17 06:34:28 -04:00
|
|
|
|
|
|
|
logger.info("Created server notices room %s for %s", room_id, user_id)
|
2019-07-23 09:00:55 -04:00
|
|
|
return room_id
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
|
2020-07-31 16:22:06 -04:00
|
|
|
async def maybe_invite_user_to_room(self, user_id: str, room_id: str) -> None:
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
"""Invite the given user to the given server room, unless the user has already
|
|
|
|
joined or been invited to it.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
user_id: The ID of the user to invite.
|
|
|
|
room_id: The ID of the room to invite the user to.
|
|
|
|
"""
|
2020-11-17 05:51:25 -05:00
|
|
|
requester = create_requester(
|
|
|
|
self.server_notices_mxid, authenticated_entity=self._server_name
|
|
|
|
)
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
|
|
|
|
# Check whether the user has already joined or been invited to this room. If
|
|
|
|
# that's the case, there is no need to re-invite them.
|
2020-05-01 10:15:36 -04:00
|
|
|
joined_rooms = await self._store.get_rooms_for_local_user_where_membership_is(
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
user_id, [Membership.INVITE, Membership.JOIN]
|
|
|
|
)
|
|
|
|
for room in joined_rooms:
|
|
|
|
if room.room_id == room_id:
|
|
|
|
return
|
|
|
|
|
2020-05-01 10:15:36 -04:00
|
|
|
await self._room_member_handler.update_membership(
|
Server notices: Dissociate room creation/lookup from invite (#7199)
Fixes #6815
Before figuring out whether we should alert a user on MAU, we call get_notice_room_for_user to get some info on the existing server notices room for this user. This function, if the room doesn't exist, creates it and invites the user in it. This means that, if we decide later that no server notice is needed, the user gets invited in a room with no message in it. This happens at every restart of the server, since the room ID returned by get_notice_room_for_user is cached.
This PR fixes that by moving the inviting bit to a dedicated function, that's only called when the server actually needs to send a notice to the user. A potential issue with this approach is that the room that's created by get_notice_room_for_user doesn't match how that same function looks for an existing room (i.e. it creates a room that doesn't have an invite or a join for the current user in it, so it could lead to a new room being created each time a user syncs), but I'm not sure this is a problem given it's cached until the server restarts, so that function won't run very often.
It also renames get_notice_room_for_user into get_or_create_notice_room_for_user to make what it does clearer.
2020-04-04 11:27:45 -04:00
|
|
|
requester=requester,
|
|
|
|
target=UserID.from_string(user_id),
|
|
|
|
room_id=room_id,
|
|
|
|
action="invite",
|
|
|
|
)
|