MatrixSynapse/synapse/server.py

520 lines
17 KiB
Python
Raw Normal View History

2014-08-12 16:10:52 +02:00
# -*- coding: utf-8 -*-
2016-01-07 05:26:29 +01:00
# Copyright 2014-2016 OpenMarket Ltd
2014-08-12 16:10:52 +02: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.
2014-08-12 16:10:52 +02:00
# This file provides some classes for setting up (partially-populated)
# homeservers; either as a full homeserver as a real application, or a small
# partial one for unit test mocking.
# Imports required for the default HomeServer() implementation
import abc
2016-08-01 19:02:07 +02:00
import logging
2016-01-26 14:52:29 +01:00
from twisted.enterprise import adbapi
2016-08-01 19:02:07 +02:00
from twisted.web.client import BrowserLikePolicyForHTTPS
2016-01-26 14:52:29 +01:00
2016-08-01 19:02:07 +02:00
from synapse.api.auth import Auth
from synapse.api.filtering import Filtering
from synapse.api.ratelimiting import Ratelimiter
from synapse.appservice.api import ApplicationServiceApi
2016-08-01 19:02:07 +02:00
from synapse.appservice.scheduler import ApplicationServiceScheduler
from synapse.crypto.keyring import Keyring
from synapse.events.builder import EventBuilderFactory
2017-09-26 20:20:23 +02:00
from synapse.events.spamcheck import SpamChecker
2018-03-12 15:34:31 +01:00
from synapse.federation.federation_client import FederationClient
2018-07-09 08:09:20 +02:00
from synapse.federation.federation_server import (
FederationHandlerRegistry,
FederationServer,
ReplicationFederationHandlerRegistry,
2018-07-09 08:09:20 +02:00
)
from synapse.federation.send_queue import FederationRemoteSendQueue
from synapse.federation.transaction_queue import TransactionQueue
2018-07-09 08:09:20 +02:00
from synapse.federation.transport.client import TransportLayerClient
from synapse.groups.attestations import GroupAttestationSigning, GroupAttestionRenewer
from synapse.groups.groups_server import GroupsServerHandler
2014-08-12 16:10:52 +02:00
from synapse.handlers import Handlers
2016-08-01 19:02:07 +02:00
from synapse.handlers.appservice import ApplicationServicesHandler
from synapse.handlers.auth import AuthHandler, MacaroonGenerator
from synapse.handlers.deactivate_account import DeactivateAccountHandler
2016-08-01 19:02:07 +02:00
from synapse.handlers.device import DeviceHandler
2018-07-09 08:09:20 +02:00
from synapse.handlers.devicemessage import DeviceMessageHandler
2016-08-01 19:02:07 +02:00
from synapse.handlers.e2e_keys import E2eKeysHandler
2017-12-05 22:44:25 +01:00
from synapse.handlers.e2e_room_keys import E2eRoomKeysHandler
2018-07-09 08:09:20 +02:00
from synapse.handlers.events import EventHandler, EventStreamHandler
from synapse.handlers.groups_local import GroupsLocalHandler
from synapse.handlers.initial_sync import InitialSyncHandler
2018-07-20 16:32:23 +02:00
from synapse.handlers.message import EventCreationHandler, MessageHandler
from synapse.handlers.pagination import PaginationHandler
from synapse.handlers.presence import PresenceHandler
from synapse.handlers.profile import BaseProfileHandler, MasterProfileHandler
2018-07-09 08:09:20 +02:00
from synapse.handlers.read_marker import ReadMarkerHandler
from synapse.handlers.receipts import ReceiptsHandler
from synapse.handlers.room import RoomContextHandler, RoomCreationHandler
from synapse.handlers.room_list import RoomListHandler
from synapse.handlers.room_member import RoomMemberMasterHandler
from synapse.handlers.room_member_worker import RoomMemberWorkerHandler
from synapse.handlers.set_password import SetPasswordHandler
from synapse.handlers.sync import SyncHandler
from synapse.handlers.typing import TypingHandler
from synapse.handlers.user_directory import UserDirectoryHandler
2018-07-09 08:09:20 +02:00
from synapse.http.client import InsecureInterceptableContextFactory, SimpleHttpClient
2016-08-01 19:02:07 +02:00
from synapse.http.matrixfederationclient import MatrixFederationHttpClient
from synapse.notifier import Notifier
2017-05-18 19:17:40 +02:00
from synapse.push.action_generator import ActionGenerator
2016-08-01 19:02:07 +02:00
from synapse.push.pusherpool import PusherPool
from synapse.rest.media.v1.media_repository import (
MediaRepository,
MediaRepositoryResource,
)
from synapse.secrets import Secrets
from synapse.server_notices.server_notices_manager import ServerNoticesManager
from synapse.server_notices.server_notices_sender import ServerNoticesSender
2018-07-09 08:09:20 +02:00
from synapse.server_notices.worker_server_notices_sender import WorkerServerNoticesSender
from synapse.state import StateHandler, StateResolutionHandler
2016-08-01 19:02:07 +02:00
from synapse.streams.events import EventSources
2014-08-12 16:10:52 +02:00
from synapse.util import Clock
from synapse.util.distributor import Distributor
logger = logging.getLogger(__name__)
2014-08-12 16:10:52 +02:00
2016-01-26 14:52:29 +01:00
class HomeServer(object):
2014-08-12 16:10:52 +02:00
"""A basic homeserver object without lazy component builders.
This will need all of the components it requires to either be passed as
constructor arguments, or the relevant methods overriding to create them.
Typically this would only be used for unit tests.
For every dependency in the DEPENDENCIES list below, this class creates one
method,
def get_DEPENDENCY(self)
which returns the value of that dependency. If no value has yet been set
nor was provided to the constructor, it will attempt to call a lazy builder
method called
def build_DEPENDENCY(self)
which must be implemented by the subclass. This code may call any of the
required "get" methods on the instance to obtain the sub-dependencies that
one requires.
Attributes:
config (synapse.config.homeserver.HomeserverConfig):
2014-08-12 16:10:52 +02:00
"""
__metaclass__ = abc.ABCMeta
2014-08-12 16:10:52 +02:00
DEPENDENCIES = [
'http_client',
'db_pool',
'federation_client',
2018-03-13 14:22:21 +01:00
'federation_server',
2014-08-12 16:10:52 +02:00
'handlers',
'auth',
'room_creation_handler',
2014-08-12 16:10:52 +02:00
'state_handler',
'state_resolution_handler',
'presence_handler',
'sync_handler',
'typing_handler',
'room_list_handler',
2016-06-02 14:31:45 +02:00
'auth_handler',
'device_handler',
2016-08-01 19:02:07 +02:00
'e2e_keys_handler',
2017-12-05 22:44:25 +01:00
'e2e_room_keys_handler',
2016-08-12 16:31:44 +02:00
'event_handler',
'event_stream_handler',
'initial_sync_handler',
'application_service_api',
'application_service_scheduler',
'application_service_handler',
2016-09-06 19:16:20 +02:00
'device_message_handler',
2017-08-25 15:34:56 +02:00
'profile_handler',
2018-01-15 17:52:07 +01:00
'event_creation_handler',
'deactivate_account_handler',
'set_password_handler',
2014-08-12 16:10:52 +02:00
'notifier',
'event_sources',
'keyring',
'pusherpool',
'event_builder_factory',
'filtering',
'http_client_context_factory',
'simple_http_client',
2016-06-29 15:57:59 +02:00
'media_repository',
'media_repository_resource',
'federation_transport_client',
'federation_sender',
'receipts_handler',
'macaroon_generator',
'tcp_replication',
'read_marker_handler',
2017-05-18 19:17:40 +02:00
'action_generator',
2017-05-31 12:51:01 +02:00
'user_directory_handler',
2017-07-10 15:52:27 +02:00
'groups_local_handler',
2017-07-10 16:44:15 +02:00
'groups_server_handler',
'groups_attestation_signing',
'groups_attestation_renewer',
'secrets',
2017-09-26 20:20:23 +02:00
'spam_checker',
2018-03-01 11:54:37 +01:00
'room_member_handler',
'federation_registry',
'server_notices_manager',
'server_notices_sender',
'message_handler',
'pagination_handler',
'room_context_handler',
2014-08-12 16:10:52 +02:00
]
# This is overridden in derived application classes
# (such as synapse.app.homeserver.SynapseHomeServer) and gives the class to be
# instantiated during setup() for future return by get_datastore()
DATASTORE_CLASS = abc.abstractproperty()
def __init__(self, hostname, reactor=None, **kwargs):
2014-08-12 16:10:52 +02:00
"""
Args:
hostname : The hostname for the server.
"""
if not reactor:
from twisted.internet import reactor
self._reactor = reactor
2014-08-12 16:10:52 +02:00
self.hostname = hostname
self._building = {}
self.clock = Clock(reactor)
self.distributor = Distributor()
self.ratelimiter = Ratelimiter()
self.datastore = None
2014-08-12 16:10:52 +02:00
# Other kwargs are explicit dependencies
for depname in kwargs:
setattr(self, depname, kwargs[depname])
def setup(self):
logger.info("Setting up.")
with self.get_db_conn() as conn:
self.datastore = self.DATASTORE_CLASS(conn, self)
2018-10-24 18:17:30 +02:00
conn.commit()
logger.info("Finished setting up.")
def get_reactor(self):
"""
Fetch the Twisted reactor in use by this HomeServer.
"""
return self._reactor
def get_ip_from_request(self, request):
# X-Forwarded-For is handled by our custom request type.
return request.getClientIP()
def is_mine(self, domain_specific_string):
return domain_specific_string.domain == self.hostname
def is_mine_id(self, string):
2016-01-19 17:11:39 +01:00
return string.split(":", 1)[1] == self.hostname
def get_clock(self):
return self.clock
def get_datastore(self):
return self.datastore
def get_config(self):
return self.config
def get_distributor(self):
return self.distributor
def get_ratelimiter(self):
return self.ratelimiter
def build_federation_client(self):
2018-03-12 15:34:31 +01:00
return FederationClient(self)
2018-03-13 14:22:21 +01:00
def build_federation_server(self):
2018-03-12 15:34:31 +01:00
return FederationServer(self)
2014-08-12 16:10:52 +02:00
def build_handlers(self):
return Handlers(self)
def build_notifier(self):
return Notifier(self)
def build_auth(self):
return Auth(self)
def build_http_client_context_factory(self):
return (
2015-09-15 16:50:13 +02:00
InsecureInterceptableContextFactory()
if self.config.use_insecure_ssl_client_just_for_testing_do_not_use
else BrowserLikePolicyForHTTPS()
)
def build_simple_http_client(self):
return SimpleHttpClient(self)
def build_room_creation_handler(self):
return RoomCreationHandler(self)
2014-08-12 16:10:52 +02:00
def build_state_handler(self):
return StateHandler(self)
def build_state_resolution_handler(self):
return StateResolutionHandler(self)
def build_presence_handler(self):
return PresenceHandler(self)
def build_typing_handler(self):
return TypingHandler(self)
def build_sync_handler(self):
return SyncHandler(self)
def build_room_list_handler(self):
return RoomListHandler(self)
2016-06-02 14:31:45 +02:00
def build_auth_handler(self):
return AuthHandler(self)
def build_macaroon_generator(self):
return MacaroonGenerator(self)
def build_device_handler(self):
return DeviceHandler(self)
2016-09-06 19:16:20 +02:00
def build_device_message_handler(self):
return DeviceMessageHandler(self)
2016-08-01 19:02:07 +02:00
def build_e2e_keys_handler(self):
return E2eKeysHandler(self)
2017-12-05 22:44:25 +01:00
def build_e2e_room_keys_handler(self):
return E2eRoomKeysHandler(self)
2016-08-01 19:02:07 +02:00
def build_application_service_api(self):
return ApplicationServiceApi(self)
def build_application_service_scheduler(self):
return ApplicationServiceScheduler(self)
def build_application_service_handler(self):
return ApplicationServicesHandler(self)
2016-08-12 16:31:44 +02:00
def build_event_handler(self):
return EventHandler(self)
def build_event_stream_handler(self):
return EventStreamHandler(self)
def build_initial_sync_handler(self):
return InitialSyncHandler(self)
2017-08-25 15:34:56 +02:00
def build_profile_handler(self):
if self.config.worker_app:
return BaseProfileHandler(self)
else:
return MasterProfileHandler(self)
2017-08-25 15:34:56 +02:00
2018-01-15 17:52:07 +01:00
def build_event_creation_handler(self):
return EventCreationHandler(self)
def build_deactivate_account_handler(self):
return DeactivateAccountHandler(self)
def build_set_password_handler(self):
return SetPasswordHandler(self)
def build_event_sources(self):
return EventSources(self)
def build_keyring(self):
return Keyring(self)
def build_event_builder_factory(self):
return EventBuilderFactory(
clock=self.get_clock(),
hostname=self.hostname,
)
def build_filtering(self):
return Filtering(self)
2015-01-29 15:55:27 +01:00
def build_pusherpool(self):
return PusherPool(self)
2016-01-26 14:52:29 +01:00
def build_http_client(self):
return MatrixFederationHttpClient(self)
def build_db_pool(self):
name = self.db_config["name"]
return adbapi.ConnectionPool(
name,
cp_reactor=self.get_reactor(),
2016-01-26 14:52:29 +01:00
**self.db_config.get("args", {})
)
def get_db_conn(self, run_new_connection=True):
"""Makes a new connection to the database, skipping the db pool
Returns:
Connection: a connection object implementing the PEP-249 spec
"""
# Any param beginning with cp_ is a parameter for adbapi, and should
# not be passed to the database engine.
db_params = {
k: v for k, v in self.db_config.get("args", {}).items()
if not k.startswith("cp_")
}
db_conn = self.database_engine.module.connect(**db_params)
if run_new_connection:
self.database_engine.on_new_connection(db_conn)
return db_conn
def build_media_repository_resource(self):
# build the media repo resource. This indirects through the HomeServer
# to ensure that we only have a single instance of
return MediaRepositoryResource(self)
2016-06-29 15:57:59 +02:00
def build_media_repository(self):
return MediaRepository(self)
def build_federation_transport_client(self):
return TransportLayerClient(self)
def build_federation_sender(self):
if self.should_send_federation():
return TransactionQueue(self)
elif not self.config.worker_app:
return FederationRemoteSendQueue(self)
else:
raise Exception("Workers cannot send federation traffic")
def build_receipts_handler(self):
return ReceiptsHandler(self)
def build_read_marker_handler(self):
return ReadMarkerHandler(self)
def build_tcp_replication(self):
raise NotImplementedError()
2017-05-18 19:17:40 +02:00
def build_action_generator(self):
return ActionGenerator(self)
2017-05-31 12:51:01 +02:00
def build_user_directory_handler(self):
return UserDirectoryHandler(self)
2017-05-31 12:51:01 +02:00
2017-07-10 15:52:27 +02:00
def build_groups_local_handler(self):
return GroupsLocalHandler(self)
2017-07-10 16:44:15 +02:00
def build_groups_server_handler(self):
return GroupsServerHandler(self)
def build_groups_attestation_signing(self):
return GroupAttestationSigning(self)
def build_groups_attestation_renewer(self):
return GroupAttestionRenewer(self)
def build_secrets(self):
return Secrets()
2017-09-26 20:20:23 +02:00
def build_spam_checker(self):
return SpamChecker(self)
2018-03-01 11:54:37 +01:00
def build_room_member_handler(self):
if self.config.worker_app:
2018-03-13 17:32:37 +01:00
return RoomMemberWorkerHandler(self)
return RoomMemberMasterHandler(self)
2018-03-01 11:54:37 +01:00
def build_federation_registry(self):
if self.config.worker_app:
return ReplicationFederationHandlerRegistry(self)
else:
return FederationHandlerRegistry()
def build_server_notices_manager(self):
if self.config.worker_app:
raise Exception("Workers cannot send server notices")
return ServerNoticesManager(self)
def build_server_notices_sender(self):
if self.config.worker_app:
return WorkerServerNoticesSender(self)
return ServerNoticesSender(self)
def build_message_handler(self):
return MessageHandler(self)
def build_pagination_handler(self):
return PaginationHandler(self)
def build_room_context_handler(self):
return RoomContextHandler(self)
def remove_pusher(self, app_id, push_key, user_id):
return self.get_pusherpool().remove_pusher(app_id, push_key, user_id)
def should_send_federation(self):
"Should this server be sending federation traffic directly?"
return self.config.send_federation and (
not self.config.worker_app
or self.config.worker_app == "synapse.app.federation_sender"
)
2016-01-26 14:52:29 +01:00
def _make_dependency_method(depname):
def _get(hs):
try:
return getattr(hs, depname)
except AttributeError:
pass
try:
builder = getattr(hs, "build_%s" % (depname))
except AttributeError:
builder = None
if builder:
# Prevent cyclic dependencies from deadlocking
if depname in hs._building:
raise ValueError("Cyclic dependency while building %s" % (
depname,
))
hs._building[depname] = 1
dep = builder()
setattr(hs, depname, dep)
del hs._building[depname]
return dep
raise NotImplementedError(
"%s has no %s nor a builder for it" % (
type(hs).__name__, depname,
)
)
setattr(HomeServer, "get_%s" % (depname), _get)
# Build magic accessors for every dependency
for depname in HomeServer.DEPENDENCIES:
_make_dependency_method(depname)