mirror of
https://git.anonymousland.org/anonymousland/synapse.git
synced 2024-12-24 21:09:24 -05:00
25adde9a04
This function is identical to all subclasses, so we may as well push it up to the base class to reduce duplication (and make use of it in the tests)
229 lines
8.0 KiB
Python
229 lines
8.0 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
# Copyright 2016 OpenMarket Ltd
|
|
#
|
|
# 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.
|
|
import logging
|
|
import sys
|
|
|
|
import synapse
|
|
from synapse import events
|
|
from synapse.api.errors import SynapseError
|
|
from synapse.app import _base
|
|
from synapse.config._base import ConfigError
|
|
from synapse.config.homeserver import HomeServerConfig
|
|
from synapse.config.logger import setup_logging
|
|
from synapse.crypto import context_factory
|
|
from synapse.http.server import JsonResource
|
|
from synapse.http.servlet import (
|
|
RestServlet, parse_json_object_from_request,
|
|
)
|
|
from synapse.http.site import SynapseSite
|
|
from synapse.metrics.resource import METRICS_PREFIX, MetricsResource
|
|
from synapse.replication.slave.storage._base import BaseSlavedStore
|
|
from synapse.replication.slave.storage.appservice import SlavedApplicationServiceStore
|
|
from synapse.replication.slave.storage.client_ips import SlavedClientIpStore
|
|
from synapse.replication.slave.storage.devices import SlavedDeviceStore
|
|
from synapse.replication.slave.storage.registration import SlavedRegistrationStore
|
|
from synapse.replication.tcp.client import ReplicationClientHandler
|
|
from synapse.rest.client.v2_alpha._base import client_v2_patterns
|
|
from synapse.server import HomeServer
|
|
from synapse.storage.engines import create_engine
|
|
from synapse.util.httpresourcetree import create_resource_tree
|
|
from synapse.util.logcontext import LoggingContext
|
|
from synapse.util.manhole import manhole
|
|
from synapse.util.versionstring import get_version_string
|
|
from twisted.internet import defer, reactor
|
|
from twisted.web.resource import Resource
|
|
|
|
logger = logging.getLogger("synapse.app.frontend_proxy")
|
|
|
|
|
|
class KeyUploadServlet(RestServlet):
|
|
PATTERNS = client_v2_patterns("/keys/upload(/(?P<device_id>[^/]+))?$")
|
|
|
|
def __init__(self, hs):
|
|
"""
|
|
Args:
|
|
hs (synapse.server.HomeServer): server
|
|
"""
|
|
super(KeyUploadServlet, self).__init__()
|
|
self.auth = hs.get_auth()
|
|
self.store = hs.get_datastore()
|
|
self.http_client = hs.get_simple_http_client()
|
|
self.main_uri = hs.config.worker_main_http_uri
|
|
|
|
@defer.inlineCallbacks
|
|
def on_POST(self, request, device_id):
|
|
requester = yield self.auth.get_user_by_req(request, allow_guest=True)
|
|
user_id = requester.user.to_string()
|
|
body = parse_json_object_from_request(request)
|
|
|
|
if device_id is not None:
|
|
# passing the device_id here is deprecated; however, we allow it
|
|
# for now for compatibility with older clients.
|
|
if (requester.device_id is not None and
|
|
device_id != requester.device_id):
|
|
logger.warning("Client uploading keys for a different device "
|
|
"(logged in as %s, uploading for %s)",
|
|
requester.device_id, device_id)
|
|
else:
|
|
device_id = requester.device_id
|
|
|
|
if device_id is None:
|
|
raise SynapseError(
|
|
400,
|
|
"To upload keys, you must pass device_id when authenticating"
|
|
)
|
|
|
|
if body:
|
|
# They're actually trying to upload something, proxy to main synapse.
|
|
# Pass through the auth headers, if any, in case the access token
|
|
# is there.
|
|
auth_headers = request.requestHeaders.getRawHeaders("Authorization", [])
|
|
headers = {
|
|
"Authorization": auth_headers,
|
|
}
|
|
result = yield self.http_client.post_json_get_json(
|
|
self.main_uri + request.uri,
|
|
body,
|
|
headers=headers,
|
|
)
|
|
|
|
defer.returnValue((200, result))
|
|
else:
|
|
# Just interested in counts.
|
|
result = yield self.store.count_e2e_one_time_keys(user_id, device_id)
|
|
defer.returnValue((200, {"one_time_key_counts": result}))
|
|
|
|
|
|
class FrontendProxySlavedStore(
|
|
SlavedDeviceStore,
|
|
SlavedClientIpStore,
|
|
SlavedApplicationServiceStore,
|
|
SlavedRegistrationStore,
|
|
BaseSlavedStore,
|
|
):
|
|
pass
|
|
|
|
|
|
class FrontendProxyServer(HomeServer):
|
|
def setup(self):
|
|
logger.info("Setting up.")
|
|
self.datastore = FrontendProxySlavedStore(self.get_db_conn(), self)
|
|
logger.info("Finished setting up.")
|
|
|
|
def _listen_http(self, listener_config):
|
|
port = listener_config["port"]
|
|
bind_addresses = listener_config["bind_addresses"]
|
|
site_tag = listener_config.get("tag", port)
|
|
resources = {}
|
|
for res in listener_config["resources"]:
|
|
for name in res["names"]:
|
|
if name == "metrics":
|
|
resources[METRICS_PREFIX] = MetricsResource(self)
|
|
elif name == "client":
|
|
resource = JsonResource(self, canonical_json=False)
|
|
KeyUploadServlet(self).register(resource)
|
|
resources.update({
|
|
"/_matrix/client/r0": resource,
|
|
"/_matrix/client/unstable": resource,
|
|
"/_matrix/client/v2_alpha": resource,
|
|
"/_matrix/client/api/v1": resource,
|
|
})
|
|
|
|
root_resource = create_resource_tree(resources, Resource())
|
|
|
|
_base.listen_tcp(
|
|
bind_addresses,
|
|
port,
|
|
SynapseSite(
|
|
"synapse.access.http.%s" % (site_tag,),
|
|
site_tag,
|
|
listener_config,
|
|
root_resource,
|
|
)
|
|
)
|
|
|
|
logger.info("Synapse client reader now listening on port %d", port)
|
|
|
|
def start_listening(self, listeners):
|
|
for listener in listeners:
|
|
if listener["type"] == "http":
|
|
self._listen_http(listener)
|
|
elif listener["type"] == "manhole":
|
|
_base.listen_tcp(
|
|
listener["bind_addresses"],
|
|
listener["port"],
|
|
manhole(
|
|
username="matrix",
|
|
password="rabbithole",
|
|
globals={"hs": self},
|
|
)
|
|
)
|
|
else:
|
|
logger.warn("Unrecognized listener type: %s", listener["type"])
|
|
|
|
self.get_tcp_replication().start_replication(self)
|
|
|
|
def build_tcp_replication(self):
|
|
return ReplicationClientHandler(self.get_datastore())
|
|
|
|
|
|
def start(config_options):
|
|
try:
|
|
config = HomeServerConfig.load_config(
|
|
"Synapse frontend proxy", config_options
|
|
)
|
|
except ConfigError as e:
|
|
sys.stderr.write("\n" + e.message + "\n")
|
|
sys.exit(1)
|
|
|
|
assert config.worker_app == "synapse.app.frontend_proxy"
|
|
|
|
assert config.worker_main_http_uri is not None
|
|
|
|
setup_logging(config, use_worker_options=True)
|
|
|
|
events.USE_FROZEN_DICTS = config.use_frozen_dicts
|
|
|
|
database_engine = create_engine(config.database_config)
|
|
|
|
tls_server_context_factory = context_factory.ServerContextFactory(config)
|
|
|
|
ss = FrontendProxyServer(
|
|
config.server_name,
|
|
db_config=config.database_config,
|
|
tls_server_context_factory=tls_server_context_factory,
|
|
config=config,
|
|
version_string="Synapse/" + get_version_string(synapse),
|
|
database_engine=database_engine,
|
|
)
|
|
|
|
ss.setup()
|
|
ss.get_handlers()
|
|
ss.start_listening(config.worker_listeners)
|
|
|
|
def start():
|
|
ss.get_state_handler().start_caching()
|
|
ss.get_datastore().start_profiling()
|
|
|
|
reactor.callWhenRunning(start)
|
|
|
|
_base.start_worker_reactor("synapse-frontend-proxy", config)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
with LoggingContext("main"):
|
|
start(sys.argv[1:])
|