def make_homeserver(self, reactor, clock): hs_config = self.default_config() # some of the tests rely on us having a user consent version hs_config.setdefault("user_consent", {}).update( { "version": "test_consent_version", "template_dir": ".", } ) hs_config["max_mau_value"] = 50 hs_config["limit_usage_by_mau"] = True # Don't attempt to reach out over federation. self.mock_federation_client = Mock() self.mock_federation_client.make_query.side_effect = CodeMessageException( 500, "" ) hs = self.setup_test_homeserver( config=hs_config, federation_client=self.mock_federation_client ) load_legacy_spam_checkers(hs) module_api = hs.get_module_api() for module, config in hs.config.modules.loaded_modules: module(config=config, api=module_api) return hs
def prepare(self, reactor, clock, hs): self.user = self.register_user("user", "pass") self.tok = self.login("user", "pass") # Allow for uploading and downloading to/from the media repo self.media_repo = hs.get_media_repository_resource() self.download_resource = self.media_repo.children[b"download"] self.upload_resource = self.media_repo.children[b"upload"] load_legacy_spam_checkers(hs)
def make_homeserver(self, reactor, clock): hs_config = self.default_config() # some of the tests rely on us having a user consent version hs_config["user_consent"] = { "version": "test_consent_version", "template_dir": ".", } hs_config["max_mau_value"] = 50 hs_config["limit_usage_by_mau"] = True hs = self.setup_test_homeserver(config=hs_config) load_legacy_spam_checkers(hs) module_api = hs.get_module_api() for module, config in hs.config.modules.loaded_modules: module(config=config, api=module_api) return hs
async def start(hs: "HomeServer") -> None: """ Start a Synapse server or worker. Should be called once the reactor is running. Will start the main HTTP listeners and do some other startup tasks, and then notify systemd. Args: hs: homeserver instance """ reactor = hs.get_reactor() # We want to use a separate thread pool for the resolver so that large # numbers of DNS requests don't starve out other users of the threadpool. resolver_threadpool = ThreadPool(name="gai_resolver") resolver_threadpool.start() reactor.addSystemEventTrigger("during", "shutdown", resolver_threadpool.stop) reactor.installNameResolver( GAIResolver(reactor, getThreadPool=lambda: resolver_threadpool)) # Register the threadpools with our metrics. register_threadpool("default", reactor.getThreadPool()) register_threadpool("gai_resolver", resolver_threadpool) # Set up the SIGHUP machinery. if hasattr(signal, "SIGHUP"): @wrap_as_background_process("sighup") async def handle_sighup(*args: Any, **kwargs: Any) -> None: # Tell systemd our state, if we're using it. This will silently fail if # we're not using systemd. sdnotify(b"RELOADING=1") for i, args, kwargs in _sighup_callbacks: i(*args, **kwargs) sdnotify(b"READY=1") # We defer running the sighup handlers until next reactor tick. This # is so that we're in a sane state, e.g. flushing the logs may fail # if the sighup happens in the middle of writing a log entry. def run_sighup(*args: Any, **kwargs: Any) -> None: # `callFromThread` should be "signal safe" as well as thread # safe. reactor.callFromThread(handle_sighup, *args, **kwargs) signal.signal(signal.SIGHUP, run_sighup) register_sighup(refresh_certificate, hs) register_sighup(reload_cache_config, hs.config) # Apply the cache config. hs.config.caches.resize_all_caches() # Load the certificate from disk. refresh_certificate(hs) # Start the tracer init_tracer(hs) # noqa # Instantiate the modules so they can register their web resources to the module API # before we start the listeners. module_api = hs.get_module_api() for module, config in hs.config.modules.loaded_modules: m = module(config=config, api=module_api) logger.info("Loaded module %s", m) load_legacy_spam_checkers(hs) load_legacy_third_party_event_rules(hs) load_legacy_presence_router(hs) load_legacy_password_auth_providers(hs) # If we've configured an expiry time for caches, start the background job now. setup_expire_lru_cache_entries(hs) # It is now safe to start your Synapse. hs.start_listening() hs.get_datastores().main.db_pool.start_profiling() hs.get_pusherpool().start() # Log when we start the shut down process. hs.get_reactor().addSystemEventTrigger("before", "shutdown", logger.info, "Shutting down...") setup_sentry(hs) setup_sdnotify(hs) # If background tasks are running on the main process, start collecting the # phone home stats. if hs.config.worker.run_background_tasks: start_phone_stats_home(hs) # We now freeze all allocated objects in the hopes that (almost) # everything currently allocated are things that will be used for the # rest of time. Doing so means less work each GC (hopefully). # # PyPy does not (yet?) implement gc.freeze() if hasattr(gc, "freeze"): gc.collect() gc.freeze() # Speed up shutdowns by freezing all allocated objects. This moves everything # into the permanent generation and excludes them from the final GC. atexit.register(gc.freeze)
async def start(hs: "HomeServer"): """ Start a Synapse server or worker. Should be called once the reactor is running. Will start the main HTTP listeners and do some other startup tasks, and then notify systemd. Args: hs: homeserver instance """ # Set up the SIGHUP machinery. if hasattr(signal, "SIGHUP"): reactor = hs.get_reactor() @wrap_as_background_process("sighup") def handle_sighup(*args, **kwargs): # Tell systemd our state, if we're using it. This will silently fail if # we're not using systemd. sdnotify(b"RELOADING=1") for i, args, kwargs in _sighup_callbacks: i(*args, **kwargs) sdnotify(b"READY=1") # We defer running the sighup handlers until next reactor tick. This # is so that we're in a sane state, e.g. flushing the logs may fail # if the sighup happens in the middle of writing a log entry. def run_sighup(*args, **kwargs): # `callFromThread` should be "signal safe" as well as thread # safe. reactor.callFromThread(handle_sighup, *args, **kwargs) signal.signal(signal.SIGHUP, run_sighup) register_sighup(refresh_certificate, hs) # Load the certificate from disk. refresh_certificate(hs) # Start the tracer synapse.logging.opentracing.init_tracer(hs) # type: ignore[attr-defined] # noqa # Instantiate the modules so they can register their web resources to the module API # before we start the listeners. module_api = hs.get_module_api() for module, config in hs.config.modules.loaded_modules: module(config=config, api=module_api) load_legacy_spam_checkers(hs) load_legacy_third_party_event_rules(hs) load_legacy_presence_router(hs) # If we've configured an expiry time for caches, start the background job now. setup_expire_lru_cache_entries(hs) # It is now safe to start your Synapse. hs.start_listening() hs.get_datastore().db_pool.start_profiling() hs.get_pusherpool().start() # Log when we start the shut down process. hs.get_reactor().addSystemEventTrigger( "before", "shutdown", logger.info, "Shutting down..." ) setup_sentry(hs) setup_sdnotify(hs) # If background tasks are running on the main process, start collecting the # phone home stats. if hs.config.run_background_tasks: start_phone_stats_home(hs) # We now freeze all allocated objects in the hopes that (almost) # everything currently allocated are things that will be used for the # rest of time. Doing so means less work each GC (hopefully). # # This only works on Python 3.7 if platform.python_implementation() == "CPython" and sys.version_info >= (3, 7): gc.collect() gc.freeze()