mirror of
https://github.com/element-hq/synapse.git
synced 2026-07-12 07:30:01 +00:00
Eric Eastwood
7da21a715d
This means you can use `get_success(...)` anywhere regardless of what kind of work needs to be done. Spawning from adding some more async Rust things in https://github.com/element-hq/synapse/pull/19846 and wanting something more standard instead of the custom `till_deferred_has_result(...)` that has crept in to a few files. Alternative to https://github.com/element-hq/synapse/pull/19867 spurred on by [this comment](https://github.com/element-hq/synapse/pull/19867#discussion_r3441774685) from @erikjohnston ### How does this work? Previously, `get_success(...)` just ran in a hot-loop advancing the Twisted reactor clock which didn't give any time for other threads to do some work or acquire the GIL if necessary (whenever there is a hand-off from Rust to Python, we need the GIL). Now, `get_success(...)` loops until we see a result (until we hit the ~0.1s real-time timeout). In the loop, we call [`time.sleep(0)`](https://docs.python.org/3/library/time.html#time.sleep) which will "Suspend execution of the calling thread [...]" (CPU and GIL) to allow other threads to do some work. Then like before, we advance the Twisted reactor clock to run any scheduled callbacks which includes anything the other threads may have scheduled. ### Does this slow down the entire test suite? Seems just as fast as before. There is minutes variance in what we had before and after but both are within the same range of each other. (see PR for actual before/after timings)
97 lines
3.8 KiB
Python
97 lines
3.8 KiB
Python
#
|
|
# This file is licensed under the Affero General Public License (AGPL) version 3.
|
|
#
|
|
# Copyright 2020 The Matrix.org Foundation C.I.C.
|
|
# Copyright (C) 2023 New Vector, Ltd
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as
|
|
# published by the Free Software Foundation, either version 3 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# See the GNU Affero General Public License for more details:
|
|
# <https://www.gnu.org/licenses/agpl-3.0.html>.
|
|
#
|
|
# Originally licensed under the Apache License, Version 2.0:
|
|
# <http://www.apache.org/licenses/LICENSE-2.0>.
|
|
#
|
|
# [This file includes modifications made by New Vector Limited]
|
|
#
|
|
#
|
|
|
|
from unittest import mock
|
|
|
|
from twisted.internet.testing import MemoryReactor
|
|
|
|
from synapse.app.generic_worker import GenericWorkerServer
|
|
from synapse.replication.tcp.commands import FederationAckCommand
|
|
from synapse.replication.tcp.protocol import IReplicationConnection
|
|
from synapse.replication.tcp.streams.federation import FederationStream
|
|
from synapse.server import HomeServer
|
|
from synapse.util.clock import Clock
|
|
|
|
from tests.unittest import HomeserverTestCase
|
|
|
|
|
|
class FederationAckTestCase(HomeserverTestCase):
|
|
def default_config(self) -> dict:
|
|
config = super().default_config()
|
|
config["worker_app"] = "synapse.app.generic_worker"
|
|
config["worker_name"] = "federation_sender1"
|
|
config["federation_sender_instances"] = ["federation_sender1"]
|
|
config["instance_map"] = {"main": {"host": "127.0.0.1", "port": 0}}
|
|
return config
|
|
|
|
def make_homeserver(self, reactor: MemoryReactor, clock: Clock) -> HomeServer:
|
|
return self.setup_test_homeserver(homeserver_to_use=GenericWorkerServer)
|
|
|
|
def test_federation_ack_sent(self) -> None:
|
|
"""A FEDERATION_ACK should be sent back after each RDATA federation
|
|
|
|
This test checks that the federation sender is correctly sending back
|
|
FEDERATION_ACK messages. The test works by spinning up a federation_sender
|
|
worker server, and then fishing out its ReplicationCommandHandler. We wire
|
|
the RCH up to a mock connection (so that we can observe the command being sent)
|
|
and then poke in an RDATA row.
|
|
|
|
XXX: it might be nice to do this by pretending to be a synapse master worker
|
|
(or a redis server), and having the worker connect to us via a mocked-up TCP
|
|
transport, rather than assuming that the implementation has a
|
|
ReplicationCommandHandler.
|
|
"""
|
|
rch = self.hs.get_replication_command_handler()
|
|
|
|
# wire up the ReplicationCommandHandler to a mock connection, which needs
|
|
# to implement IReplicationConnection. (Note that Mock doesn't understand
|
|
# interfaces, but casing an interface to a list gives the attributes.)
|
|
mock_connection = mock.Mock(spec=list(IReplicationConnection))
|
|
rch.new_connection(mock_connection)
|
|
|
|
# tell it it received an RDATA row
|
|
self.get_success(
|
|
rch.on_rdata(
|
|
"federation",
|
|
"master",
|
|
token=10,
|
|
rows=[
|
|
FederationStream.FederationStreamRow(
|
|
type="x", data={"test": [1, 2, 3]}
|
|
)
|
|
],
|
|
)
|
|
)
|
|
|
|
# Wait for the FEDERATION_ACK to be sent
|
|
#
|
|
# `on_rdata` handles this as part of a fire-and-forget background process (see
|
|
# `FederationSenderHandler.update_token`)
|
|
#
|
|
# We're specifically waiting for the database queries in the background process
|
|
self.reactor.advance(0)
|
|
|
|
# now check that the FEDERATION_ACK was sent
|
|
mock_connection.send_command.assert_called_once()
|
|
cmd = mock_connection.send_command.call_args[0][0]
|
|
assert isinstance(cmd, FederationAckCommand)
|
|
self.assertEqual(cmd.token, 10)
|