Files
ess-helm/scripts/migration/synapse.py
T

260 lines
9.4 KiB
Python

# Copyright 2026 Element Creations Ltd
#
# SPDX-License-Identifier: AGPL-3.0-only
"""
Synapse-specific migration strategy.
"""
import logging
from dataclasses import dataclass
from typing import Any
from rapidfuzz import fuzz, process
from .interfaces import ExtraFilesDiscoveryStrategy, SecretDiscoveryStrategy
from .migration import MigrationStrategy, TransformationSpec
from .models import DiscoveredSecret, MigrationError, SecretConfig
from .utils import extract_hostname_from_url
logger = logging.getLogger("migration")
worker_types = [
"main",
"account-data",
"appservice",
"background",
"client-reader",
"device-lists",
"encryption",
"event-creator",
"event-persister",
"federation-inbound",
"federation-reader",
"federation-sender",
"initial-synchrotron",
"media-repository",
"presence-writer",
"push-rules",
"pusher",
"receipts",
"sliding-sync",
"sso-login",
"synchrotron",
"typing-persister",
"user-dir",
]
def prompt_user_for_worker(
pretty_logger: logging.Logger, instance_name: str, instance_props: Any, matched_worker_types: list[str]
) -> str:
if not matched_worker_types:
matched_worker_types = worker_types
logger.info(" No worker type found for instance %s (host: %s)", instance_name, instance_props["host"])
pretty_logger.info(f"\n ❌ No worker type found for instance {instance_name} (host: {instance_props['host']})")
pretty_logger.info(" ❌ Available worker types")
for i, worker_type in enumerate(matched_worker_types):
pretty_logger.info(f" ❌ {i + 1}. {worker_type}")
while True:
try:
value = input(f" Please select the worker type of instance {instance_name}: ").strip()
if value:
# make sure user selected an valid integer
try:
worker_index = int(value) - 1
if worker_index in range(len(matched_worker_types)):
return matched_worker_types[worker_index]
else:
pretty_logger.info(f"Invalid worker type: {value}")
except ValueError:
pretty_logger.info(" ❌ Please select a valid worker type.")
else:
pretty_logger.info(" ❌ Value cannot be empty. Please try again.")
except KeyboardInterrupt as err:
pretty_logger.info("\n ❌ Operation cancelled by user")
raise MigrationError("User cancelled worker input") from err
except EOFError as err:
pretty_logger.info("\n ❌ End of input reached")
raise MigrationError("End of input reached during worker prompt") from err
def extract_workers_from_instance_map(pretty_logger: logging.Logger, instance_map: dict[str, Any]) -> dict[str, Any]:
"""Extract workers from the instance map."""
selected_workers = {}
for instance_name in instance_map:
matches = process.extract(instance_name, worker_types, scorer=fuzz.WRatio, limit=3)
very_high_probable_matches = [m[0] for m in matches if m[1] > 90]
probable_matches = [m[0] for m in matches if m[1] > 60]
selected_worker = (
prompt_user_for_worker(pretty_logger, instance_name, instance_map[instance_name], probable_matches)
if len(very_high_probable_matches) != 1
else very_high_probable_matches[0]
)
if selected_worker == "main":
continue
if selected_worker not in selected_workers:
selected_workers[selected_worker] = {
"enabled": True,
"replicas": 1,
}
else:
selected_workers[selected_worker]["replicas"] += 1
return selected_workers
@dataclass
class SynapseMigration(MigrationStrategy):
"""Synapse-specific migration implementation."""
@property
def component_root_key(self) -> str:
return "synapse"
@property
def override_configs(self) -> set[str]:
return {
"public_baseurl",
"server_name",
"database.args.host",
"database.args.port",
"database.args.user",
"database.args.password",
"database.args.database",
"database.args.sslmode",
"database.args.application_name",
"database.args.keepalives",
"database.args.keepalives_idle",
"database.args.keepalives_interval",
"database.args.keepalives_count",
"ip_range_blacklist",
"signing_key_path",
"start_pushers",
"pusher_instances",
"update_user_directory_from_worker",
"instance_map",
"instance_map.main",
"instance_map.host",
"instance_map.port",
"redis",
"redis.enabled",
"redis.host",
"stream_writers",
"enable_metrics",
"log_config",
"macaroon_secret_key_path",
"registration_shared_secret_path",
"worker_replication_secret_path",
"form_secret_path",
"listeners", # Listeners are also managed by ESS
}
@property
def transformations(self) -> list[TransformationSpec]:
return [
TransformationSpec(src_key="server_name", target_key="serverName"), # Required by default
TransformationSpec(src_key="database.args.host", target_key="synapse.postgres.host"), # Required by default
TransformationSpec(
src_key="database.args.port", target_key="synapse.postgres.port", required=False
), # Optional - defaults to 5432
TransformationSpec(src_key="database.args.user", target_key="synapse.postgres.user"), # Required by default
TransformationSpec(
src_key="database.args.database", target_key="synapse.postgres.database"
), # Required by default
TransformationSpec(
src_key="database.args.sslmode", target_key="synapse.postgres.sslMode", required=False
), # Optional security feature
TransformationSpec(
src_key="public_baseurl",
target_key="synapse.ingress.host",
transformer=extract_hostname_from_url,
), # Extract hostname from public_baseurl for ingress host
TransformationSpec(
src_key="instance_map",
target_key="synapse.workers",
transformer=extract_workers_from_instance_map,
required=False,
), # Extract workers from synapse instance_map
]
@property
def component_config_extras(self) -> dict[str, Any]:
return {"enabled": True}
class SynapseSecretDiscovery(SecretDiscoveryStrategy):
"""Synapse-specific secret discovery implementation."""
@property
def ess_secret_schema(self) -> dict[str, SecretConfig]:
"""Get the ESS secret schema for Synapse."""
return {
# Synapse secrets
"synapse.postgres.password": SecretConfig(
init_if_missing_from_source_cfg=False, # Must be provided
description="Synapse database password",
config_inline="database.args.password",
config_path=None,
),
"synapse.macaroon": SecretConfig(
init_if_missing_from_source_cfg=False, # This would break user tokens if changing after migrating
description="Synapse macaroon secret",
config_inline="macaroon_secret_key",
config_path="macaroon_secret_key_path",
),
"synapse.registrationSharedSecret": SecretConfig(
init_if_missing_from_source_cfg=True, # Would break external scripts
# if changing after migrating. Just warn about it, dont break.
description="Registration shared secret",
config_inline="registration_shared_secret",
config_path="registration_shared_secret_path",
),
"synapse.signingKey": SecretConfig(
init_if_missing_from_source_cfg=False, # This would break federation if changing after migrating
description="Signing key",
config_inline="signing_key",
config_path="signing_key_path",
),
}
@property
def component_name(self) -> str:
return "Synapse"
def discover_component_specific_secrets(self, config_data: dict) -> dict[str, DiscoveredSecret]:
"""
Discover component-specific secrets from configuration.
Synapse doesn't have specialized secret discovery, so this returns an empty dict.
Args:
config_data: Synapse configuration data
Returns:
Empty dictionary (no specialized secret discovery for Synapse)
"""
return {}
class SynapseExtraFileDiscovery(ExtraFilesDiscoveryStrategy):
@property
def component_name(self) -> str:
return "Synapse"
@property
def ignored_config_keys(self) -> list[str]:
return [
"media_store_path", # Synapse media store path should be ignored
"log_config", # Log configuration is handled by the chart
]
@property
def ignored_file_paths(self) -> list[str]:
"""Files paths to ignore when discovering extra files."""
...
return []