2016-01-06 23:26:29 -05:00
|
|
|
# Copyright 2014-2016 OpenMarket Ltd
|
2018-02-23 05:41:34 -05:00
|
|
|
# Copyright 2018 New Vector Ltd
|
2014-11-19 13:20:59 -05: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 02:09:20 -04:00
|
|
|
import logging
|
2022-04-27 08:05:00 -04:00
|
|
|
from typing import (
|
|
|
|
TYPE_CHECKING,
|
|
|
|
Any,
|
|
|
|
Dict,
|
|
|
|
Iterable,
|
|
|
|
Iterator,
|
|
|
|
List,
|
|
|
|
Optional,
|
|
|
|
Tuple,
|
|
|
|
cast,
|
|
|
|
)
|
2014-11-19 13:20:59 -05:00
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
from synapse.push import PusherConfig, ThrottleParams
|
2020-07-16 11:32:19 -04:00
|
|
|
from synapse.storage._base import SQLBaseStore, db_to_json
|
2022-04-27 08:05:00 -04:00
|
|
|
from synapse.storage.database import (
|
|
|
|
DatabasePool,
|
|
|
|
LoggingDatabaseConnection,
|
|
|
|
LoggingTransaction,
|
|
|
|
)
|
2020-12-16 11:25:30 -05:00
|
|
|
from synapse.storage.util.id_generators import StreamIdGenerator
|
|
|
|
from synapse.types import JsonDict
|
2021-01-15 11:57:23 -05:00
|
|
|
from synapse.util import json_encoder
|
2021-12-15 12:00:50 -05:00
|
|
|
from synapse.util.caches.descriptors import cached
|
2016-04-06 10:42:15 -04:00
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
if TYPE_CHECKING:
|
2021-03-23 07:12:48 -04:00
|
|
|
from synapse.server import HomeServer
|
2020-12-16 11:25:30 -05:00
|
|
|
|
2014-11-19 13:20:59 -05:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
2014-12-03 08:37:02 -05:00
|
|
|
|
2018-02-21 05:54:18 -05:00
|
|
|
class PusherWorkerStore(SQLBaseStore):
|
2021-10-08 10:25:16 -04:00
|
|
|
def __init__(
|
|
|
|
self,
|
|
|
|
database: DatabasePool,
|
|
|
|
db_conn: LoggingDatabaseConnection,
|
|
|
|
hs: "HomeServer",
|
|
|
|
):
|
2020-12-16 11:25:30 -05:00
|
|
|
super().__init__(database, db_conn, hs)
|
|
|
|
self._pushers_id_gen = StreamIdGenerator(
|
|
|
|
db_conn, "pushers", "id", extra_tables=[("deleted_pushers", "stream_id")]
|
|
|
|
)
|
|
|
|
|
2021-03-02 09:05:01 -05:00
|
|
|
self.db_pool.updates.register_background_update_handler(
|
|
|
|
"remove_deactivated_pushers",
|
|
|
|
self._remove_deactivated_pushers,
|
|
|
|
)
|
|
|
|
|
2021-03-03 07:08:16 -05:00
|
|
|
self.db_pool.updates.register_background_update_handler(
|
|
|
|
"remove_stale_pushers",
|
|
|
|
self._remove_stale_pushers,
|
|
|
|
)
|
|
|
|
|
2021-08-26 08:53:57 -04:00
|
|
|
self.db_pool.updates.register_background_update_handler(
|
|
|
|
"remove_deleted_email_pushers",
|
|
|
|
self._remove_deleted_email_pushers,
|
|
|
|
)
|
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
def _decode_pushers_rows(self, rows: Iterable[dict]) -> Iterator[PusherConfig]:
|
2019-12-18 09:26:58 -05:00
|
|
|
"""JSON-decode the data in the rows returned from the `pushers` table
|
|
|
|
|
|
|
|
Drops any rows whose data cannot be decoded
|
|
|
|
"""
|
2015-04-29 14:41:14 -04:00
|
|
|
for r in rows:
|
2020-08-14 10:30:16 -04:00
|
|
|
data_json = r["data"]
|
2015-04-29 14:41:14 -04:00
|
|
|
try:
|
2020-08-14 10:30:16 -04:00
|
|
|
r["data"] = db_to_json(data_json)
|
2015-04-29 14:41:14 -04:00
|
|
|
except Exception as e:
|
2019-10-31 06:23:24 -04:00
|
|
|
logger.warning(
|
2015-04-29 14:41:14 -04:00
|
|
|
"Invalid JSON in data for pusher %d: %s, %s",
|
2019-06-20 05:32:02 -04:00
|
|
|
r["id"],
|
2020-08-14 10:30:16 -04:00
|
|
|
data_json,
|
2019-04-03 05:07:29 -04:00
|
|
|
e.args[0],
|
2015-04-29 14:41:14 -04:00
|
|
|
)
|
2019-12-18 09:26:58 -05:00
|
|
|
continue
|
2015-04-29 14:41:14 -04:00
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
yield PusherConfig(**r)
|
2015-04-29 14:41:14 -04:00
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
async def user_has_pusher(self, user_id: str) -> bool:
|
2020-08-14 10:30:16 -04:00
|
|
|
ret = await self.db_pool.simple_select_one_onecol(
|
2016-04-08 10:29:59 -04:00
|
|
|
"pushers", {"user_name": user_id}, "id", allow_none=True
|
|
|
|
)
|
2019-07-23 09:00:55 -04:00
|
|
|
return ret is not None
|
2016-04-08 10:29:59 -04:00
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
async def get_pushers_by_app_id_and_pushkey(
|
|
|
|
self, app_id: str, pushkey: str
|
|
|
|
) -> Iterator[PusherConfig]:
|
|
|
|
return await self.get_pushers_by({"app_id": app_id, "pushkey": pushkey})
|
2014-12-18 09:49:22 -05:00
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
async def get_pushers_by_user_id(self, user_id: str) -> Iterator[PusherConfig]:
|
|
|
|
return await self.get_pushers_by({"user_name": user_id})
|
2016-04-11 13:00:03 -04:00
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
async def get_pushers_by(self, keyvalues: Dict[str, Any]) -> Iterator[PusherConfig]:
|
2020-08-14 10:30:16 -04:00
|
|
|
ret = await self.db_pool.simple_select_list(
|
2019-04-03 05:07:29 -04:00
|
|
|
"pushers",
|
|
|
|
keyvalues,
|
2016-04-12 08:47:17 -04:00
|
|
|
[
|
|
|
|
"id",
|
|
|
|
"user_name",
|
|
|
|
"access_token",
|
|
|
|
"profile_tag",
|
|
|
|
"kind",
|
|
|
|
"app_id",
|
|
|
|
"app_display_name",
|
|
|
|
"device_display_name",
|
|
|
|
"pushkey",
|
|
|
|
"ts",
|
|
|
|
"lang",
|
|
|
|
"data",
|
|
|
|
"last_stream_ordering",
|
|
|
|
"last_success",
|
|
|
|
"failing_since",
|
2019-04-03 05:07:29 -04:00
|
|
|
],
|
|
|
|
desc="get_pushers_by",
|
2016-04-11 13:00:03 -04:00
|
|
|
)
|
2019-07-23 09:00:55 -04:00
|
|
|
return self._decode_pushers_rows(ret)
|
2016-04-11 13:00:03 -04:00
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
async def get_all_pushers(self) -> Iterator[PusherConfig]:
|
2022-04-27 08:05:00 -04:00
|
|
|
def get_pushers(txn: LoggingTransaction) -> Iterator[PusherConfig]:
|
2015-04-29 13:03:42 -04:00
|
|
|
txn.execute("SELECT * FROM pushers")
|
2020-08-05 16:38:57 -04:00
|
|
|
rows = self.db_pool.cursor_to_dict(txn)
|
2014-12-18 09:49:22 -05:00
|
|
|
|
2015-04-29 14:41:14 -04:00
|
|
|
return self._decode_pushers_rows(rows)
|
2015-04-29 13:07:36 -04:00
|
|
|
|
2020-08-14 10:30:16 -04:00
|
|
|
return await self.db_pool.runInteraction("get_all_pushers", get_pushers)
|
2014-11-19 13:20:59 -05:00
|
|
|
|
2020-07-07 07:11:35 -04:00
|
|
|
async def get_all_updated_pushers_rows(
|
|
|
|
self, instance_name: str, last_id: int, current_id: int, limit: int
|
|
|
|
) -> Tuple[List[Tuple[int, tuple]], int, bool]:
|
|
|
|
"""Get updates for pushers replication stream.
|
2016-03-15 13:01:43 -04:00
|
|
|
|
2020-07-07 07:11:35 -04:00
|
|
|
Args:
|
|
|
|
instance_name: The writer we want to fetch updates from. Unused
|
|
|
|
here since there is only ever one writer.
|
|
|
|
last_id: The token to fetch updates from. Exclusive.
|
|
|
|
current_id: The token to fetch updates up to. Inclusive.
|
|
|
|
limit: The requested limit for the number of rows to return. The
|
|
|
|
function may return more or fewer rows.
|
2019-04-03 05:07:29 -04:00
|
|
|
|
2020-07-07 07:11:35 -04:00
|
|
|
Returns:
|
|
|
|
A tuple consisting of: the updates, a token to use to fetch
|
|
|
|
subsequent updates, and whether we returned fewer rows than exists
|
|
|
|
between the requested tokens due to the limit.
|
2016-03-15 13:01:43 -04:00
|
|
|
|
2020-07-07 07:11:35 -04:00
|
|
|
The token returned can be used in a subsequent call to this
|
|
|
|
function to get further updatees.
|
2017-03-27 09:03:38 -04:00
|
|
|
|
2020-07-07 07:11:35 -04:00
|
|
|
The updates are a list of 2-tuples of stream ID and the row data
|
2017-03-27 09:03:38 -04:00
|
|
|
"""
|
|
|
|
|
|
|
|
if last_id == current_id:
|
2020-07-07 07:11:35 -04:00
|
|
|
return [], current_id, False
|
2017-03-27 09:03:38 -04:00
|
|
|
|
2022-04-27 08:05:00 -04:00
|
|
|
def get_all_updated_pushers_rows_txn(
|
|
|
|
txn: LoggingTransaction,
|
|
|
|
) -> Tuple[List[Tuple[int, tuple]], int, bool]:
|
2020-07-07 07:11:35 -04:00
|
|
|
sql = """
|
|
|
|
SELECT id, user_name, app_id, pushkey
|
|
|
|
FROM pushers
|
|
|
|
WHERE ? < id AND id <= ?
|
|
|
|
ORDER BY id ASC LIMIT ?
|
|
|
|
"""
|
2017-03-27 09:03:38 -04:00
|
|
|
txn.execute(sql, (last_id, current_id, limit))
|
2022-04-27 08:05:00 -04:00
|
|
|
updates = cast(
|
|
|
|
List[Tuple[int, tuple]],
|
|
|
|
[
|
|
|
|
(stream_id, (user_name, app_id, pushkey, False))
|
|
|
|
for stream_id, user_name, app_id, pushkey in txn
|
|
|
|
],
|
|
|
|
)
|
2020-07-07 07:11:35 -04:00
|
|
|
|
|
|
|
sql = """
|
|
|
|
SELECT stream_id, user_id, app_id, pushkey
|
|
|
|
FROM deleted_pushers
|
|
|
|
WHERE ? < stream_id AND stream_id <= ?
|
|
|
|
ORDER BY stream_id ASC LIMIT ?
|
|
|
|
"""
|
2017-03-27 09:03:38 -04:00
|
|
|
txn.execute(sql, (last_id, current_id, limit))
|
2020-07-07 07:11:35 -04:00
|
|
|
updates.extend(
|
|
|
|
(stream_id, (user_name, app_id, pushkey, True))
|
|
|
|
for stream_id, user_name, app_id, pushkey in txn
|
|
|
|
)
|
|
|
|
|
|
|
|
updates.sort() # Sort so that they're ordered by stream id
|
2017-03-27 09:03:38 -04:00
|
|
|
|
2020-07-07 07:11:35 -04:00
|
|
|
limited = False
|
|
|
|
upper_bound = current_id
|
|
|
|
if len(updates) >= limit:
|
|
|
|
limited = True
|
|
|
|
upper_bound = updates[-1][0]
|
2017-03-27 09:03:38 -04:00
|
|
|
|
2020-07-07 07:11:35 -04:00
|
|
|
return updates, upper_bound, limited
|
2019-04-03 05:07:29 -04:00
|
|
|
|
2020-08-05 16:38:57 -04:00
|
|
|
return await self.db_pool.runInteraction(
|
2017-03-27 09:03:38 -04:00
|
|
|
"get_all_updated_pushers_rows", get_all_updated_pushers_rows_txn
|
|
|
|
)
|
|
|
|
|
2020-08-14 10:30:16 -04:00
|
|
|
@cached(num_args=1, max_entries=15000)
|
2022-04-27 08:05:00 -04:00
|
|
|
async def get_if_user_has_pusher(self, user_id: str) -> None:
|
2016-11-04 06:53:42 -04:00
|
|
|
# This only exists for the cachedList decorator
|
2016-11-04 06:48:20 -04:00
|
|
|
raise NotImplementedError()
|
2016-06-01 06:08:45 -04:00
|
|
|
|
2020-08-14 10:30:16 -04:00
|
|
|
async def update_pusher_last_stream_ordering(
|
2022-04-27 08:05:00 -04:00
|
|
|
self, app_id: str, pushkey: str, user_id: str, last_stream_ordering: int
|
2020-08-14 10:30:16 -04:00
|
|
|
) -> None:
|
|
|
|
await self.db_pool.simple_update_one(
|
2020-02-25 11:56:55 -05:00
|
|
|
"pushers",
|
|
|
|
{"app_id": app_id, "pushkey": pushkey, "user_name": user_id},
|
|
|
|
{"last_stream_ordering": last_stream_ordering},
|
|
|
|
desc="update_pusher_last_stream_ordering",
|
|
|
|
)
|
|
|
|
|
2020-08-14 10:30:16 -04:00
|
|
|
async def update_pusher_last_stream_ordering_and_success(
|
|
|
|
self,
|
|
|
|
app_id: str,
|
|
|
|
pushkey: str,
|
|
|
|
user_id: str,
|
|
|
|
last_stream_ordering: int,
|
|
|
|
last_success: int,
|
|
|
|
) -> bool:
|
2020-02-25 11:56:55 -05:00
|
|
|
"""Update the last stream ordering position we've processed up to for
|
|
|
|
the given pusher.
|
|
|
|
|
|
|
|
Args:
|
2020-08-14 10:30:16 -04:00
|
|
|
app_id
|
|
|
|
pushkey
|
|
|
|
user_id
|
|
|
|
last_stream_ordering
|
|
|
|
last_success
|
2020-02-25 11:56:55 -05:00
|
|
|
|
|
|
|
Returns:
|
2020-08-14 10:30:16 -04:00
|
|
|
True if the pusher still exists; False if it has been deleted.
|
2020-02-25 11:56:55 -05:00
|
|
|
"""
|
2020-08-14 10:30:16 -04:00
|
|
|
updated = await self.db_pool.simple_update(
|
2020-02-25 11:56:55 -05:00
|
|
|
table="pushers",
|
|
|
|
keyvalues={"app_id": app_id, "pushkey": pushkey, "user_name": user_id},
|
|
|
|
updatevalues={
|
|
|
|
"last_stream_ordering": last_stream_ordering,
|
|
|
|
"last_success": last_success,
|
|
|
|
},
|
|
|
|
desc="update_pusher_last_stream_ordering_and_success",
|
|
|
|
)
|
|
|
|
|
|
|
|
return bool(updated)
|
|
|
|
|
2020-08-14 10:30:16 -04:00
|
|
|
async def update_pusher_failing_since(
|
2020-12-16 11:25:30 -05:00
|
|
|
self, app_id: str, pushkey: str, user_id: str, failing_since: Optional[int]
|
2020-08-14 10:30:16 -04:00
|
|
|
) -> None:
|
|
|
|
await self.db_pool.simple_update(
|
2020-02-25 11:56:55 -05:00
|
|
|
table="pushers",
|
|
|
|
keyvalues={"app_id": app_id, "pushkey": pushkey, "user_name": user_id},
|
|
|
|
updatevalues={"failing_since": failing_since},
|
|
|
|
desc="update_pusher_failing_since",
|
|
|
|
)
|
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
async def get_throttle_params_by_room(
|
|
|
|
self, pusher_id: str
|
|
|
|
) -> Dict[str, ThrottleParams]:
|
2020-08-14 10:30:16 -04:00
|
|
|
res = await self.db_pool.simple_select_list(
|
2020-02-25 11:56:55 -05:00
|
|
|
"pusher_throttle",
|
|
|
|
{"pusher": pusher_id},
|
|
|
|
["room_id", "last_sent_ts", "throttle_ms"],
|
|
|
|
desc="get_throttle_params_by_room",
|
|
|
|
)
|
|
|
|
|
|
|
|
params_by_room = {}
|
|
|
|
for row in res:
|
2020-12-16 11:25:30 -05:00
|
|
|
params_by_room[row["room_id"]] = ThrottleParams(
|
2021-02-16 17:32:34 -05:00
|
|
|
row["last_sent_ts"],
|
|
|
|
row["throttle_ms"],
|
2020-12-16 11:25:30 -05:00
|
|
|
)
|
2020-02-25 11:56:55 -05:00
|
|
|
|
|
|
|
return params_by_room
|
|
|
|
|
2020-12-16 11:25:30 -05:00
|
|
|
async def set_throttle_params(
|
|
|
|
self, pusher_id: str, room_id: str, params: ThrottleParams
|
|
|
|
) -> None:
|
2020-02-25 11:56:55 -05:00
|
|
|
# no need to lock because `pusher_throttle` has a primary key on
|
|
|
|
# (pusher, room_id) so simple_upsert will retry
|
2020-08-14 10:30:16 -04:00
|
|
|
await self.db_pool.simple_upsert(
|
2020-02-25 11:56:55 -05:00
|
|
|
"pusher_throttle",
|
|
|
|
{"pusher": pusher_id, "room_id": room_id},
|
2020-12-16 11:25:30 -05:00
|
|
|
{"last_sent_ts": params.last_sent_ts, "throttle_ms": params.throttle_ms},
|
2020-02-25 11:56:55 -05:00
|
|
|
desc="set_throttle_params",
|
|
|
|
lock=False,
|
|
|
|
)
|
|
|
|
|
2021-03-02 09:05:01 -05:00
|
|
|
async def _remove_deactivated_pushers(self, progress: dict, batch_size: int) -> int:
|
|
|
|
"""A background update that deletes all pushers for deactivated users.
|
|
|
|
|
|
|
|
Note that we don't proacively tell the pusherpool that we've deleted
|
|
|
|
these (just because its a bit off a faff to do from here), but they will
|
|
|
|
get cleaned up at the next restart
|
|
|
|
"""
|
|
|
|
|
|
|
|
last_user = progress.get("last_user", "")
|
|
|
|
|
2022-04-27 08:05:00 -04:00
|
|
|
def _delete_pushers(txn: LoggingTransaction) -> int:
|
2021-03-02 09:05:01 -05:00
|
|
|
|
|
|
|
sql = """
|
|
|
|
SELECT name FROM users
|
|
|
|
WHERE deactivated = ? and name > ?
|
|
|
|
ORDER BY name ASC
|
|
|
|
LIMIT ?
|
|
|
|
"""
|
|
|
|
|
|
|
|
txn.execute(sql, (1, last_user, batch_size))
|
|
|
|
users = [row[0] for row in txn]
|
|
|
|
|
|
|
|
self.db_pool.simple_delete_many_txn(
|
|
|
|
txn,
|
|
|
|
table="pushers",
|
|
|
|
column="user_name",
|
2021-09-20 05:26:13 -04:00
|
|
|
values=users,
|
2021-03-02 09:05:01 -05:00
|
|
|
keyvalues={},
|
|
|
|
)
|
|
|
|
|
|
|
|
if users:
|
|
|
|
self.db_pool.updates._background_update_progress_txn(
|
|
|
|
txn, "remove_deactivated_pushers", {"last_user": users[-1]}
|
|
|
|
)
|
|
|
|
|
|
|
|
return len(users)
|
|
|
|
|
|
|
|
number_deleted = await self.db_pool.runInteraction(
|
|
|
|
"_remove_deactivated_pushers", _delete_pushers
|
|
|
|
)
|
|
|
|
|
|
|
|
if number_deleted < batch_size:
|
|
|
|
await self.db_pool.updates._end_background_update(
|
|
|
|
"remove_deactivated_pushers"
|
|
|
|
)
|
|
|
|
|
|
|
|
return number_deleted
|
2021-03-03 07:08:16 -05:00
|
|
|
|
|
|
|
async def _remove_stale_pushers(self, progress: dict, batch_size: int) -> int:
|
|
|
|
"""A background update that deletes all pushers for logged out devices.
|
|
|
|
|
|
|
|
Note that we don't proacively tell the pusherpool that we've deleted
|
|
|
|
these (just because its a bit off a faff to do from here), but they will
|
|
|
|
get cleaned up at the next restart
|
|
|
|
"""
|
|
|
|
|
|
|
|
last_pusher = progress.get("last_pusher", 0)
|
|
|
|
|
2022-04-27 08:05:00 -04:00
|
|
|
def _delete_pushers(txn: LoggingTransaction) -> int:
|
2021-03-03 07:08:16 -05:00
|
|
|
|
|
|
|
sql = """
|
|
|
|
SELECT p.id, access_token FROM pushers AS p
|
|
|
|
LEFT JOIN access_tokens AS a ON (p.access_token = a.id)
|
|
|
|
WHERE p.id > ?
|
|
|
|
ORDER BY p.id ASC
|
|
|
|
LIMIT ?
|
|
|
|
"""
|
|
|
|
|
|
|
|
txn.execute(sql, (last_pusher, batch_size))
|
|
|
|
pushers = [(row[0], row[1]) for row in txn]
|
|
|
|
|
|
|
|
self.db_pool.simple_delete_many_txn(
|
|
|
|
txn,
|
|
|
|
table="pushers",
|
|
|
|
column="id",
|
2021-09-20 05:26:13 -04:00
|
|
|
values=[pusher_id for pusher_id, token in pushers if token is None],
|
2021-03-03 07:08:16 -05:00
|
|
|
keyvalues={},
|
|
|
|
)
|
|
|
|
|
|
|
|
if pushers:
|
|
|
|
self.db_pool.updates._background_update_progress_txn(
|
|
|
|
txn, "remove_stale_pushers", {"last_pusher": pushers[-1][0]}
|
|
|
|
)
|
|
|
|
|
|
|
|
return len(pushers)
|
|
|
|
|
|
|
|
number_deleted = await self.db_pool.runInteraction(
|
|
|
|
"_remove_stale_pushers", _delete_pushers
|
|
|
|
)
|
|
|
|
|
|
|
|
if number_deleted < batch_size:
|
|
|
|
await self.db_pool.updates._end_background_update("remove_stale_pushers")
|
|
|
|
|
|
|
|
return number_deleted
|
2021-08-26 08:53:57 -04:00
|
|
|
|
|
|
|
async def _remove_deleted_email_pushers(
|
|
|
|
self, progress: dict, batch_size: int
|
|
|
|
) -> int:
|
|
|
|
"""A background update that deletes all pushers for deleted email addresses.
|
|
|
|
|
|
|
|
In previous versions of synapse, when users deleted their email address, it didn't
|
|
|
|
also delete all the pushers for that email address. This background update removes
|
|
|
|
those to prevent unwanted emails. This should only need to be run once (when users
|
|
|
|
upgrade to v1.42.0
|
|
|
|
|
|
|
|
Args:
|
|
|
|
progress: dict used to store progress of this background update
|
|
|
|
batch_size: the maximum number of rows to retrieve in a single select query
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The number of deleted rows
|
|
|
|
"""
|
|
|
|
|
|
|
|
last_pusher = progress.get("last_pusher", 0)
|
|
|
|
|
2022-04-27 08:05:00 -04:00
|
|
|
def _delete_pushers(txn: LoggingTransaction) -> int:
|
2021-08-26 08:53:57 -04:00
|
|
|
|
|
|
|
sql = """
|
|
|
|
SELECT p.id, p.user_name, p.app_id, p.pushkey
|
|
|
|
FROM pushers AS p
|
|
|
|
LEFT JOIN user_threepids AS t
|
|
|
|
ON t.user_id = p.user_name
|
|
|
|
AND t.medium = 'email'
|
|
|
|
AND t.address = p.pushkey
|
|
|
|
WHERE t.user_id is NULL
|
|
|
|
AND p.app_id = 'm.email'
|
|
|
|
AND p.id > ?
|
|
|
|
ORDER BY p.id ASC
|
|
|
|
LIMIT ?
|
|
|
|
"""
|
|
|
|
|
|
|
|
txn.execute(sql, (last_pusher, batch_size))
|
2021-09-01 05:13:01 -04:00
|
|
|
rows = txn.fetchall()
|
2021-08-26 08:53:57 -04:00
|
|
|
|
|
|
|
last = None
|
|
|
|
num_deleted = 0
|
2021-09-01 05:13:01 -04:00
|
|
|
for row in rows:
|
2021-08-26 08:53:57 -04:00
|
|
|
last = row[0]
|
|
|
|
num_deleted += 1
|
|
|
|
self.db_pool.simple_delete_txn(
|
|
|
|
txn,
|
|
|
|
"pushers",
|
|
|
|
{"user_name": row[1], "app_id": row[2], "pushkey": row[3]},
|
|
|
|
)
|
|
|
|
|
|
|
|
if last is not None:
|
|
|
|
self.db_pool.updates._background_update_progress_txn(
|
|
|
|
txn, "remove_deleted_email_pushers", {"last_pusher": last}
|
|
|
|
)
|
|
|
|
|
|
|
|
return num_deleted
|
|
|
|
|
|
|
|
number_deleted = await self.db_pool.runInteraction(
|
|
|
|
"_remove_deleted_email_pushers", _delete_pushers
|
|
|
|
)
|
|
|
|
|
|
|
|
if number_deleted < batch_size:
|
|
|
|
await self.db_pool.updates._end_background_update(
|
|
|
|
"remove_deleted_email_pushers"
|
|
|
|
)
|
|
|
|
|
|
|
|
return number_deleted
|
2021-03-02 09:05:01 -05:00
|
|
|
|
2018-02-27 07:01:36 -05:00
|
|
|
|
|
|
|
class PusherStore(PusherWorkerStore):
|
2020-12-16 11:25:30 -05:00
|
|
|
def get_pushers_stream_token(self) -> int:
|
2018-02-27 07:01:36 -05:00
|
|
|
return self._pushers_id_gen.get_current_token()
|
|
|
|
|
2020-08-14 10:30:16 -04:00
|
|
|
async def add_pusher(
|
2019-04-03 05:07:29 -04:00
|
|
|
self,
|
2020-12-16 11:25:30 -05:00
|
|
|
user_id: str,
|
|
|
|
access_token: Optional[int],
|
|
|
|
kind: str,
|
|
|
|
app_id: str,
|
|
|
|
app_display_name: str,
|
|
|
|
device_display_name: str,
|
|
|
|
pushkey: str,
|
|
|
|
pushkey_ts: int,
|
|
|
|
lang: Optional[str],
|
|
|
|
data: Optional[JsonDict],
|
|
|
|
last_stream_ordering: int,
|
|
|
|
profile_tag: str = "",
|
2020-08-14 10:30:16 -04:00
|
|
|
) -> None:
|
2020-09-23 11:11:18 -04:00
|
|
|
async with self._pushers_id_gen.get_next() as stream_id:
|
2017-11-16 10:32:01 -05:00
|
|
|
# no need to lock because `pushers` has a unique key on
|
2019-12-04 05:15:55 -05:00
|
|
|
# (app_id, pushkey, user_name) so simple_upsert will retry
|
2020-08-14 10:30:16 -04:00
|
|
|
await self.db_pool.simple_upsert(
|
2017-11-16 10:32:01 -05:00
|
|
|
table="pushers",
|
2019-04-03 05:07:29 -04:00
|
|
|
keyvalues={"app_id": app_id, "pushkey": pushkey, "user_name": user_id},
|
2017-11-16 10:32:01 -05:00
|
|
|
values={
|
|
|
|
"access_token": access_token,
|
|
|
|
"kind": kind,
|
|
|
|
"app_display_name": app_display_name,
|
|
|
|
"device_display_name": device_display_name,
|
|
|
|
"ts": pushkey_ts,
|
|
|
|
"lang": lang,
|
2021-01-15 11:57:23 -05:00
|
|
|
"data": json_encoder.encode(data),
|
2017-11-16 10:32:01 -05:00
|
|
|
"last_stream_ordering": last_stream_ordering,
|
|
|
|
"profile_tag": profile_tag,
|
|
|
|
"id": stream_id,
|
|
|
|
},
|
|
|
|
desc="add_pusher",
|
|
|
|
lock=False,
|
|
|
|
)
|
2016-05-13 06:25:02 -04:00
|
|
|
|
2020-10-19 10:00:12 -04:00
|
|
|
user_has_pusher = self.get_if_user_has_pusher.cache.get_immediate(
|
2019-01-24 05:31:54 -05:00
|
|
|
(user_id,), None, update_metrics=False
|
|
|
|
)
|
|
|
|
|
|
|
|
if user_has_pusher is not True:
|
|
|
|
# invalidate, since we the user might not have had a pusher before
|
2020-08-14 10:30:16 -04:00
|
|
|
await self.db_pool.runInteraction(
|
2018-02-27 07:01:36 -05:00
|
|
|
"add_pusher",
|
2021-12-29 08:04:28 -05:00
|
|
|
self._invalidate_cache_and_stream, # type: ignore[attr-defined]
|
2019-04-03 05:07:29 -04:00
|
|
|
self.get_if_user_has_pusher,
|
|
|
|
(user_id,),
|
2018-02-27 07:01:36 -05:00
|
|
|
)
|
2014-11-19 13:20:59 -05:00
|
|
|
|
2020-08-14 10:30:16 -04:00
|
|
|
async def delete_pusher_by_app_id_pushkey_user_id(
|
2020-12-16 11:25:30 -05:00
|
|
|
self, app_id: str, pushkey: str, user_id: str
|
2020-08-14 10:30:16 -04:00
|
|
|
) -> None:
|
2022-04-27 08:05:00 -04:00
|
|
|
def delete_pusher_txn(txn: LoggingTransaction, stream_id: int) -> None:
|
2021-12-29 08:04:28 -05:00
|
|
|
self._invalidate_cache_and_stream( # type: ignore[attr-defined]
|
2018-02-27 07:01:36 -05:00
|
|
|
txn, self.get_if_user_has_pusher, (user_id,)
|
|
|
|
)
|
2016-05-13 06:25:02 -04:00
|
|
|
|
2021-01-25 14:52:30 -05:00
|
|
|
# It is expected that there is exactly one pusher to delete, but
|
|
|
|
# if it isn't there (or there are multiple) delete them all.
|
|
|
|
self.db_pool.simple_delete_txn(
|
2016-03-15 13:01:43 -04:00
|
|
|
txn,
|
|
|
|
"pushers",
|
2019-04-03 05:07:29 -04:00
|
|
|
{"app_id": app_id, "pushkey": pushkey, "user_name": user_id},
|
2016-03-15 13:01:43 -04:00
|
|
|
)
|
2017-11-16 12:44:52 -05:00
|
|
|
|
|
|
|
# it's possible for us to end up with duplicate rows for
|
|
|
|
# (app_id, pushkey, user_id) at different stream_ids, but that
|
|
|
|
# doesn't really matter.
|
2020-08-05 16:38:57 -04:00
|
|
|
self.db_pool.simple_insert_txn(
|
2016-03-15 13:01:43 -04:00
|
|
|
txn,
|
2017-11-16 12:44:52 -05:00
|
|
|
table="deleted_pushers",
|
|
|
|
values={
|
|
|
|
"stream_id": stream_id,
|
|
|
|
"app_id": app_id,
|
|
|
|
"pushkey": pushkey,
|
|
|
|
"user_id": user_id,
|
|
|
|
},
|
2016-03-15 13:01:43 -04:00
|
|
|
)
|
2016-05-13 06:25:02 -04:00
|
|
|
|
2020-09-23 11:11:18 -04:00
|
|
|
async with self._pushers_id_gen.get_next() as stream_id:
|
2020-08-14 10:30:16 -04:00
|
|
|
await self.db_pool.runInteraction(
|
2020-08-05 16:38:57 -04:00
|
|
|
"delete_pusher", delete_pusher_txn, stream_id
|
|
|
|
)
|
2021-02-25 08:56:55 -05:00
|
|
|
|
|
|
|
async def delete_all_pushers_for_user(self, user_id: str) -> None:
|
|
|
|
"""Delete all pushers associated with an account."""
|
|
|
|
|
|
|
|
# We want to generate a row in `deleted_pushers` for each pusher we're
|
|
|
|
# deleting, so we fetch the list now so we can generate the appropriate
|
|
|
|
# number of stream IDs.
|
|
|
|
#
|
|
|
|
# Note: technically there could be a race here between adding/deleting
|
|
|
|
# pushers, but a) the worst case if we don't stop a pusher until the
|
|
|
|
# next restart and b) this is only called when we're deactivating an
|
|
|
|
# account.
|
|
|
|
pushers = list(await self.get_pushers_by_user_id(user_id))
|
|
|
|
|
2022-04-27 08:05:00 -04:00
|
|
|
def delete_pushers_txn(txn: LoggingTransaction, stream_ids: List[int]) -> None:
|
2021-12-29 08:04:28 -05:00
|
|
|
self._invalidate_cache_and_stream( # type: ignore[attr-defined]
|
2021-02-25 08:56:55 -05:00
|
|
|
txn, self.get_if_user_has_pusher, (user_id,)
|
|
|
|
)
|
|
|
|
|
|
|
|
self.db_pool.simple_delete_txn(
|
|
|
|
txn,
|
|
|
|
table="pushers",
|
|
|
|
keyvalues={"user_name": user_id},
|
|
|
|
)
|
|
|
|
|
|
|
|
self.db_pool.simple_insert_many_txn(
|
|
|
|
txn,
|
|
|
|
table="deleted_pushers",
|
2022-01-13 19:44:18 -05:00
|
|
|
keys=("stream_id", "app_id", "pushkey", "user_id"),
|
2021-02-25 08:56:55 -05:00
|
|
|
values=[
|
2022-01-13 19:44:18 -05:00
|
|
|
(stream_id, pusher.app_id, pusher.pushkey, user_id)
|
2021-02-25 08:56:55 -05:00
|
|
|
for stream_id, pusher in zip(stream_ids, pushers)
|
|
|
|
],
|
|
|
|
)
|
|
|
|
|
|
|
|
async with self._pushers_id_gen.get_next_mult(len(pushers)) as stream_ids:
|
|
|
|
await self.db_pool.runInteraction(
|
|
|
|
"delete_all_pushers_for_user", delete_pushers_txn, stream_ids
|
|
|
|
)
|