1.116.0

CHANGES.md

@@ -1,3 +1,10 @@
+# Synapse 1.116.0 (2024-10-01)
+
+No significant changes since 1.116.0rc2.
+
+
+
+
 # Synapse 1.116.0rc2 (2024-09-26)
 
 ### Features

changelog.d/17749.doc

@@ -1 +0,0 @@
-Remove spurious "TODO UPDATE ALL THIS" note in the Debian installation docs.

debian/changelog

@@ -1,3 +1,9 @@
+matrix-synapse-py3 (1.116.0) stable; urgency=medium
+
+  * New Synapse release 1.116.0.
+
+ -- Synapse Packaging team <packages@matrix.org>  Tue, 01 Oct 2024 11:14:07 +0100
+
 matrix-synapse-py3 (1.116.0~rc2) stable; urgency=medium
 
   * New synapse release 1.116.0rc2.

docker/configure_workers_and_start.py

@@ -24,15 +24,6 @@
 # nginx and supervisord configs depending on the workers requested.
 #
 # The environment variables it reads are:
-#   * SYNAPSE_CONFIG_PATH: The path where the generated `homeserver.yaml` will
-#         be stored.
-#   * SYNAPSE_CONFIG_DIR: The directory where generated config will be stored.
-#         If `SYNAPSE_CONFIG_PATH` is not set, it will default to
-#         SYNAPSE_CONFIG_DIR/homeserver.yaml.
-#   * SYNAPSE_DATA_DIR: Where the generated config will put persistent data
-#         such as the database and media store.
-#   * SYNAPSE_CONFIG_TEMPLATE_DIR: The directory containing jinja2 templates for
-#         configuration that this script will generate config from. Defaults to '/conf'.
 #   * SYNAPSE_SERVER_NAME: The desired server_name of the homeserver.
 #   * SYNAPSE_REPORT_STATS: Whether to report stats.
 #   * SYNAPSE_WORKER_TYPES: A comma separated list of worker names as specified in WORKERS_CONFIG
@@ -44,8 +35,6 @@
 #         SYNAPSE_WORKER_TYPES='event_persister, federation_sender, client_reader'
 #         SYNAPSE_WORKER_TYPES='event_persister:2, federation_sender:2, client_reader'
 #         SYNAPSE_WORKER_TYPES='stream_writers=account_data+presence+typing'
-#   * SYNAPSE_WORKERS_WRITE_LOGS_TO_DISK: Whether worker logs should be written to disk,
-#         in addition to stdout.
 #   * SYNAPSE_AS_REGISTRATION_DIR: If specified, a directory in which .yaml and .yml files
 #         will be treated as Application Service registration files.
 #   * SYNAPSE_TLS_CERT: Path to a TLS certificate in PEM format.
@@ -59,9 +48,7 @@
 #   * SYNAPSE_LOG_SENSITIVE: If unset, SQL and SQL values won't be logged,
 #         regardless of the SYNAPSE_LOG_LEVEL setting.
 #   * SYNAPSE_LOG_TESTING: if set, Synapse will log additional information useful
-#         for testing.
-#   * SYNAPSE_USE_UNIX_SOCKET: if set, workers will communicate via unix socket
-#         rather than TCP.
+#     for testing.
 #
 # NOTE: According to Complement's ENTRYPOINT expectations for a homeserver image (as defined
 # in the project's README), this script may be run multiple times, and functionality should
@@ -617,9 +604,7 @@ def generate_base_homeserver_config() -> None:
     # start.py already does this for us, so just call that.
     # note that this script is copied in in the official, monolith dockerfile
     os.environ["SYNAPSE_HTTP_PORT"] = str(MAIN_PROCESS_HTTP_LISTENER_PORT)
-
-    # This script makes use of the `SYNAPSE_CONFIG_DIR` environment variable to
-    # determine where to place the generated homeserver config.
+    subprocess.run(["/usr/local/bin/python", "/start.py", "migrate_config"], check=True)
 
 
 def parse_worker_types(
@@ -748,10 +733,8 @@ def parse_worker_types(
 
 def generate_worker_files(
     environ: Mapping[str, str],
-    config_dir: str,
     config_path: str,
     data_dir: str,
-    template_dir: str,
     requested_worker_types: Dict[str, Set[str]],
 ) -> None:
     """Read the desired workers(if any) that is passed in and generate shared
@@ -759,13 +742,9 @@ def generate_worker_files(
 
     Args:
         environ: os.environ instance.
-        config_dir: The location of the configuration directory, where generated
-            worker config files are written to.
-        config_path: The location of the base Synapse homeserver config file.
-        data_dir: The location of the synapse data directory. Where logs will be
-            stored (if `SYNAPSE_WORKERS_WRITE_LOGS_TO_DISK` is set).
-        template_dir: The location of the template directory. Where jinja2
-            templates for config files live.
+        config_path: The location of the generated Synapse main worker config file.
+        data_dir: The location of the synapse data directory. Where log and
+            user-facing config files live.
         requested_worker_types: A Dict containing requested workers in the format of
             {'worker_name1': {'worker_type', ...}}
     """
@@ -828,8 +807,7 @@ def generate_worker_files(
     nginx_locations: Dict[str, str] = {}
 
     # Create the worker configuration directory if it doesn't already exist
-    workers_config_dir = os.path.join(config_dir, "workers")
-    os.makedirs(workers_config_dir, exist_ok=True)
+    os.makedirs("/conf/workers", exist_ok=True)
 
     # Start worker ports from this arbitrary port
     worker_port = 18009
@@ -876,7 +854,7 @@ def generate_worker_files(
         worker_config = insert_worker_name_for_worker_config(worker_config, worker_name)
 
         worker_config.update(
-            {"name": worker_name, "port": str(worker_port)}
+            {"name": worker_name, "port": str(worker_port), "config_path": config_path}
         )
 
         # Update the shared config with any worker_type specific options. The first of a
@@ -899,14 +877,12 @@ def generate_worker_files(
         worker_descriptors.append(worker_config)
 
         # Write out the worker's logging config file
-        log_config_filepath = generate_worker_log_config(
-            environ, worker_name, template_dir, workers_config_dir, data_dir
-        )
+        log_config_filepath = generate_worker_log_config(environ, worker_name, data_dir)
 
         # Then a worker config file
         convert(
-            os.path.join(template_dir, "worker.yaml.j2"),
-            os.path.join(workers_config_dir, f"{worker_name}.yaml"),
+            "/conf/worker.yaml.j2",
+            f"/conf/workers/{worker_name}.yaml",
             **worker_config,
             worker_log_config_filepath=log_config_filepath,
             using_unix_sockets=using_unix_sockets,
@@ -947,9 +923,7 @@ def generate_worker_files(
     # Finally, we'll write out the config files.
 
     # log config for the master process
-    master_log_config = generate_worker_log_config(
-        environ, "master", template_dir, workers_config_dir, data_dir
-    )
+    master_log_config = generate_worker_log_config(environ, "master", data_dir)
     shared_config["log_config"] = master_log_config
 
     # Find application service registrations
@@ -980,8 +954,8 @@ def generate_worker_files(
 
     # Shared homeserver config
     convert(
-        os.path.join(template_dir, "shared.yaml.j2"),
-        os.path.join(workers_config_dir, "shared.yaml"),
+        "/conf/shared.yaml.j2",
+        "/conf/workers/shared.yaml",
         shared_worker_config=yaml.dump(shared_config),
         appservice_registrations=appservice_registrations,
         enable_redis=workers_in_use,
@@ -991,7 +965,7 @@ def generate_worker_files(
 
     # Nginx config
     convert(
-        os.path.join(template_dir, "nginx.conf.j2"),
+        "/conf/nginx.conf.j2",
         "/etc/nginx/conf.d/matrix-synapse.conf",
         worker_locations=nginx_location_config,
         upstream_directives=nginx_upstream_config,
@@ -1003,7 +977,7 @@ def generate_worker_files(
     # Supervisord config
     os.makedirs("/etc/supervisor", exist_ok=True)
     convert(
-        os.path.join(template_dir, "supervisord.conf.j2"),
+        "/conf/supervisord.conf.j2",
         "/etc/supervisor/supervisord.conf",
         main_config_path=config_path,
         enable_redis=workers_in_use,
@@ -1011,7 +985,7 @@ def generate_worker_files(
     )
 
     convert(
-        os.path.join(template_dir, "synapse.supervisord.conf.j2"),
+        "/conf/synapse.supervisord.conf.j2",
         "/etc/supervisor/conf.d/synapse.conf",
         workers=worker_descriptors,
         main_config_path=config_path,
@@ -1020,7 +994,7 @@ def generate_worker_files(
 
     # healthcheck config
     convert(
-        os.path.join(template_dir, "healthcheck.sh.j2"),
+        "/conf/healthcheck.sh.j2",
         "/healthcheck.sh",
         healthcheck_urls=healthcheck_urls,
     )
@@ -1032,24 +1006,10 @@ def generate_worker_files(
 
 
 def generate_worker_log_config(
-    environ: Mapping[str, str],
-    worker_name: str,
-    workers_config_dir: str,
-    template_dir: str,
-    data_dir: str,
+    environ: Mapping[str, str], worker_name: str, data_dir: str
 ) -> str:
     """Generate a log.config file for the given worker.
 
-    Args:
-        environ: A mapping representing the environment variables that this script
-            is running with.
-        worker_name: The name of the worker. Used in generated file paths.
-        workers_config_dir: The location of the worker configuration directory,
-            where the generated worker log config will be saved.
-        template_dir: The directory containing jinja2 template files.
-        data_dir: The directory where log files will be written (if
-            `SYNAPSE_WORKERS_WRITE_LOGS_TO_DISK` is set).
-
     Returns: the path to the generated file
     """
     # Check whether we should write worker logs to disk, in addition to the console
@@ -1064,9 +1024,9 @@ def generate_worker_log_config(
     extra_log_template_args["SYNAPSE_LOG_TESTING"] = environ.get("SYNAPSE_LOG_TESTING")
 
     # Render and write the file
-    log_config_filepath = os.path.join(workers_config_dir, f"{worker_name}.log.config")
+    log_config_filepath = f"/conf/workers/{worker_name}.log.config"
     convert(
-        os.path.join(template_dir, "log.config"),
+        "/conf/log.config",
         log_config_filepath,
         worker_name=worker_name,
         **extra_log_template_args,
@@ -1089,7 +1049,6 @@ def main(args: List[str], environ: MutableMapping[str, str]) -> None:
     config_dir = environ.get("SYNAPSE_CONFIG_DIR", "/data")
     config_path = environ.get("SYNAPSE_CONFIG_PATH", config_dir + "/homeserver.yaml")
     data_dir = environ.get("SYNAPSE_DATA_DIR", "/data")
-    template_dir = environ.get("SYNAPSE_CONFIG_TEMPLATE_DIR", "/conf")
 
     # override SYNAPSE_NO_TLS, we don't support TLS in worker mode,
     # this needs to be handled by a frontend proxy
@@ -1101,10 +1060,9 @@ def main(args: List[str], environ: MutableMapping[str, str]) -> None:
         generate_base_homeserver_config()
     else:
         log("Base homeserver config exists—not regenerating")
-
     # This script may be run multiple times (mostly by Complement, see note at top of
     # file). Don't re-configure workers in this instance.
-    mark_filepath = os.path.join(config_dir, "workers_have_been_configured")
+    mark_filepath = "/conf/workers_have_been_configured"
     if not os.path.exists(mark_filepath):
         # Collect and validate worker_type requests
         # Read the desired worker configuration from the environment
@@ -1121,9 +1079,7 @@ def main(args: List[str], environ: MutableMapping[str, str]) -> None:
 
         # Always regenerate all other config files
         log("Generating worker config files")
-        generate_worker_files(
-            environ, config_dir, config_path, data_dir, template_dir, requested_worker_types
-        )
+        generate_worker_files(environ, config_path, data_dir, requested_worker_types)
 
         # Mark workers as being configured
         with open(mark_filepath, "w") as f:

docker/start.py

@@ -42,8 +42,6 @@ def convert(src: str, dst: str, environ: Mapping[str, object]) -> None:
 
 
 def generate_config_from_template(
-    data_dir: str,
-    template_dir: str,
     config_dir: str,
     config_path: str,
     os_environ: Mapping[str, str],
@@ -52,9 +50,6 @@ def generate_config_from_template(
     """Generate a homeserver.yaml from environment variables
 
     Args:
-        data_dir: where persistent data is stored
-        template_dir: The location of the template directory. Where jinja2
-            templates for config files live.
         config_dir: where to put generated config files
         config_path: where to put the main config file
         os_environ: environment mapping
@@ -75,10 +70,9 @@ def generate_config_from_template(
         "macaroon": "SYNAPSE_MACAROON_SECRET_KEY",
     }
 
-    synapse_server_name = environ["SYNAPSE_SERVER_NAME"]
     for name, secret in secrets.items():
         if secret not in environ:
-            filename = os.path.join(data_dir, f"{synapse_server_name}.{name}.key")
+            filename = "/data/%s.%s.key" % (environ["SYNAPSE_SERVER_NAME"], name)
 
             # if the file already exists, load in the existing value; otherwise,
             # generate a new secret and write it to a file
@@ -94,7 +88,7 @@ def generate_config_from_template(
                     handle.write(value)
             environ[secret] = value
 
-    environ["SYNAPSE_APPSERVICES"] = glob.glob(os.path.join(data_dir, "appservices", "*.yaml"))
+    environ["SYNAPSE_APPSERVICES"] = glob.glob("/data/appservices/*.yaml")
     if not os.path.exists(config_dir):
         os.mkdir(config_dir)
 
@@ -117,12 +111,12 @@ def generate_config_from_template(
         environ["SYNAPSE_LOG_CONFIG"] = config_dir + "/log.config"
 
     log("Generating synapse config file " + config_path)
-    convert(os.path.join(template_dir, "homeserver.yaml"), config_path, environ)
+    convert("/conf/homeserver.yaml", config_path, environ)
 
     log_config_file = environ["SYNAPSE_LOG_CONFIG"]
     log("Generating log config file " + log_config_file)
     convert(
-        os.path.join(template_dir, "log.config"),
+        "/conf/log.config",
         log_config_file,
         {**environ, "include_worker_name_in_log_line": False},
     )
@@ -134,15 +128,15 @@ def generate_config_from_template(
         "synapse.app.homeserver",
         "--config-path",
         config_path,
-        # tell synapse to put generated keys in the data directory rather than /compiled
+        # tell synapse to put generated keys in /data rather than /compiled
         "--keys-directory",
         config_dir,
         "--generate-keys",
     ]
 
     if ownership is not None:
-        log(f"Setting ownership on the data dir to {ownership}")
-        subprocess.run(["chown", "-R", ownership, data_dir], check=True)
+        log(f"Setting ownership on /data to {ownership}")
+        subprocess.run(["chown", "-R", ownership, "/data"], check=True)
         args = ["gosu", ownership] + args
 
     subprocess.run(args, check=True)
@@ -165,13 +159,12 @@ def run_generate_config(environ: Mapping[str, str], ownership: Optional[str]) ->
     config_dir = environ.get("SYNAPSE_CONFIG_DIR", "/data")
     config_path = environ.get("SYNAPSE_CONFIG_PATH", config_dir + "/homeserver.yaml")
     data_dir = environ.get("SYNAPSE_DATA_DIR", "/data")
-    template_dir = environ.get("SYNAPSE_CONFIG_TEMPLATE_DIR", "/conf")
 
     # create a suitable log config from our template
     log_config_file = "%s/%s.log.config" % (config_dir, server_name)
     if not os.path.exists(log_config_file):
         log("Creating log config %s" % (log_config_file,))
-        convert(os.path.join(template_dir, "log.config"), log_config_file, environ)
+        convert("/conf/log.config", log_config_file, environ)
 
     # generate the main config file, and a signing key.
     args = [
@@ -223,14 +216,12 @@ def main(args: List[str], environ: MutableMapping[str, str]) -> None:
 
     if mode == "migrate_config":
         # generate a config based on environment vars.
-        data_dir = environ.get("SYNAPSE_DATA_DIR", "/data")
         config_dir = environ.get("SYNAPSE_CONFIG_DIR", "/data")
         config_path = environ.get(
             "SYNAPSE_CONFIG_PATH", config_dir + "/homeserver.yaml"
         )
-        template_dir = environ.get("SYNAPSE_CONFIG_TEMPLATE_DIR", "/conf")
         return generate_config_from_template(
-            data_dir, template_dir, config_dir, config_path, environ, ownership
+            config_dir, config_path, environ, ownership
         )
 
     if mode != "run":

docs/setup/installation.md

@@ -52,6 +52,8 @@ architecture via <https://packages.matrix.org/debian/>.
 
 To install the latest release:
 
+TODO UPDATE ALL THIS
+
 ```sh
 sudo apt install -y lsb-release wget apt-transport-https
 sudo wget -O /usr/share/keyrings/matrix-org-archive-keyring.gpg https://packages.matrix.org/debian/matrix-org-archive-keyring.gpg
@@ -314,7 +316,7 @@ sudo dnf group install "Development Tools"
 
 *Note: The term "RHEL" below refers to both Red Hat Enterprise Linux and Rocky Linux. The distributions are 1:1 binary compatible.*
 
-It's recommended to use the latest Python versions.
+It's recommended to use the latest Python versions. 
 
 RHEL 8 in particular ships with Python 3.6 by default which is EOL and therefore no longer supported by Synapse. RHEL 9 ship with Python 3.9 which is still supported by the Python core team as of this writing. However, newer Python versions provide significant performance improvements and they're available in official distributions' repositories. Therefore it's recommended to use them.
 
@@ -344,7 +346,7 @@ dnf install python3.12 python3.12-devel
 ```
 Finally, install common prerequisites
 ```bash
-dnf install libicu libicu-devel libpq5 libpq5-devel lz4 pkgconf
+dnf install libicu libicu-devel libpq5 libpq5-devel lz4 pkgconf 
 dnf group install "Development Tools"
 ```
 ###### Using venv module instead of virtualenv command
@@ -353,7 +355,7 @@ It's recommended to use Python venv module directly rather than the virtualenv c
 * On RHEL 9, virtualenv is only available on [EPEL](https://docs.fedoraproject.org/en-US/epel/).
 * On RHEL 8, virtualenv is based on Python 3.6. It does not support creating 3.11/3.12 virtual environments.
 
-Here's an example of creating Python 3.12 virtual environment and installing Synapse from PyPI.
+Here's an example of creating Python 3.12 virtual environment and installing Synapse from PyPI. 
 
 ```bash
 mkdir -p ~/synapse

pyproject.toml

@@ -97,7 +97,7 @@ module-name = "synapse.synapse_rust"
 
 [tool.poetry]
 name = "matrix-synapse"
-version = "1.116.0rc2"
+version = "1.116.0"
 description = "Homeserver for the Matrix decentralised comms protocol"
 authors = ["Matrix.org Team and Contributors <packages@matrix.org>"]
 license = "AGPL-3.0-or-later"