mirror of
https://github.com/element-hq/ess-helm.git
synced 2026-11-20 00:51:27 -08:00
341 lines
13 KiB
Python
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 []
|