323 lines
18 KiB
PHP
323 lines
18 KiB
PHP
<?php
|
|
|
|
app_require('classes/replication_manager.php');
|
|
|
|
use classes\replication_manager;
|
|
|
|
it('computes MySQL GTID interval counts and coverage percentages', function (): void {
|
|
$source = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa:1-5:7-10,bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb:1-2';
|
|
$executed = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa:1-3:7-10,bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb:1';
|
|
|
|
expect(replication_manager::mysqlGtidIntervalCount($source))->toBe(11);
|
|
expect(replication_manager::mysqlGtidCoveragePercent($source, $executed))->toBe(72.73);
|
|
});
|
|
|
|
it('reports empty source GTID sets as caught up', function (): void {
|
|
expect(replication_manager::mysqlGtidCoveragePercent('', ''))->toBe(100.0);
|
|
});
|
|
|
|
it('computes Redis offset percentages safely', function (): void {
|
|
expect(replication_manager::redisOffsetPercent(1000, 750))->toBe(75.0);
|
|
expect(replication_manager::redisOffsetPercent(0, 0))->toBe(100.0);
|
|
expect(replication_manager::redisOffsetPercent(1000, 1250))->toBe(100.0);
|
|
});
|
|
|
|
it('computes MariaDB GTID coverage by domain sequence', function (): void {
|
|
$source = '0-1-10,1-1-20';
|
|
$replica = '0-2-8,1-3-20';
|
|
|
|
expect(replication_manager::mariadbGtidCoveragePercent($source, $replica))->toBe(93.33);
|
|
expect(replication_manager::mariadbGtidCoveragePercent('', ''))->toBe(100.0);
|
|
});
|
|
|
|
it('normalizes public replication kind aliases', function (): void {
|
|
expect(replication_manager::normalizeKind('databases'))->toBe('database');
|
|
expect(replication_manager::normalizeKind('mysql'))->toBe('database');
|
|
expect(replication_manager::normalizeKind('redis'))->toBe('redis');
|
|
expect(replication_manager::normalizeKind('minio'))->toBe('minio');
|
|
expect(replication_manager::normalizeKind('s3'))->toBe('minio');
|
|
expect(replication_manager::normalizeKind('object-storage'))->toBe('minio');
|
|
});
|
|
|
|
it('generates replication-ready MariaDB compose templates without embedding secrets', function (): void {
|
|
$template = replication_manager::composeTemplate([
|
|
'kind' => 'database',
|
|
'role' => 'replica',
|
|
'service_name' => 'MariaDB Replica 2',
|
|
'database' => 'nnks_db',
|
|
'username' => 'nnks_db_user',
|
|
'host_port' => 5433,
|
|
'server_id' => 2,
|
|
]);
|
|
|
|
expect($template['kind'])->toBe('database');
|
|
expect($template['role'])->toBe('replica');
|
|
expect($template['service_name'])->toBe('mariadb-replica-2');
|
|
expect($template['compose'])->toContain('image: "mariadb:11"');
|
|
expect($template['compose'])->toContain('"--server-id=2"');
|
|
expect($template['compose'])->toContain('"--log-bin=/var/lib/mysql/mariadb-bin"');
|
|
expect($template['compose'])->toContain('"--binlog-format=ROW"');
|
|
expect($template['compose'])->toContain('"--gtid-strict-mode=ON"');
|
|
expect($template['compose'])->toContain('"--read-only=ON"');
|
|
expect($template['compose'])->toContain('"--replicate-ignore-table=nnks_db.logs"');
|
|
expect($template['compose'])->toContain('"--replicate-ignore-table=nnks_db.edge_gateway_log_entries"');
|
|
expect($template['compose'])->toContain('"--replicate-ignore-table=nnks_db.replication_status_snapshots"');
|
|
expect($template['compose'])->toContain('"5433:3306"');
|
|
expect($template['compose'])->toContain('mariadb-replica-2-seed');
|
|
expect($template['compose'])->toContain('MARIADB_PRIMARY_ADMIN_PASSWORD');
|
|
expect($template['compose'])->toContain('mariadb-dump --host="$MARIADB_PRIMARY_HOST"');
|
|
expect($template['compose'])->toContain('--ignore-table="$MARIADB_SEED_DATABASE.logs"');
|
|
expect($template['compose'])->toContain('--ignore-table="$MARIADB_SEED_DATABASE.edge_gateway_log_entries"');
|
|
expect($template['compose'])->toContain('--ignore-table="$MARIADB_SEED_DATABASE.replication_status_snapshots"');
|
|
expect($template['compose'])->toContain('--no-data "$MARIADB_SEED_DATABASE" "$table"');
|
|
expect($template['compose'])->toContain('${MARIADB_ROOT_PASSWORD:?set MARIADB_ROOT_PASSWORD}');
|
|
expect($template['compose'])->not->toContain('<set-a-long-random-root-password>');
|
|
expect($template['env'])->toMatch('/MARIADB_ROOT_PASSWORD=[A-Za-z0-9_-]{32}/');
|
|
expect($template['env'])->toMatch('/MARIADB_PASSWORD=[A-Za-z0-9_-]{32}/');
|
|
expect($template['env'])->toContain('MARIADB_PRIMARY_ADMIN_PASSWORD=');
|
|
expect($template['credentials']['password'])->toMatch('/^[A-Za-z0-9_-]{32}$/');
|
|
expect($template['credentials']['admin_password'])->toMatch('/^[A-Za-z0-9_-]{32}$/');
|
|
expect($template['credentials']['port'])->toBe(5433);
|
|
expect($template['credentials']['allow_preseeded_replica'])->toBeTrue();
|
|
expect($template['seed_command'])->toContain('mariadb-dump');
|
|
expect($template['seed_command'])->toContain('--gtid');
|
|
expect($template['seed_command'])->toContain('--master-data=2');
|
|
expect($template['seed_command'])->toContain('--ignore-table=\'nnks_db.logs\'');
|
|
expect($template['seed_command'])->toContain('--ignore-table=\'nnks_db.edge_gateway_log_entries\'');
|
|
expect($template['seed_command'])->toContain('--ignore-table=\'nnks_db.replication_status_snapshots\'');
|
|
});
|
|
|
|
it('detects missing database tables before provisioning a preseeded replica', function (): void {
|
|
expect(replication_manager::missingDatabaseTables(
|
|
['customers', 'edge_gateways', 'orders'],
|
|
['customers', 'orders']
|
|
))->toBe(['edge_gateways']);
|
|
});
|
|
|
|
it('seeds MariaDB replicas in place instead of requiring container recreation', function (): void {
|
|
$content = file_get_contents(app_path('classes/replication_manager.php'));
|
|
|
|
expect($content)->toContain('advanceMariaDbReplicaSeed($operationId, $primary, $host, $target)');
|
|
expect($content)->toContain('MARIADB_SEED_BATCH_ROWS');
|
|
expect($content)->toContain('MARIADB_SEED_STEP_SECONDS');
|
|
expect($content)->toContain('activeOperationId($kind, $id, \'provision\')');
|
|
expect($content)->toContain('updateOperationProgress($operationId, $progress, $message, $context)');
|
|
expect($content)->toContain("application_write_freeze::freeze('MariaDB replica seed is copying data.'");
|
|
expect($content)->toContain('DROP DATABASE IF EXISTS');
|
|
expect($content)->toContain('CREATE DATABASE ');
|
|
expect($content)->toContain('SHOW CREATE TABLE');
|
|
expect($content)->toContain('SET GLOBAL gtid_slave_pos');
|
|
expect($content)->toContain('databasePrimaryKeyColumnNames($source, $primaryDatabase, $tableName)');
|
|
expect($content)->toContain('$target->begin_transaction()');
|
|
expect($content)->toContain("'connect_without_database' => \$usePreseededReplica");
|
|
});
|
|
|
|
it('keeps operational log tables schema-only during MariaDB seeding and replication', function (): void {
|
|
$content = file_get_contents(app_path('classes/replication_manager.php'));
|
|
|
|
expect($content)->toContain('MARIADB_SCHEMA_ONLY_TABLES');
|
|
expect($content)->toContain("'logs'");
|
|
expect($content)->toContain("'edge_gateway_log_entries'");
|
|
expect($content)->toContain("'replication_status_snapshots'");
|
|
expect($content)->toContain("'replication_operations'");
|
|
expect($content)->toContain("'replication_audit_logs'");
|
|
expect($content)->toContain("'skip_data' => \$skipData");
|
|
expect($content)->toContain('createMariaDbReplicaTable(');
|
|
expect($content)->toContain('SET GLOBAL replicate_ignore_table');
|
|
expect($content)->toContain('--replicate-ignore-table=');
|
|
expect($content)->toContain('mariaDbSchemaOnlyDumpIgnoreArgs');
|
|
expect($content)->toContain('mariaDbSchemaOnlySeedCommandIgnoreArgs');
|
|
expect($content)->toContain('databaseSchemaOnlyTablesWithRows');
|
|
expect($content)->toContain('schemaOnlyTablesContainRowsBlocker');
|
|
expect($content)->toContain('RESET SLAVE ALL');
|
|
expect($content)->toContain('mariaDbSeedContextRequiresFilterReset($context)');
|
|
});
|
|
|
|
it('allows failed replicas to be removed without allowing primary or healthy replica removal', function (): void {
|
|
expect(replication_manager::replicationHostCanBeRemoved(['role' => 'primary', 'status' => 'ok']))->toBeFalse();
|
|
expect(replication_manager::replicationHostCanBeRemoved(['role' => 'inactive', 'status' => 'inactive']))->toBeTrue();
|
|
expect(replication_manager::replicationHostCanBeRemoved(['role' => 'replica', 'status' => 'degraded']))->toBeTrue();
|
|
expect(replication_manager::replicationHostCanBeRemoved(['role' => 'replica', 'status' => 'ok']))->toBeFalse();
|
|
});
|
|
|
|
it('generates Redis replica compose templates with primary connection placeholders', function (): void {
|
|
$template = replication_manager::composeTemplate([
|
|
'kind' => 'redis',
|
|
'role' => 'replica',
|
|
'service_name' => 'Redis Replica',
|
|
'host_port' => 6380,
|
|
'primary_host' => 'redis-primary.internal',
|
|
'primary_port' => 6379,
|
|
]);
|
|
|
|
expect($template['kind'])->toBe('redis');
|
|
expect($template['compose'])->toContain('image: "redis:7"');
|
|
expect($template['compose'])->toContain('REDIS_PASSWORD: "${REDIS_PASSWORD:?set REDIS_PASSWORD}"');
|
|
expect($template['compose'])->toContain('REDIS_PRIMARY_HOST: "${REDIS_PRIMARY_HOST:?set REDIS_PRIMARY_HOST}"');
|
|
expect($template['compose'])->toContain('REDIS_PRIMARY_PORT: "${REDIS_PRIMARY_PORT:-6379}"');
|
|
expect($template['compose'])->toContain('${REDIS_PRIMARY_PASSWORD:?set REDIS_PRIMARY_PASSWORD}');
|
|
expect($template['compose'])->toContain('REDIS_PRIMARY_USERNAME: "${REDIS_PRIMARY_USERNAME:-}"');
|
|
expect($template['compose'])->toContain('if [ ! -f /data/redis.conf ]; then');
|
|
expect($template['compose'])->toContain('> /data/redis.conf');
|
|
expect($template['compose'])->toContain('exec redis-server /data/redis.conf');
|
|
expect($template['compose'])->toContain('echo "replicaof $$REDIS_PRIMARY_HOST $${REDIS_PRIMARY_PORT:-6379}"');
|
|
expect($template['compose'])->toContain('echo "masterauth $$REDIS_PRIMARY_PASSWORD"');
|
|
expect($template['compose'])->toContain('echo "masteruser $$REDIS_PRIMARY_USERNAME"');
|
|
expect($template['compose'])->toContain('redis-cli --no-auth-warning -a \"$${REDIS_PASSWORD}\" ping | grep PONG');
|
|
expect($template['compose'])->not->toContain($template['credentials']['password']);
|
|
expect($template['env'])->toMatch('/REDIS_PASSWORD=[A-Za-z0-9_-]{32}/');
|
|
expect($template['env'])->toContain('REDIS_PRIMARY_HOST=redis-primary.internal');
|
|
expect($template['env'])->toContain('REDIS_PRIMARY_PORT=6379');
|
|
expect($template['env'])->toContain("REDIS_PRIMARY_PASSWORD=\n");
|
|
expect($template['env'])->toContain("REDIS_PRIMARY_USERNAME=\n");
|
|
expect($template['credentials']['password'])->toMatch('/^[A-Za-z0-9_-]{32}$/');
|
|
});
|
|
|
|
it('generates MinIO replica compose templates without embedding secrets', function (): void {
|
|
$template = replication_manager::composeTemplate([
|
|
'kind' => 'minio',
|
|
'role' => 'replica',
|
|
'service_name' => 'MinIO Replica 1',
|
|
'host_port' => 9010,
|
|
'console_port' => 9011,
|
|
'buckets' => ['attachments', 'uploads'],
|
|
]);
|
|
|
|
expect($template['kind'])->toBe('minio');
|
|
expect($template['engine'])->toBe('minio');
|
|
expect($template['service_name'])->toBe('minio-replica-1');
|
|
expect($template['host_port'])->toBe(9010);
|
|
expect($template['console_port'])->toBe(9011);
|
|
expect($template['compose'])->toContain('image: "minio/minio:latest"');
|
|
expect($template['compose'])->toContain('MINIO_ROOT_USER: "${MINIO_ROOT_USER:?set MINIO_ROOT_USER}"');
|
|
expect($template['compose'])->toContain('MINIO_ROOT_PASSWORD: "${MINIO_ROOT_PASSWORD:?set MINIO_ROOT_PASSWORD}"');
|
|
expect($template['compose'])->toContain('"9010:9000"');
|
|
expect($template['compose'])->toContain('"9011:9001"');
|
|
expect($template['compose'])->toContain('mc mb --ignore-existing');
|
|
expect($template['compose'])->toContain('mc version enable');
|
|
expect($template['compose'])->toContain('MINIO_PRIMARY_ENDPOINT');
|
|
expect($template['compose'])->not->toContain($template['credentials']['password']);
|
|
expect($template['env'])->toMatch('/MINIO_ROOT_PASSWORD=[A-Za-z0-9_-]{32}/');
|
|
expect($template['env'])->toContain('MINIO_BUCKETS=attachments,uploads');
|
|
expect($template['env'])->toContain('MINIO_PRIMARY_ENDPOINT=');
|
|
expect($template['credentials']['scheme'])->toBe('http');
|
|
expect($template['credentials']['buckets'])->toBe(['attachments', 'uploads']);
|
|
expect($template['credentials']['space_headroom_percent'])->toBe(20.0);
|
|
});
|
|
|
|
it('computes MinIO free-space and catch-up math safely', function (): void {
|
|
expect(replication_manager::minioRequiredFreeBytes(1000))->toBe(1200);
|
|
expect(replication_manager::minioByteReplicationPercent(1000, 750))->toBe(75.0);
|
|
expect(replication_manager::minioByteReplicationPercent(0, 0))->toBe(100.0);
|
|
expect(replication_manager::minioSpaceBlockers(1199, 1200))->toContain('MinIO target does not have enough free space. Required 1200 bytes, available 1199 bytes.');
|
|
expect(replication_manager::minioSpaceBlockers(null, 1200))->toContain('MinIO target free space could not be determined.');
|
|
expect(replication_manager::minioAvailableBytesFromAdminInfo([
|
|
'servers' => [
|
|
['drives' => [['availableSpace' => 4096]]],
|
|
],
|
|
]))->toBe(4096);
|
|
expect(replication_manager::normalizeMinioBuckets('Attachments, uploads backups'))->toBe(['attachments', 'uploads', 'backups']);
|
|
});
|
|
|
|
it('wires MinIO replication through routes and bootstrap snapshots', function (): void {
|
|
$manager = file_get_contents(app_path('classes/replication_manager.php'));
|
|
$routes = file_get_contents(app_path('routes/superuserReplicationRoute.php'));
|
|
$openapi = file_get_contents(app_path('openapi.yaml'));
|
|
|
|
expect($manager)->toContain('private const KIND_MINIO');
|
|
expect($manager)->toContain('provisionMinioHost($host, $operationId)');
|
|
expect($manager)->toContain('promoteMinioHost($host)');
|
|
expect($manager)->toContain('testMinioHost($host)');
|
|
expect($manager)->toContain('minioTargetFreeBytes($host)');
|
|
expect($manager)->toContain('minioRequiredFreeBytes');
|
|
expect($manager)->toContain("'minio' => [");
|
|
expect($routes)->toContain("/superuser/replication/minio");
|
|
expect($openapi)->toContain('enum: [database, redis, minio]');
|
|
expect($openapi)->toContain('endpoint:');
|
|
expect($openapi)->toContain('space_headroom_percent:');
|
|
});
|
|
|
|
it('provisions Redis replicas after a connectivity-only preflight and reports sync progress', function (): void {
|
|
$content = file_get_contents(app_path('classes/replication_manager.php'));
|
|
|
|
expect($content)->toContain('provisionRedisHost($host, $operationId)');
|
|
expect($content)->toContain("testRedisHost(array_merge(\$host, ['test_connectivity_only' => true]))");
|
|
expect($content)->toContain("executeRaw(['REPLICAOF', (string)\$primary['host'], (string)\$primary['port']])");
|
|
expect($content)->toContain("executeRaw(['CONFIG', 'REWRITE'])");
|
|
expect($content)->toContain('Redis replication was configured; waiting for the replica to catch up.');
|
|
expect($content)->toContain('$onlySyncBlockers');
|
|
expect($content)->toContain("'status' => 'running'");
|
|
expect($content)->toContain('Redis replica is syncing from the primary.');
|
|
});
|
|
|
|
it('keeps Redis promotion caught-up, durable, and metadata-safe', function (): void {
|
|
$content = file_get_contents(app_path('classes/replication_manager.php'));
|
|
|
|
expect($content)->toContain("application_write_freeze::freeze('Replication promotion in progress.'");
|
|
expect($content)->toContain("if (\$status['blockers'] !== [] || (float)\$status['replication_percent'] < 100.0)");
|
|
expect($content)->toContain("executeRaw(['REPLICAOF', 'NO', 'ONE'])");
|
|
expect($content)->toContain("executeRaw(['CONFIG', 'REWRITE'])");
|
|
expect($content)->toContain('switchPrimary(self::KIND_REDIS');
|
|
expect($content)->toContain('writeBootstrapSnapshot()');
|
|
});
|
|
|
|
it('does not require replica SQL threads before database provisioning configures them', function (): void {
|
|
$content = file_get_contents(app_path('classes/replication_manager.php'));
|
|
|
|
expect($content)->toContain("'test_connectivity_only' => true");
|
|
expect($content)->toContain("'connect_without_database' => \$usePreseededReplica");
|
|
expect($content)->toContain("'healthy' => \$status['blockers'] === []");
|
|
expect($content)->toContain("'message' => \$targetEngine === 'mariadb'");
|
|
expect($content)->toContain('Database replica status is not configured.');
|
|
expect($content)->toContain('Database replication IO thread is not running.');
|
|
expect($content)->toContain('Database replication SQL thread is not running.');
|
|
expect($content)->toContain("if (\$status !== [])");
|
|
});
|
|
|
|
it('keeps replication operation progress schema idempotent for existing installs', function (): void {
|
|
$content = file_get_contents(app_path('classes/replication_schema_bootstrap.php'));
|
|
|
|
expect($content)->toContain("ensureColumn('replication_operations', 'progress_percent'");
|
|
expect($content)->toContain("ensureColumn('replication_operations', 'message'");
|
|
expect($content)->toContain("ensureColumn('replication_operations', 'context_json'");
|
|
});
|
|
|
|
it('creates the generated replication user on the primary during provisioning', function (): void {
|
|
$content = file_get_contents(app_path('classes/replication_manager.php'));
|
|
|
|
expect($content)->toContain('ensureDatabaseReplicationUser($primary, $replicationUser, $replicationPassword)');
|
|
expect($content)->toContain('GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO');
|
|
});
|
|
|
|
it('supports MariaDB prerequisites without requiring Oracle MySQL variables', function (): void {
|
|
$blockers = replication_manager::databasePrerequisiteBlockers([
|
|
'server_version' => '11.8.6-MariaDB-ubu2404',
|
|
'log_bin' => 'ON',
|
|
'server_id' => '12',
|
|
'gtid_binlog_pos' => '0-12-42',
|
|
]);
|
|
|
|
expect($blockers)->toBe([]);
|
|
|
|
$quietServerBlockers = replication_manager::databasePrerequisiteBlockers([
|
|
'server_version' => '11.8.6-MariaDB-ubu2404',
|
|
'log_bin' => 'ON',
|
|
'server_id' => '12',
|
|
'gtid_current_pos' => '',
|
|
]);
|
|
|
|
expect($quietServerBlockers)->toBe([]);
|
|
});
|
|
|
|
it('reports MariaDB-specific blockers when GTID or binary logging prerequisites are missing', function (): void {
|
|
$blockers = replication_manager::databasePrerequisiteBlockers([
|
|
'server_version' => '11.8.6-MariaDB-ubu2404',
|
|
'log_bin' => 'OFF',
|
|
'server_id' => '12',
|
|
]);
|
|
|
|
expect($blockers)->toContain('MariaDB binary logging must be enabled.');
|
|
expect($blockers)->toContain('MariaDB GTID position must be available.');
|
|
expect($blockers)->not->toContain('Oracle MySQL 8.x is required for managed replication. Current server reports 11.8.6-MariaDB-ubu2404.');
|
|
});
|