Optimise some references to hs.config (#7546)
These are surprisingly expensive, and we only really need to do them at startup.
This commit is contained in:
parent
2901f54359
commit
f4269694ce
|
@ -0,0 +1 @@
|
|||
Optimise some references to `hs.config`.
|
|
@ -366,7 +366,9 @@ class EventCreationHandler(object):
|
|||
self.notifier = hs.get_notifier()
|
||||
self.config = hs.config
|
||||
self.require_membership_for_aliases = hs.config.require_membership_for_aliases
|
||||
self._instance_name = hs.get_instance_name()
|
||||
self._is_event_writer = (
|
||||
self.config.worker.writers.events == hs.get_instance_name()
|
||||
)
|
||||
|
||||
self.room_invite_state_types = self.hs.config.room_invite_state_types
|
||||
|
||||
|
@ -836,7 +838,7 @@ class EventCreationHandler(object):
|
|||
success = False
|
||||
try:
|
||||
# If we're a worker we need to hit out to the master.
|
||||
if self.config.worker.writers.events != self._instance_name:
|
||||
if not self._is_event_writer:
|
||||
result = await self.send_event(
|
||||
instance_name=self.config.worker.writers.events,
|
||||
event_id=event.event_id,
|
||||
|
@ -906,7 +908,7 @@ class EventCreationHandler(object):
|
|||
|
||||
This should only be run on the instance in charge of persisting events.
|
||||
"""
|
||||
assert self.config.worker.writers.events == self._instance_name
|
||||
assert self._is_event_writer
|
||||
|
||||
if ratelimit:
|
||||
# We check if this is a room admin redacting an event so that we
|
||||
|
|
|
@ -48,6 +48,12 @@ class ResourceLimitsServerNotices(object):
|
|||
|
||||
self._notifier = hs.get_notifier()
|
||||
|
||||
self._enabled = (
|
||||
hs.config.limit_usage_by_mau
|
||||
and self._server_notices_manager.is_enabled()
|
||||
and not hs.config.hs_disabled
|
||||
)
|
||||
|
||||
async def maybe_send_server_notice_to_user(self, user_id):
|
||||
"""Check if we need to send a notice to this user, this will be true in
|
||||
two cases.
|
||||
|
@ -61,14 +67,7 @@ class ResourceLimitsServerNotices(object):
|
|||
Returns:
|
||||
Deferred
|
||||
"""
|
||||
if self._config.hs_disabled is True:
|
||||
return
|
||||
|
||||
if self._config.limit_usage_by_mau is False:
|
||||
return
|
||||
|
||||
if not self._server_notices_manager.is_enabled():
|
||||
# Don't try and send server notices unless they've been enabled
|
||||
if not self._enabled:
|
||||
return
|
||||
|
||||
timestamp = await self._store.user_last_seen_monthly_active(user_id)
|
||||
|
|
|
@ -122,6 +122,10 @@ class MonthlyActiveUsersStore(MonthlyActiveUsersWorkerStore):
|
|||
def __init__(self, database: Database, db_conn, hs):
|
||||
super(MonthlyActiveUsersStore, self).__init__(database, db_conn, hs)
|
||||
|
||||
self._limit_usage_by_mau = hs.config.limit_usage_by_mau
|
||||
self._mau_stats_only = hs.config.mau_stats_only
|
||||
self._max_mau_value = hs.config.max_mau_value
|
||||
|
||||
# Do not add more reserved users than the total allowable number
|
||||
# cur = LoggingTransaction(
|
||||
self.db.new_transaction(
|
||||
|
@ -130,7 +134,7 @@ class MonthlyActiveUsersStore(MonthlyActiveUsersWorkerStore):
|
|||
[],
|
||||
[],
|
||||
self._initialise_reserved_users,
|
||||
hs.config.mau_limits_reserved_threepids[: self.hs.config.max_mau_value],
|
||||
hs.config.mau_limits_reserved_threepids[: self._max_mau_value],
|
||||
)
|
||||
|
||||
def _initialise_reserved_users(self, txn, threepids):
|
||||
|
@ -142,6 +146,15 @@ class MonthlyActiveUsersStore(MonthlyActiveUsersWorkerStore):
|
|||
threepids (list[dict]): List of threepid dicts to reserve
|
||||
"""
|
||||
|
||||
# XXX what is this function trying to achieve? It upserts into
|
||||
# monthly_active_users for each *registered* reserved mau user, but why?
|
||||
#
|
||||
# - shouldn't there already be an entry for each reserved user (at least
|
||||
# if they have been active recently)?
|
||||
#
|
||||
# - if it's important that the timestamp is kept up to date, why do we only
|
||||
# run this at startup?
|
||||
|
||||
for tp in threepids:
|
||||
user_id = self.get_user_id_by_threepid_txn(txn, tp["medium"], tp["address"])
|
||||
|
||||
|
@ -191,8 +204,7 @@ class MonthlyActiveUsersStore(MonthlyActiveUsersWorkerStore):
|
|||
|
||||
txn.execute(sql, query_args)
|
||||
|
||||
max_mau_value = self.hs.config.max_mau_value
|
||||
if self.hs.config.limit_usage_by_mau:
|
||||
if self._limit_usage_by_mau:
|
||||
# If MAU user count still exceeds the MAU threshold, then delete on
|
||||
# a least recently active basis.
|
||||
# Note it is not possible to write this query using OFFSET due to
|
||||
|
@ -210,13 +222,13 @@ class MonthlyActiveUsersStore(MonthlyActiveUsersWorkerStore):
|
|||
LIMIT ?
|
||||
)
|
||||
"""
|
||||
txn.execute(sql, (max_mau_value,))
|
||||
txn.execute(sql, ((self._max_mau_value),))
|
||||
# Need if/else since 'AND user_id NOT IN ({})' fails on Postgres
|
||||
# when len(reserved_users) == 0. Works fine on sqlite.
|
||||
else:
|
||||
# Must be >= 0 for postgres
|
||||
num_of_non_reserved_users_to_remove = max(
|
||||
max_mau_value - len(reserved_users), 0
|
||||
self._max_mau_value - len(reserved_users), 0
|
||||
)
|
||||
|
||||
# It is important to filter reserved users twice to guard
|
||||
|
@ -335,7 +347,7 @@ class MonthlyActiveUsersStore(MonthlyActiveUsersWorkerStore):
|
|||
Args:
|
||||
user_id(str): the user_id to query
|
||||
"""
|
||||
if self.hs.config.limit_usage_by_mau or self.hs.config.mau_stats_only:
|
||||
if self._limit_usage_by_mau or self._mau_stats_only:
|
||||
# Trial users and guests should not be included as part of MAU group
|
||||
is_guest = yield self.is_guest(user_id)
|
||||
if is_guest:
|
||||
|
@ -356,11 +368,11 @@ class MonthlyActiveUsersStore(MonthlyActiveUsersWorkerStore):
|
|||
# In the case where mau_stats_only is True and limit_usage_by_mau is
|
||||
# False, there is no point in checking get_monthly_active_count - it
|
||||
# adds no value and will break the logic if max_mau_value is exceeded.
|
||||
if not self.hs.config.limit_usage_by_mau:
|
||||
if not self._limit_usage_by_mau:
|
||||
yield self.upsert_monthly_active_user(user_id)
|
||||
else:
|
||||
count = yield self.get_monthly_active_count()
|
||||
if count < self.hs.config.max_mau_value:
|
||||
if count < self._max_mau_value:
|
||||
yield self.upsert_monthly_active_user(user_id)
|
||||
elif now - last_seen_timestamp > LAST_SEEN_GRANULARITY:
|
||||
yield self.upsert_monthly_active_user(user_id)
|
||||
|
|
|
@ -27,20 +27,33 @@ from synapse.server_notices.resource_limits_server_notices import (
|
|||
)
|
||||
|
||||
from tests import unittest
|
||||
from tests.unittest import override_config
|
||||
from tests.utils import default_config
|
||||
|
||||
|
||||
class TestResourceLimitsServerNotices(unittest.HomeserverTestCase):
|
||||
def make_homeserver(self, reactor, clock):
|
||||
hs_config = self.default_config()
|
||||
hs_config["server_notices"] = {
|
||||
def default_config(self):
|
||||
config = default_config("test")
|
||||
|
||||
config.update(
|
||||
{
|
||||
"admin_contact": "mailto:user@test.com",
|
||||
"limit_usage_by_mau": True,
|
||||
"server_notices": {
|
||||
"system_mxid_localpart": "server",
|
||||
"system_mxid_display_name": "test display name",
|
||||
"system_mxid_avatar_url": None,
|
||||
"room_name": "Server Notices",
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
hs = self.setup_test_homeserver(config=hs_config)
|
||||
return hs
|
||||
# apply any additional config which was specified via the override_config
|
||||
# decorator.
|
||||
if self._extra_config is not None:
|
||||
config.update(self._extra_config)
|
||||
|
||||
return config
|
||||
|
||||
def prepare(self, reactor, clock, hs):
|
||||
self.server_notices_sender = self.hs.get_server_notices_sender()
|
||||
|
@ -60,7 +73,6 @@ class TestResourceLimitsServerNotices(unittest.HomeserverTestCase):
|
|||
)
|
||||
self._send_notice = self._rlsn._server_notices_manager.send_notice
|
||||
|
||||
self.hs.config.limit_usage_by_mau = True
|
||||
self.user_id = "@user_id:test"
|
||||
|
||||
self._rlsn._server_notices_manager.get_or_create_notice_room_for_user = Mock(
|
||||
|
@ -68,21 +80,17 @@ class TestResourceLimitsServerNotices(unittest.HomeserverTestCase):
|
|||
)
|
||||
self._rlsn._store.add_tag_to_room = Mock(return_value=defer.succeed(None))
|
||||
self._rlsn._store.get_tags_for_room = Mock(return_value=defer.succeed({}))
|
||||
self.hs.config.admin_contact = "mailto:user@test.com"
|
||||
|
||||
def test_maybe_send_server_notice_to_user_flag_off(self):
|
||||
"""Tests cases where the flags indicate nothing to do"""
|
||||
# test hs disabled case
|
||||
self.hs.config.hs_disabled = True
|
||||
|
||||
@override_config({"hs_disabled": True})
|
||||
def test_maybe_send_server_notice_disabled_hs(self):
|
||||
"""If the HS is disabled, we should not send notices"""
|
||||
self.get_success(self._rlsn.maybe_send_server_notice_to_user(self.user_id))
|
||||
|
||||
self._send_notice.assert_not_called()
|
||||
# Test when mau limiting disabled
|
||||
self.hs.config.hs_disabled = False
|
||||
self.hs.config.limit_usage_by_mau = False
|
||||
self.get_success(self._rlsn.maybe_send_server_notice_to_user(self.user_id))
|
||||
|
||||
@override_config({"limit_usage_by_mau": False})
|
||||
def test_maybe_send_server_notice_to_user_flag_off(self):
|
||||
"""If mau limiting is disabled, we should not send notices"""
|
||||
self.get_success(self._rlsn.maybe_send_server_notice_to_user(self.user_id))
|
||||
self._send_notice.assert_not_called()
|
||||
|
||||
def test_maybe_send_server_notice_to_user_remove_blocked_notice(self):
|
||||
|
@ -153,13 +161,12 @@ class TestResourceLimitsServerNotices(unittest.HomeserverTestCase):
|
|||
|
||||
self._send_notice.assert_not_called()
|
||||
|
||||
@override_config({"mau_limit_alerting": False})
|
||||
def test_maybe_send_server_notice_when_alerting_suppressed_room_unblocked(self):
|
||||
"""
|
||||
Test that when server is over MAU limit and alerting is suppressed, then
|
||||
an alert message is not sent into the room
|
||||
"""
|
||||
self.hs.config.mau_limit_alerting = False
|
||||
|
||||
self._rlsn._auth.check_auth_blocking = Mock(
|
||||
return_value=defer.succeed(None),
|
||||
side_effect=ResourceLimitError(
|
||||
|
@ -170,12 +177,11 @@ class TestResourceLimitsServerNotices(unittest.HomeserverTestCase):
|
|||
|
||||
self.assertEqual(self._send_notice.call_count, 0)
|
||||
|
||||
@override_config({"mau_limit_alerting": False})
|
||||
def test_check_hs_disabled_unaffected_by_mau_alert_suppression(self):
|
||||
"""
|
||||
Test that when a server is disabled, that MAU limit alerting is ignored.
|
||||
"""
|
||||
self.hs.config.mau_limit_alerting = False
|
||||
|
||||
self._rlsn._auth.check_auth_blocking = Mock(
|
||||
return_value=defer.succeed(None),
|
||||
side_effect=ResourceLimitError(
|
||||
|
@ -187,12 +193,12 @@ class TestResourceLimitsServerNotices(unittest.HomeserverTestCase):
|
|||
# Would be better to check contents, but 2 calls == set blocking event
|
||||
self.assertEqual(self._send_notice.call_count, 2)
|
||||
|
||||
@override_config({"mau_limit_alerting": False})
|
||||
def test_maybe_send_server_notice_when_alerting_suppressed_room_blocked(self):
|
||||
"""
|
||||
When the room is already in a blocked state, test that when alerting
|
||||
is suppressed that the room is returned to an unblocked state.
|
||||
"""
|
||||
self.hs.config.mau_limit_alerting = False
|
||||
self._rlsn._auth.check_auth_blocking = Mock(
|
||||
return_value=defer.succeed(None),
|
||||
side_effect=ResourceLimitError(
|
||||
|
|
|
@ -23,6 +23,7 @@ from synapse.http.site import XForwardedForRequest
|
|||
from synapse.rest.client.v1 import login
|
||||
|
||||
from tests import unittest
|
||||
from tests.unittest import override_config
|
||||
|
||||
|
||||
class ClientIpStoreTestCase(unittest.HomeserverTestCase):
|
||||
|
@ -137,9 +138,8 @@ class ClientIpStoreTestCase(unittest.HomeserverTestCase):
|
|||
],
|
||||
)
|
||||
|
||||
@override_config({"limit_usage_by_mau": False, "max_mau_value": 50})
|
||||
def test_disabled_monthly_active_user(self):
|
||||
self.hs.config.limit_usage_by_mau = False
|
||||
self.hs.config.max_mau_value = 50
|
||||
user_id = "@user:server"
|
||||
self.get_success(
|
||||
self.store.insert_client_ip(
|
||||
|
@ -149,9 +149,8 @@ class ClientIpStoreTestCase(unittest.HomeserverTestCase):
|
|||
active = self.get_success(self.store.user_last_seen_monthly_active(user_id))
|
||||
self.assertFalse(active)
|
||||
|
||||
@override_config({"limit_usage_by_mau": True, "max_mau_value": 50})
|
||||
def test_adding_monthly_active_user_when_full(self):
|
||||
self.hs.config.limit_usage_by_mau = True
|
||||
self.hs.config.max_mau_value = 50
|
||||
lots_of_users = 100
|
||||
user_id = "@user:server"
|
||||
|
||||
|
@ -166,9 +165,8 @@ class ClientIpStoreTestCase(unittest.HomeserverTestCase):
|
|||
active = self.get_success(self.store.user_last_seen_monthly_active(user_id))
|
||||
self.assertFalse(active)
|
||||
|
||||
@override_config({"limit_usage_by_mau": True, "max_mau_value": 50})
|
||||
def test_adding_monthly_active_user_when_space(self):
|
||||
self.hs.config.limit_usage_by_mau = True
|
||||
self.hs.config.max_mau_value = 50
|
||||
user_id = "@user:server"
|
||||
active = self.get_success(self.store.user_last_seen_monthly_active(user_id))
|
||||
self.assertFalse(active)
|
||||
|
@ -184,9 +182,8 @@ class ClientIpStoreTestCase(unittest.HomeserverTestCase):
|
|||
active = self.get_success(self.store.user_last_seen_monthly_active(user_id))
|
||||
self.assertTrue(active)
|
||||
|
||||
@override_config({"limit_usage_by_mau": True, "max_mau_value": 50})
|
||||
def test_updating_monthly_active_user_when_space(self):
|
||||
self.hs.config.limit_usage_by_mau = True
|
||||
self.hs.config.max_mau_value = 50
|
||||
user_id = "@user:server"
|
||||
self.get_success(self.store.register_user(user_id=user_id, password_hash=None))
|
||||
|
||||
|
|
|
@ -19,94 +19,106 @@ from twisted.internet import defer
|
|||
from synapse.api.constants import UserTypes
|
||||
|
||||
from tests import unittest
|
||||
from tests.unittest import default_config, override_config
|
||||
|
||||
FORTY_DAYS = 40 * 24 * 60 * 60
|
||||
|
||||
|
||||
def gen_3pids(count):
|
||||
"""Generate `count` threepids as a list."""
|
||||
return [
|
||||
{"medium": "email", "address": "user%i@matrix.org" % i} for i in range(count)
|
||||
]
|
||||
|
||||
|
||||
class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
|
||||
def make_homeserver(self, reactor, clock):
|
||||
def default_config(self):
|
||||
config = default_config("test")
|
||||
|
||||
hs = self.setup_test_homeserver()
|
||||
self.store = hs.get_datastore()
|
||||
hs.config.limit_usage_by_mau = True
|
||||
hs.config.max_mau_value = 50
|
||||
config.update({"limit_usage_by_mau": True, "max_mau_value": 50})
|
||||
|
||||
# apply any additional config which was specified via the override_config
|
||||
# decorator.
|
||||
if self._extra_config is not None:
|
||||
config.update(self._extra_config)
|
||||
|
||||
return config
|
||||
|
||||
def prepare(self, reactor, clock, homeserver):
|
||||
self.store = homeserver.get_datastore()
|
||||
# Advance the clock a bit
|
||||
reactor.advance(FORTY_DAYS)
|
||||
|
||||
return hs
|
||||
|
||||
@override_config({"max_mau_value": 3, "mau_limit_reserved_threepids": gen_3pids(3)})
|
||||
def test_initialise_reserved_users(self):
|
||||
self.hs.config.max_mau_value = 5
|
||||
threepids = self.hs.config.mau_limits_reserved_threepids
|
||||
|
||||
# register three users, of which two have reserved 3pids, and a third
|
||||
# which is a support user.
|
||||
user1 = "@user1:server"
|
||||
user1_email = "user1@matrix.org"
|
||||
user1_email = threepids[0]["address"]
|
||||
user2 = "@user2:server"
|
||||
user2_email = "user2@matrix.org"
|
||||
user2_email = threepids[1]["address"]
|
||||
user3 = "@user3:server"
|
||||
user3_email = "user3@matrix.org"
|
||||
|
||||
threepids = [
|
||||
{"medium": "email", "address": user1_email},
|
||||
{"medium": "email", "address": user2_email},
|
||||
{"medium": "email", "address": user3_email},
|
||||
]
|
||||
self.hs.config.mau_limits_reserved_threepids = threepids
|
||||
# -1 because user3 is a support user and does not count
|
||||
user_num = len(threepids) - 1
|
||||
|
||||
self.store.register_user(user_id=user1, password_hash=None)
|
||||
self.store.register_user(user_id=user2, password_hash=None)
|
||||
self.store.register_user(
|
||||
user_id=user3, password_hash=None, user_type=UserTypes.SUPPORT
|
||||
)
|
||||
self.store.register_user(user_id=user1)
|
||||
self.store.register_user(user_id=user2)
|
||||
self.store.register_user(user_id=user3, user_type=UserTypes.SUPPORT)
|
||||
self.pump()
|
||||
|
||||
now = int(self.hs.get_clock().time_msec())
|
||||
self.store.user_add_threepid(user1, "email", user1_email, now, now)
|
||||
self.store.user_add_threepid(user2, "email", user2_email, now, now)
|
||||
|
||||
# XXX why are we doing this here? this function is only run at startup
|
||||
# so it is odd to re-run it here.
|
||||
self.store.db.runInteraction(
|
||||
"initialise", self.store._initialise_reserved_users, threepids
|
||||
)
|
||||
self.pump()
|
||||
|
||||
active_count = self.store.get_monthly_active_count()
|
||||
# the number of users we expect will be counted against the mau limit
|
||||
# -1 because user3 is a support user and does not count
|
||||
user_num = len(threepids) - 1
|
||||
|
||||
# Test total counts, ensure user3 (support user) is not counted
|
||||
self.assertEquals(self.get_success(active_count), user_num)
|
||||
# Check the number of active users. Ensure user3 (support user) is not counted
|
||||
active_count = self.get_success(self.store.get_monthly_active_count())
|
||||
self.assertEquals(active_count, user_num)
|
||||
|
||||
# Test user is marked as active
|
||||
# Test each of the registered users is marked as active
|
||||
timestamp = self.store.user_last_seen_monthly_active(user1)
|
||||
self.assertTrue(self.get_success(timestamp))
|
||||
timestamp = self.store.user_last_seen_monthly_active(user2)
|
||||
self.assertTrue(self.get_success(timestamp))
|
||||
|
||||
# Test that users are never removed from the db.
|
||||
# Test that users with reserved 3pids are not removed from the MAU table
|
||||
# XXX some of this is redundant. poking things into the config shouldn't
|
||||
# work, and in any case it's not obvious what we expect to happen when
|
||||
# we advance the reactor.
|
||||
self.hs.config.max_mau_value = 0
|
||||
|
||||
self.reactor.advance(FORTY_DAYS)
|
||||
self.hs.config.max_mau_value = 5
|
||||
|
||||
self.store.reap_monthly_active_users()
|
||||
self.pump()
|
||||
|
||||
active_count = self.store.get_monthly_active_count()
|
||||
self.assertEquals(self.get_success(active_count), user_num)
|
||||
|
||||
# Test that regular users are removed from the db
|
||||
# Add some more users and check they are counted as active
|
||||
ru_count = 2
|
||||
self.store.upsert_monthly_active_user("@ru1:server")
|
||||
self.store.upsert_monthly_active_user("@ru2:server")
|
||||
self.pump()
|
||||
|
||||
active_count = self.store.get_monthly_active_count()
|
||||
self.assertEqual(self.get_success(active_count), user_num + ru_count)
|
||||
self.hs.config.max_mau_value = user_num
|
||||
|
||||
# now run the reaper and check that the number of active users is reduced
|
||||
# to max_mau_value
|
||||
self.store.reap_monthly_active_users()
|
||||
self.pump()
|
||||
|
||||
active_count = self.store.get_monthly_active_count()
|
||||
self.assertEquals(self.get_success(active_count), user_num)
|
||||
self.assertEquals(self.get_success(active_count), 3)
|
||||
|
||||
def test_can_insert_and_count_mau(self):
|
||||
count = self.store.get_monthly_active_count()
|
||||
|
@ -136,8 +148,8 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
|
|||
result = self.store.user_last_seen_monthly_active(user_id3)
|
||||
self.assertNotEqual(self.get_success(result), 0)
|
||||
|
||||
@override_config({"max_mau_value": 5})
|
||||
def test_reap_monthly_active_users(self):
|
||||
self.hs.config.max_mau_value = 5
|
||||
initial_users = 10
|
||||
for i in range(initial_users):
|
||||
self.store.upsert_monthly_active_user("@user%d:server" % i)
|
||||
|
@ -158,19 +170,19 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
|
|||
count = self.store.get_monthly_active_count()
|
||||
self.assertEquals(self.get_success(count), 0)
|
||||
|
||||
# Note that below says mau_limit (no s), this is the name of the config
|
||||
# value, although it gets stored on the config object as mau_limits.
|
||||
@override_config({"max_mau_value": 5, "mau_limit_reserved_threepids": gen_3pids(5)})
|
||||
def test_reap_monthly_active_users_reserved_users(self):
|
||||
""" Tests that reaping correctly handles reaping where reserved users are
|
||||
present"""
|
||||
|
||||
self.hs.config.max_mau_value = 5
|
||||
initial_users = 5
|
||||
threepids = self.hs.config.mau_limits_reserved_threepids
|
||||
initial_users = len(threepids)
|
||||
reserved_user_number = initial_users - 1
|
||||
threepids = []
|
||||
for i in range(initial_users):
|
||||
user = "@user%d:server" % i
|
||||
email = "user%d@example.com" % i
|
||||
email = "user%d@matrix.org" % i
|
||||
self.get_success(self.store.upsert_monthly_active_user(user))
|
||||
threepids.append({"medium": "email", "address": email})
|
||||
# Need to ensure that the most recent entries in the
|
||||
# monthly_active_users table are reserved
|
||||
now = int(self.hs.get_clock().time_msec())
|
||||
|
@ -182,7 +194,6 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
|
|||
self.store.user_add_threepid(user, "email", email, now, now)
|
||||
)
|
||||
|
||||
self.hs.config.mau_limits_reserved_threepids = threepids
|
||||
self.store.db.runInteraction(
|
||||
"initialise", self.store._initialise_reserved_users, threepids
|
||||
)
|
||||
|
@ -279,11 +290,11 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
|
|||
self.pump()
|
||||
self.assertEqual(self.get_success(count), 0)
|
||||
|
||||
# Note that the max_mau_value setting should not matter.
|
||||
@override_config(
|
||||
{"limit_usage_by_mau": False, "mau_stats_only": True, "max_mau_value": 1}
|
||||
)
|
||||
def test_track_monthly_users_without_cap(self):
|
||||
self.hs.config.limit_usage_by_mau = False
|
||||
self.hs.config.mau_stats_only = True
|
||||
self.hs.config.max_mau_value = 1 # should not matter
|
||||
|
||||
count = self.store.get_monthly_active_count()
|
||||
self.assertEqual(0, self.get_success(count))
|
||||
|
||||
|
@ -294,9 +305,8 @@ class MonthlyActiveUsersTestCase(unittest.HomeserverTestCase):
|
|||
count = self.store.get_monthly_active_count()
|
||||
self.assertEqual(2, self.get_success(count))
|
||||
|
||||
@override_config({"limit_usage_by_mau": False, "mau_stats_only": False})
|
||||
def test_no_users_when_not_tracking(self):
|
||||
self.hs.config.limit_usage_by_mau = False
|
||||
self.hs.config.mau_stats_only = False
|
||||
self.store.upsert_monthly_active_user = Mock()
|
||||
|
||||
self.store.populate_monthly_active_users("@user:sever")
|
||||
|
|
|
@ -17,47 +17,44 @@
|
|||
|
||||
import json
|
||||
|
||||
from mock import Mock
|
||||
|
||||
from synapse.api.auth_blocking import AuthBlocking
|
||||
from synapse.api.constants import LoginType
|
||||
from synapse.api.errors import Codes, HttpResponseException, SynapseError
|
||||
from synapse.rest.client.v2_alpha import register, sync
|
||||
|
||||
from tests import unittest
|
||||
from tests.unittest import override_config
|
||||
from tests.utils import default_config
|
||||
|
||||
|
||||
class TestMauLimit(unittest.HomeserverTestCase):
|
||||
|
||||
servlets = [register.register_servlets, sync.register_servlets]
|
||||
|
||||
def make_homeserver(self, reactor, clock):
|
||||
def default_config(self):
|
||||
config = default_config("test")
|
||||
|
||||
self.hs = self.setup_test_homeserver(
|
||||
"red", http_client=None, federation_client=Mock()
|
||||
config.update(
|
||||
{
|
||||
"registrations_require_3pid": [],
|
||||
"limit_usage_by_mau": True,
|
||||
"max_mau_value": 2,
|
||||
"mau_trial_days": 0,
|
||||
"server_notices": {
|
||||
"system_mxid_localpart": "server",
|
||||
"room_name": "Test Server Notice Room",
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
self.store = self.hs.get_datastore()
|
||||
# apply any additional config which was specified via the override_config
|
||||
# decorator.
|
||||
if self._extra_config is not None:
|
||||
config.update(self._extra_config)
|
||||
|
||||
self.hs.config.registrations_require_3pid = []
|
||||
self.hs.config.enable_registration_captcha = False
|
||||
self.hs.config.recaptcha_public_key = []
|
||||
return config
|
||||
|
||||
self.hs.config.limit_usage_by_mau = True
|
||||
self.hs.config.hs_disabled = False
|
||||
self.hs.config.max_mau_value = 2
|
||||
self.hs.config.server_notices_mxid = "@server:red"
|
||||
self.hs.config.server_notices_mxid_display_name = None
|
||||
self.hs.config.server_notices_mxid_avatar_url = None
|
||||
self.hs.config.server_notices_room_name = "Test Server Notice Room"
|
||||
self.hs.config.mau_trial_days = 0
|
||||
|
||||
# AuthBlocking reads config options during hs creation. Recreate the
|
||||
# hs' copy of AuthBlocking after we've updated config values above
|
||||
self.auth_blocking = AuthBlocking(self.hs)
|
||||
self.hs.get_auth()._auth_blocking = self.auth_blocking
|
||||
|
||||
return self.hs
|
||||
def prepare(self, reactor, clock, homeserver):
|
||||
self.store = homeserver.get_datastore()
|
||||
|
||||
def test_simple_deny_mau(self):
|
||||
# Create and sync so that the MAU counts get updated
|
||||
|
@ -66,6 +63,9 @@ class TestMauLimit(unittest.HomeserverTestCase):
|
|||
token2 = self.create_user("kermit2")
|
||||
self.do_sync_for_user(token2)
|
||||
|
||||
# check we're testing what we think we are: there should be two active users
|
||||
self.assertEqual(self.get_success(self.store.get_monthly_active_count()), 2)
|
||||
|
||||
# We've created and activated two users, we shouldn't be able to
|
||||
# register new users
|
||||
with self.assertRaises(SynapseError) as cm:
|
||||
|
@ -93,9 +93,8 @@ class TestMauLimit(unittest.HomeserverTestCase):
|
|||
token3 = self.create_user("kermit3")
|
||||
self.do_sync_for_user(token3)
|
||||
|
||||
@override_config({"mau_trial_days": 1})
|
||||
def test_trial_delay(self):
|
||||
self.hs.config.mau_trial_days = 1
|
||||
|
||||
# We should be able to register more than the limit initially
|
||||
token1 = self.create_user("kermit1")
|
||||
self.do_sync_for_user(token1)
|
||||
|
@ -127,8 +126,8 @@ class TestMauLimit(unittest.HomeserverTestCase):
|
|||
self.assertEqual(e.code, 403)
|
||||
self.assertEqual(e.errcode, Codes.RESOURCE_LIMIT_EXCEEDED)
|
||||
|
||||
@override_config({"mau_trial_days": 1})
|
||||
def test_trial_users_cant_come_back(self):
|
||||
self.auth_blocking._mau_trial_days = 1
|
||||
self.hs.config.mau_trial_days = 1
|
||||
|
||||
# We should be able to register more than the limit initially
|
||||
|
@ -176,11 +175,11 @@ class TestMauLimit(unittest.HomeserverTestCase):
|
|||
self.assertEqual(e.code, 403)
|
||||
self.assertEqual(e.errcode, Codes.RESOURCE_LIMIT_EXCEEDED)
|
||||
|
||||
@override_config(
|
||||
# max_mau_value should not matter
|
||||
{"max_mau_value": 1, "limit_usage_by_mau": False, "mau_stats_only": True}
|
||||
)
|
||||
def test_tracked_but_not_limited(self):
|
||||
self.auth_blocking._max_mau_value = 1 # should not matter
|
||||
self.auth_blocking._limit_usage_by_mau = False
|
||||
self.hs.config.mau_stats_only = True
|
||||
|
||||
# Simply being able to create 2 users indicates that the
|
||||
# limit was not reached.
|
||||
token1 = self.create_user("kermit1")
|
||||
|
|
Loading…
Reference in New Issue