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

341 lines
13 KiB
Python

# Copyright 2026 Element Creations Ltd
#
# SPDX-License-Identifier: AGPL-3.0-only
"""
Synapse-specific migration strategy.
"""
import logging
import os
import urllib
from dataclasses import dataclass
from typing import Any
from .interfaces import ExtraFilesDiscoveryStrategy, SecretDiscoveryStrategy
from .migration import MigrationStrategy, TransformationSpec
from .models import DiscoveredSecret, SecretConfig
from .utils import detect_key_type, extract_hostname_from_url
logger = logging.getLogger("migration")
def parse_postgres_uri(uri: str) -> dict[str, Any]:
"""
Parse a PostgreSQL connection URI and extract database configuration.
Args:
uri: PostgreSQL connection URI (e.g., "postgresql://user:pass@host:port/db?sslmode=prefer")
Returns:
Dictionary with database configuration fields (port is returned as int)
"""
if not uri or not uri.startswith("postgresql://"):
return {}
try:
# Parse the URI
parsed = urllib.parse.urlparse(uri)
# Build result dictionary only with fields that are actually present
result: dict[str, str | int | None] = {}
if parsed.hostname:
result["host"] = parsed.hostname
if parsed.port:
result["port"] = int(parsed.port)
if parsed.username:
result["user"] = parsed.username
if parsed.password:
result["password"] = parsed.password
if parsed.path:
result["name"] = parsed.path.lstrip("/")
# Extract SSL mode from query parameters (only if present)
if parsed.query:
query_params = urllib.parse.parse_qs(parsed.query)
if "sslmode" in query_params:
result["ssl"] = query_params["sslmode"][0]
return result
except Exception as e:
logging.warning(f"Failed to parse PostgreSQL URI '{uri}': {e}")
return {}
def extract_port_from_uri(_, uri: str) -> int | None:
"""
Extract port from PostgreSQL URI, returning None if not present.
Args:
uri: PostgreSQL connection URI
Returns:
Port as integer if present, None otherwise
"""
parsed = parse_postgres_uri(uri)
port = parsed.get("port")
return int(port) if port is not None else None
@dataclass
class MASMigration(MigrationStrategy):
"""MAS-specific migration implementation."""
@property
def component_root_key(self) -> str:
return "matrixAuthenticationService"
@property
def override_configs(self) -> set[str]:
return {
"http", # The entire HTTP configuration is managed by ESS
"database.uri", # Database URI configuration is managed by ESS"
"secrets.keys",
}
@property
def transformations(self) -> list[TransformationSpec]:
return [
TransformationSpec(
src_key="database.uri",
target_key="matrixAuthenticationService.postgres.host",
transformer=lambda _, uri: parse_postgres_uri(uri).get("host"),
required=True,
),
TransformationSpec(
src_key="database.uri",
target_key="matrixAuthenticationService.postgres.port",
transformer=extract_port_from_uri,
required=False,
),
TransformationSpec(
src_key="database.uri",
target_key="matrixAuthenticationService.postgres.user",
transformer=lambda _, uri: parse_postgres_uri(uri).get("user"),
required=True,
),
TransformationSpec(
src_key="database.uri",
target_key="matrixAuthenticationService.postgres.database",
transformer=lambda _, uri: parse_postgres_uri(uri).get("name"),
required=True,
),
TransformationSpec(
src_key="database.uri",
target_key="matrixAuthenticationService.postgres.sslMode",
transformer=lambda _, uri: parse_postgres_uri(uri).get("ssl"),
required=False,
),
TransformationSpec(
src_key="http.public_base",
target_key="matrixAuthenticationService.ingress.host",
transformer=extract_hostname_from_url,
), # Extract hostname from http.public_base for ingress host
]
class MASSecretDiscovery(SecretDiscoveryStrategy):
"""MAS-specific secret discovery implementation."""
@property
def component_name(self) -> str:
return "Matrix Authentication Service"
@property
def ess_secret_schema(self) -> dict[str, SecretConfig]:
"""Get the ESS secret schema for MAS."""
return {
# MAS secrets
"matrixAuthenticationService.postgres.password": SecretConfig(
init_if_missing_from_source_cfg=True, # Must be provided
description="MAS database password",
config_inline="database.uri",
config_path=None,
transformer=lambda uri: parse_postgres_uri(uri).get("password"),
),
"matrixAuthenticationService.synapseSharedSecret": SecretConfig(
init_if_missing_from_source_cfg=True, # Can be auto-generated
description="MAS Synapse shared secret",
config_inline="matrix.secret",
config_path="matrix.secret_file",
),
"matrixAuthenticationService.encryptionSecret": SecretConfig(
init_if_missing_from_source_cfg=True, # Must be provided
description="MAS encryption secret",
config_inline="secrets.encryption",
config_path="secrets.encryption_file",
),
# Key secrets - these will be discovered through special key processing
"matrixAuthenticationService.keys.rsa": SecretConfig(
init_if_missing_from_source_cfg=True,
description="MAS RSA private key for signing operations",
config_inline=None,
config_path=None,
transformer=None,
),
"matrixAuthenticationService.keys.ecdsaPrime256v1": SecretConfig(
init_if_missing_from_source_cfg=True,
description="MAS ECDSA Prime256v1 private key for signing operations",
config_inline=None,
config_path=None,
transformer=None,
),
"matrixAuthenticationService.keys.ecdsaSecp256k1": SecretConfig(
init_if_missing_from_source_cfg=True,
description="MAS ECDSA Secp256k1 private key for signing operations",
config_inline=None,
config_path=None,
transformer=None,
),
"matrixAuthenticationService.keys.ecdsaSecp384r1": SecretConfig(
init_if_missing_from_source_cfg=True,
description="MAS ECDSA Secp384r1 private key for signing operations",
config_inline=None,
config_path=None,
transformer=None,
),
}
def discover_component_specific_secrets(self, config_data: dict) -> dict[str, DiscoveredSecret]:
"""
Discover component-specific secrets from MAS configuration.
Args:
config_data: MAS configuration data
Returns:
Dictionary mapping ESS secret keys to DiscoveredSecret objects
"""
discovered_secrets: dict[str, DiscoveredSecret] = {}
# Handle keys_dir (directory scanning)
keys_dir = config_data.get("secrets", {}).get("keys_dir")
if keys_dir:
dir_secrets = self._process_keys_directory(keys_dir)
discovered_secrets.update(dir_secrets)
# Handle individual keys
keys_config = config_data.get("secrets", {}).get("keys", [])
if keys_config:
individual_secrets = self._process_individual_keys(keys_config)
# Individual keys take precedence over directory keys
discovered_secrets.update(individual_secrets)
return discovered_secrets
def _process_keys_directory(self, keys_dir: str) -> dict[str, DiscoveredSecret]:
"""
Process all key files in a directory.
Args:
keys_dir: Path to directory containing key files
Returns:
Dictionary mapping ESS secret keys to DiscoveredSecret objects
"""
discovered_secrets: dict[str, DiscoveredSecret] = {}
try:
if not os.path.isdir(keys_dir):
logger.warning(f"Keys directory does not exist: {keys_dir}")
return discovered_secrets
for filename in os.listdir(keys_dir):
filepath = os.path.join(keys_dir, filename)
if os.path.isfile(filepath):
try:
with open(filepath, "rb") as f:
content = f.read()
key_type = detect_key_type(content)
if key_type in ["rsa", "ecdsaPrime256v1", "ecdsaSecp256k1", "ecdsaSecp384r1"]:
secret_key = f"matrixAuthenticationService.keys.{key_type}"
# Only set if not already discovered (prefer individual keys over directory)
if secret_key not in discovered_secrets:
discovered_secret = DiscoveredSecret(
source_file="mas.yaml",
secret_key=secret_key,
config_key="secrets.keys_dir",
value=content.decode("utf-8")
)
discovered_secrets[secret_key] = discovered_secret
logger.info(f"Discovered {key_type} key from file: {filepath}")
except Exception as e:
logger.warning(f"Failed to process key file {filepath}: {e}")
except Exception as e:
logger.warning(f"Failed to process keys directory {keys_dir}: {e}")
return discovered_secrets
def _process_individual_keys(self, keys_config: list) -> dict[str, DiscoveredSecret]:
"""
Process individual key configurations.
Args:
keys_config: List of key configuration dictionaries
Returns:
Dictionary mapping ESS secret keys to DiscoveredSecret objects
"""
discovered_secrets: dict[str, DiscoveredSecret] = {}
for index, key_config in enumerate(keys_config):
content = None
config_key = None
# Try key_file first
if "key_file" in key_config:
try:
with open(key_config["key_file"], "rb") as f:
content = f.read()
config_key = f"secrets.keys.{index}.key_file"
logger.info(f"Read key from file: {key_config['key_file']}")
except Exception as e:
logger.warning(f"Failed to read key file {key_config['key_file']}: {e}")
continue
# Try inline key content
elif "key" in key_config:
content = key_config["key"].encode("utf-8")
config_key = f"secrets.keys.{index}.key"
logger.info("Read key from inline content")
if content and config_key:
key_type = detect_key_type(content)
if key_type in ["rsa", "ecdsaPrime256v1", "ecdsaSecp256k1", "ecdsaSecp384r1"]:
secret_key = f"matrixAuthenticationService.keys.{key_type}"
# Only set if not already discovered (prefer individual keys over directory)
if secret_key not in discovered_secrets:
discovered_secret = DiscoveredSecret(
source_file="mas.yaml",
secret_key=secret_key,
config_key=config_key,
value=content.decode("utf-8")
)
discovered_secrets[secret_key] = discovered_secret
logger.info(f"Discovered {key_type} key from individual configuration")
return discovered_secrets
class MASExtraFileDiscovery(ExtraFilesDiscoveryStrategy):
@property
def component_name(self) -> str:
return "Matrix Authentication Service"
@property
def ignored_config_keys(self) -> list[str]:
# Keep secrets.keys_dir in ignored keys for extra files discovery
# as it's processed by specialized key discovery logic
return ["secrets.keys_dir"]
@property
def ignored_file_paths(self) -> list[str]:
"""Files paths to ignore when discovering extra files."""
...
return []