2018-05-17 10:34:28 +00:00
|
|
|
# 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
|
2021-08-27 09:16:40 +00:00
|
|
|
from typing import TYPE_CHECKING, Optional
|
2018-05-17 10:34:28 +00:00
|
|
|
|
|
|
|
from synapse.api.constants import EventTypes, Membership, RoomCreationPreset
|
2020-07-31 20:22:06 +00:00
|
|
|
from synapse.events import EventBase
|
2022-05-16 15:35:31 +00:00
|
|
|
from synapse.types import Requester, StreamKeyType, UserID, create_requester
|
2020-05-01 14:15:36 +00:00
|
|
|
from synapse.util.caches.descriptors import cached
|
2018-05-17 10:34:28 +00:00
|
|
|
|
2021-08-27 09:16:40 +00:00
|
|
|
if TYPE_CHECKING:
|
|
|
|
from synapse.server import HomeServer
|
|
|
|
|
2018-05-17 10:34:28 +00:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
2018-08-16 16:02:04 +00:00
|
|
|
SERVER_NOTICE_ROOM_TAG = "m.server_notice"
|
|
|
|
|
2018-05-17 10:34:28 +00:00
|
|
|
|
2020-09-04 10:54:56 +00:00
|
|
|
class ServerNoticesManager:
|
2021-08-27 09:16:40 +00:00
|
|
|
def __init__(self, hs: "HomeServer"):
|
2022-02-23 11:04:02 +00:00
|
|
|
self._store = hs.get_datastores().main
|
2018-05-17 10:34:28 +00:00
|
|
|
self._config = hs.config
|
2021-01-20 10:44:52 +00:00
|
|
|
self._account_data_handler = hs.get_account_data_handler()
|
2018-05-17 10:34:28 +00: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 15:27:45 +00:00
|
|
|
self._room_member_handler = hs.get_room_member_handler()
|
2018-05-17 10:34:28 +00:00
|
|
|
self._event_creation_handler = hs.get_event_creation_handler()
|
2022-04-08 11:51:27 +00:00
|
|
|
self._message_handler = hs.get_message_handler()
|
2018-05-23 13:30:47 +00:00
|
|
|
self._is_mine_id = hs.is_mine_id
|
2020-11-17 10:51:25 +00:00
|
|
|
self._server_name = hs.hostname
|
2018-05-17 10:34:28 +00:00
|
|
|
|
2018-08-24 13:50:03 +00:00
|
|
|
self._notifier = hs.get_notifier()
|
2021-09-24 11:25:21 +00:00
|
|
|
self.server_notices_mxid = self._config.servernotices.server_notices_mxid
|
2018-08-24 13:50:03 +00:00
|
|
|
|
2021-10-07 18:55:15 +00:00
|
|
|
def is_enabled(self) -> bool:
|
|
|
|
"""Checks if server notices are enabled on this server."""
|
2021-09-24 11:25:21 +00:00
|
|
|
return self.server_notices_mxid is not None
|
2018-05-17 10:34:28 +00:00
|
|
|
|
2020-05-01 14:15:36 +00:00
|
|
|
async def send_notice(
|
2020-07-31 20:22:06 +00:00
|
|
|
self,
|
|
|
|
user_id: str,
|
|
|
|
event_content: dict,
|
|
|
|
type: str = EventTypes.Message,
|
2021-03-24 10:48:46 +00:00
|
|
|
state_key: Optional[str] = None,
|
2021-08-27 09:16:40 +00:00
|
|
|
txn_id: Optional[str] = None,
|
2020-07-31 20:22:06 +00:00
|
|
|
) -> EventBase:
|
2018-05-18 10:22:12 +00:00
|
|
|
"""Send a notice to the given user
|
|
|
|
|
|
|
|
Creates the server notices room, if none exists.
|
|
|
|
|
|
|
|
Args:
|
2020-07-31 20:22:06 +00: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
|
2021-08-27 09:16:40 +00:00
|
|
|
txn_id: The transaction ID.
|
2018-05-18 10:22:12 +00:00
|
|
|
"""
|
2020-05-01 14:15:36 +00: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 10:34:28 +00:00
|
|
|
|
2021-09-24 11:25:21 +00:00
|
|
|
assert self.server_notices_mxid is not None
|
2020-11-17 10:51:25 +00:00
|
|
|
requester = create_requester(
|
2021-09-24 11:25:21 +00:00
|
|
|
self.server_notices_mxid, authenticated_entity=self._server_name
|
2020-11-17 10:51:25 +00:00
|
|
|
)
|
2018-05-17 10:34:28 +00:00
|
|
|
|
|
|
|
logger.info("Sending server notice to %s", user_id)
|
|
|
|
|
2018-08-15 14:04:52 +00:00
|
|
|
event_dict = {
|
|
|
|
"type": type,
|
|
|
|
"room_id": room_id,
|
2021-09-24 11:25:21 +00:00
|
|
|
"sender": self.server_notices_mxid,
|
2018-08-15 14:04:52 +00:00
|
|
|
"content": event_content,
|
|
|
|
}
|
2018-08-16 10:10:19 +00:00
|
|
|
|
|
|
|
if state_key is not None:
|
2018-08-15 14:04:52 +00:00
|
|
|
event_dict["state_key"] = state_key
|
|
|
|
|
2020-05-22 13:21:54 +00:00
|
|
|
event, _ = await self._event_creation_handler.create_and_send_nonmember_event(
|
2021-08-27 09:16:40 +00:00
|
|
|
requester, event_dict, ratelimit=False, txn_id=txn_id
|
2018-05-17 10:34:28 +00:00
|
|
|
)
|
2020-05-22 13:21:54 +00:00
|
|
|
return event
|
2018-05-17 10:34:28 +00:00
|
|
|
|
2022-05-13 13:30:15 +00:00
|
|
|
@cached()
|
|
|
|
async def maybe_get_notice_room_for_user(self, user_id: str) -> Optional[str]:
|
|
|
|
"""Try to look up the server notice room for this user if it exists.
|
|
|
|
|
|
|
|
Does not create one if none can be found.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
user_id: the user we want a server notice room for.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The room's ID, or None if no room could be found.
|
|
|
|
"""
|
|
|
|
rooms = await self._store.get_rooms_for_local_user_where_membership_is(
|
|
|
|
user_id, [Membership.INVITE, Membership.JOIN]
|
|
|
|
)
|
|
|
|
for room in rooms:
|
|
|
|
# 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.
|
|
|
|
user_ids = await self._store.get_users_in_room(room.room_id)
|
|
|
|
if len(user_ids) <= 2 and self.server_notices_mxid in user_ids:
|
|
|
|
# we found a room which our user shares with the system notice
|
|
|
|
# user
|
|
|
|
return room.room_id
|
|
|
|
|
|
|
|
return None
|
|
|
|
|
2020-05-01 14:15:36 +00:00
|
|
|
@cached()
|
2020-07-31 20:22:06 +00:00
|
|
|
async def get_or_create_notice_room_for_user(self, user_id: str) -> str:
|
2018-05-17 10:34:28 +00: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 15:27:45 +00: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 10:34:28 +00:00
|
|
|
|
|
|
|
Args:
|
2020-07-31 20:22:06 +00:00
|
|
|
user_id: complete user id for the user we want a room for
|
2018-05-17 10:34:28 +00:00
|
|
|
|
|
|
|
Returns:
|
2020-07-31 20:22:06 +00:00
|
|
|
room id of notice room.
|
2018-05-17 10:34:28 +00:00
|
|
|
"""
|
2021-09-24 11:25:21 +00:00
|
|
|
if self.server_notices_mxid is None:
|
2018-05-17 10:34:28 +00:00
|
|
|
raise Exception("Server notices not enabled")
|
|
|
|
|
2018-05-23 13:30:47 +00:00
|
|
|
assert self._is_mine_id(user_id), "Cannot send server notices to remote users"
|
|
|
|
|
2022-04-08 11:51:27 +00:00
|
|
|
requester = create_requester(
|
|
|
|
self.server_notices_mxid, authenticated_entity=self._server_name
|
|
|
|
)
|
|
|
|
|
2022-05-13 13:30:15 +00:00
|
|
|
room_id = await self.maybe_get_notice_room_for_user(user_id)
|
|
|
|
if room_id is not None:
|
|
|
|
logger.info(
|
|
|
|
"Using existing server notices room %s for user %s",
|
|
|
|
room_id,
|
|
|
|
user_id,
|
|
|
|
)
|
|
|
|
await self._update_notice_user_profile_if_changed(
|
|
|
|
requester,
|
|
|
|
room_id,
|
|
|
|
self._config.servernotices.server_notices_mxid_display_name,
|
|
|
|
self._config.servernotices.server_notices_mxid_avatar_url,
|
|
|
|
)
|
|
|
|
return room_id
|
2018-05-17 10:34:28 +00:00
|
|
|
|
|
|
|
# apparently no existing notice room: create a new one
|
|
|
|
logger.info("Creating server notices room for %s", user_id)
|
|
|
|
|
2018-05-23 16:43:30 +00: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 (
|
2021-09-24 11:25:21 +00:00
|
|
|
self._config.servernotices.server_notices_mxid_display_name is not None
|
|
|
|
or self._config.servernotices.server_notices_mxid_avatar_url is not None
|
2018-05-23 16:43:30 +00:00
|
|
|
):
|
|
|
|
join_profile = {
|
2021-09-24 11:25:21 +00:00
|
|
|
"displayname": self._config.servernotices.server_notices_mxid_display_name,
|
|
|
|
"avatar_url": self._config.servernotices.server_notices_mxid_avatar_url,
|
2018-05-23 16:43:30 +00:00
|
|
|
}
|
|
|
|
|
2020-05-22 13:21:54 +00:00
|
|
|
info, _ = await self._room_creation_handler.create_room(
|
2018-05-17 10:34:28 +00:00
|
|
|
requester,
|
|
|
|
config={
|
|
|
|
"preset": RoomCreationPreset.PRIVATE_CHAT,
|
2021-09-24 11:25:21 +00:00
|
|
|
"name": self._config.servernotices.server_notices_room_name,
|
2018-05-17 10:34:28 +00:00
|
|
|
"power_level_content_override": {"users_default": -10},
|
|
|
|
},
|
|
|
|
ratelimit=False,
|
2018-05-23 16:43:30 +00:00
|
|
|
creator_join_profile=join_profile,
|
2018-05-17 10:34:28 +00:00
|
|
|
)
|
|
|
|
room_id = info["room_id"]
|
2018-08-24 13:50:03 +00:00
|
|
|
|
2022-05-13 13:30:15 +00:00
|
|
|
self.maybe_get_notice_room_for_user.invalidate((user_id,))
|
|
|
|
|
2021-01-20 10:44:52 +00:00
|
|
|
max_id = await self._account_data_handler.add_tag_to_room(
|
2018-08-24 13:44:16 +00:00
|
|
|
user_id, room_id, SERVER_NOTICE_ROOM_TAG, {}
|
2018-08-24 13:50:03 +00:00
|
|
|
)
|
2022-05-16 15:35:31 +00:00
|
|
|
self._notifier.on_new_event(StreamKeyType.ACCOUNT_DATA, max_id, users=[user_id])
|
2018-05-17 10:34:28 +00:00
|
|
|
|
|
|
|
logger.info("Created server notices room %s for %s", room_id, user_id)
|
2019-07-23 13:00:55 +00: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 15:27:45 +00:00
|
|
|
|
2020-07-31 20:22:06 +00: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 15:27:45 +00: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.
|
|
|
|
"""
|
2021-09-24 11:25:21 +00:00
|
|
|
assert self.server_notices_mxid is not None
|
2020-11-17 10:51:25 +00: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 15:27:45 +00: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 14:15:36 +00: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 15:27:45 +00:00
|
|
|
user_id, [Membership.INVITE, Membership.JOIN]
|
|
|
|
)
|
|
|
|
for room in joined_rooms:
|
|
|
|
if room.room_id == room_id:
|
|
|
|
return
|
|
|
|
|
2020-05-01 14:15:36 +00: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 15:27:45 +00:00
|
|
|
requester=requester,
|
|
|
|
target=UserID.from_string(user_id),
|
|
|
|
room_id=room_id,
|
|
|
|
action="invite",
|
|
|
|
)
|
2022-04-08 11:51:27 +00:00
|
|
|
|
|
|
|
async def _update_notice_user_profile_if_changed(
|
|
|
|
self,
|
|
|
|
requester: Requester,
|
|
|
|
room_id: str,
|
|
|
|
display_name: Optional[str],
|
|
|
|
avatar_url: Optional[str],
|
|
|
|
) -> None:
|
|
|
|
"""
|
|
|
|
Updates the notice user's profile if it's different from what is in the room.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
requester: The user who is performing the update.
|
|
|
|
room_id: The ID of the server notice room
|
|
|
|
display_name: The displayname of the server notice user
|
|
|
|
avatar_url: The avatar url of the server notice user
|
|
|
|
"""
|
|
|
|
logger.debug("Checking whether notice user profile has changed for %s", room_id)
|
|
|
|
|
|
|
|
assert self.server_notices_mxid is not None
|
|
|
|
|
|
|
|
notice_user_data_in_room = await self._message_handler.get_room_data(
|
2022-08-22 13:17:59 +00:00
|
|
|
create_requester(self.server_notices_mxid),
|
2022-04-08 11:51:27 +00:00
|
|
|
room_id,
|
|
|
|
EventTypes.Member,
|
|
|
|
self.server_notices_mxid,
|
|
|
|
)
|
|
|
|
|
|
|
|
assert notice_user_data_in_room is not None
|
|
|
|
|
|
|
|
notice_user_profile_changed = (
|
|
|
|
display_name != notice_user_data_in_room.content.get("displayname")
|
|
|
|
or avatar_url != notice_user_data_in_room.content.get("avatar_url")
|
|
|
|
)
|
|
|
|
if notice_user_profile_changed:
|
|
|
|
logger.info("Updating notice user profile in room %s", room_id)
|
|
|
|
await self._room_member_handler.update_membership(
|
|
|
|
requester=requester,
|
|
|
|
target=UserID.from_string(self.server_notices_mxid),
|
|
|
|
room_id=room_id,
|
|
|
|
action="join",
|
|
|
|
content={"displayname": display_name, "avatar_url": avatar_url},
|
|
|
|
)
|