diff --git a/web/app/Services/Cloud/CloudAdminTrafficPoolService.php b/web/app/Services/Cloud/CloudAdminTrafficPoolService.php index 65464cda..1078cc1e 100644 --- a/web/app/Services/Cloud/CloudAdminTrafficPoolService.php +++ b/web/app/Services/Cloud/CloudAdminTrafficPoolService.php @@ -44,6 +44,14 @@ final class CloudAdminTrafficPoolService public static function page(array $query = []): array { + $groups = CloudTrafficPoolGroup::orderBy('id')->get(); + $generatedAt = time(); + $freshnessByGroup = CloudTrafficPoolFreshness::forGroups( + $groups->pluck('id')->map( + static fn ($id): int => (int) $id + )->all(), + $generatedAt + ); $items = []; $summary = [ 'groups_total' => 0, @@ -52,8 +60,12 @@ final class CloudAdminTrafficPoolService 'enforced' => 0, 'ready_to_enforce' => 0, ]; - foreach (CloudTrafficPoolGroup::orderBy('id')->get() as $group) { - $item = self::groupDto($group); + foreach ($groups as $group) { + $item = self::groupDto( + $group, + $freshnessByGroup[(int) $group->id] ?? null, + $generatedAt + ); $items[] = $item; $summary['groups_total']++; $summary[$item['mode']]++; @@ -66,7 +78,7 @@ final class CloudAdminTrafficPoolService 'lines' => self::lineCatalog(), 'summary' => $summary, 'sample_freshness_seconds' => self::SAMPLE_FRESHNESS_SECONDS, - 'generated_at' => time(), + 'generated_at' => $generatedAt, ]; } @@ -600,8 +612,11 @@ final class CloudAdminTrafficPoolService ]; } - private static function groupDto(CloudTrafficPoolGroup $group): array - { + private static function groupDto( + CloudTrafficPoolGroup $group, + ?array $accountingFreshness = null, + ?int $now = null + ): array { $lineRows = CloudNetworkLine::where( 'traffic_pool_group_id', (int) $group->id )->orderBy('id')->get(['id', 'region_id']); @@ -612,7 +627,7 @@ final class CloudAdminTrafficPoolService static fn ($id): int => (int) $id )->filter(static fn (int $id): bool => $id > 0) ->unique()->count(); - $readiness = self::buildReadiness($group, time()); + $readiness = self::buildReadiness($group, $now ?? time()); $nextMode = match ((string) $group->mode) { 'disabled' => 'shadow', 'shadow' => 'enforced', @@ -628,6 +643,11 @@ final class CloudAdminTrafficPoolService 'line_count' => count($lineIds), 'region_count' => $regionCount, 'readiness' => $readiness, + 'accounting_freshness' => $accountingFreshness + ?? CloudTrafficPoolFreshness::forGroup( + (int) $group->id, + (int) $readiness['checked_at'] + ), 'actions' => [ 'can_rename' => true, 'can_replace_lines' => (string) $group->mode === 'disabled', diff --git a/web/app/Services/Cloud/CloudTrafficPoolFreshness.php b/web/app/Services/Cloud/CloudTrafficPoolFreshness.php new file mode 100644 index 00000000..d5df1d28 --- /dev/null +++ b/web/app/Services/Cloud/CloudTrafficPoolFreshness.php @@ -0,0 +1,359 @@ + */ + public static function snapshot( + int $userId, + int $trafficPoolGroupId, + ?int $now = null + ): array { + $key = $userId . ':' . $trafficPoolGroupId; + return self::snapshots([[ + 'user_id' => $userId, + 'traffic_pool_group_id' => $trafficPoolGroupId, + ]], $now)[$key] ?? self::empty('projection_pending'); + } + + /** @return array> */ + public static function snapshots( + array $identities, + ?int $now = null, + ?array $accountingSnapshots = null + ): array { + $now ??= time(); + $pairs = []; + foreach ($identities as $identity) { + $userId = (int) ($identity['user_id'] ?? 0); + $groupId = (int) ($identity['traffic_pool_group_id'] ?? 0); + if ($userId > 0 && $groupId > 0) { + $pairs[$userId . ':' . $groupId] = [ + 'user_id' => $userId, + 'traffic_pool_group_id' => $groupId, + ]; + } + } + if ($pairs === []) { + return []; + } + $accountingSnapshots ??= CloudTrafficPoolAccounting::snapshots( + array_values($pairs), + $now + ); + $snapshotByKey = []; + $poolIds = []; + foreach ($pairs as $key => $pair) { + $snapshot = $accountingSnapshots[$key] ?? null; + if (!is_array($snapshot) + || ($snapshot['pool_id'] ?? null) === null) { + continue; + } + $snapshotByKey[$key] = $snapshot; + $poolIds[] = (int) $snapshot['pool_id']; + } + + $factsByKey = []; + if ($snapshotByKey !== []) { + $facts = CloudServicePeriod::query() + ->leftJoin('cloud_instances as freshness_instance', + 'freshness_instance.id', '=', + 'cloud_service_periods.instance_id') + ->leftJoin( + 'cloud_traffic_instance_cursors as freshness_cursor', + 'freshness_cursor.instance_id', '=', + 'cloud_service_periods.instance_id' + )->leftJoin( + 'cloud_traffic_scan_failures as freshness_period_failure', + static function ($join): void { + $join->on( + 'freshness_period_failure.subject_id', '=', + 'cloud_service_periods.id' + )->where( + 'freshness_period_failure.scan_kind', '=', 'period' + ); + } + )->leftJoin( + 'cloud_traffic_scan_failures as freshness_instance_failure', + static function ($join): void { + $join->on( + 'freshness_instance_failure.subject_id', '=', + 'cloud_service_periods.instance_id' + )->where( + 'freshness_instance_failure.scan_kind', '=', + 'instance' + ); + } + )->where(function ($query) use ($pairs): void { + foreach ($pairs as $pair) { + $query->orWhere(function ($branch) use ($pair): void { + $branch->where( + 'cloud_service_periods.user_id', + $pair['user_id'] + )->where( + 'cloud_service_periods.traffic_pool_group_id', + $pair['traffic_pool_group_id']); + }); + } + })->where('cloud_service_periods.traffic_quota_mode', 'finite') + ->whereIn('cloud_service_periods.status', + ['active', 'exhausted']) + ->where('cloud_service_periods.starts_at', '<=', $now) + ->where('cloud_service_periods.ends_at', '>', $now) + ->orderBy('cloud_service_periods.id')->get([ + 'cloud_service_periods.id as period_id', + 'cloud_service_periods.instance_id', + 'cloud_service_periods.user_id as period_user_id', + 'cloud_service_periods.traffic_pool_group_id as group_id', + 'freshness_instance.user_id as instance_user_id', + 'freshness_instance.lifetime_download_bytes', + 'freshness_instance.lifetime_upload_bytes', + 'freshness_instance.traffic_synced_at', + 'freshness_cursor.instance_id as cursor_instance_id', + 'freshness_cursor.user_id as cursor_user_id', + 'freshness_cursor.pool_id as cursor_pool_id', + 'freshness_cursor.accounted_download_bytes', + 'freshness_cursor.accounted_upload_bytes', + 'freshness_cursor.last_observed_at', + 'freshness_cursor.state as cursor_state', + 'freshness_period_failure.id as period_failure_id', + 'freshness_instance_failure.id as instance_failure_id', + ]); + foreach ($facts as $fact) { + $key = (int) $fact->period_user_id . ':' + . (int) $fact->group_id; + if (!isset($snapshotByKey[$key])) { + continue; + } + $factsByKey[$key][] = $fact; + } + } + $dueByPool = []; + if ($poolIds !== []) { + foreach (CloudTrafficUsageSettlementBucket::whereIn( + 'pool_id', $poolIds + )->where('state', 'open')->where('seal_at', '<=', $now) + ->selectRaw( + 'pool_id, COUNT(*) AS aggregate, MIN(seal_at) AS oldest' + )->groupBy('pool_id')->get() as $row) { + $dueByPool[(int) $row->pool_id] = [ + 'count' => (int) $row->aggregate, + 'oldest' => (int) $row->oldest, + ]; + } + } + + $result = []; + foreach ($pairs as $key => $pair) { + $snapshot = $snapshotByKey[$key] ?? null; + if ($snapshot === null) { + $result[$key] = self::empty('projection_pending'); + continue; + } + $status = 'current'; + $code = 'current'; + $unsettled = []; + $stale = []; + $confirmed = []; + if ((string) $snapshot['state'] === 'attention') { + $status = 'attention'; + $code = 'pool_attention'; + } + foreach ($factsByKey[$key] ?? [] as $fact) { + $instanceId = (int) $fact->instance_id; + if ($fact->cursor_instance_id === null + || (int) $fact->instance_user_id !== $pair['user_id'] + || (int) $fact->cursor_pool_id + !== (int) $snapshot['pool_id'] + || (int) $fact->cursor_user_id !== $pair['user_id']) { + $unsettled[$instanceId] = true; + $status = 'attention'; + $code = 'cursor_missing'; + continue; + } + if ((int) $fact->last_observed_at > 0) { + $confirmed[] = (int) $fact->last_observed_at; + } + if ((string) $fact->cursor_state === 'attention' + || (int) $fact->lifetime_download_bytes + < (int) $fact->accounted_download_bytes + || (int) $fact->lifetime_upload_bytes + < (int) $fact->accounted_upload_bytes) { + $unsettled[$instanceId] = true; + $status = 'attention'; + $code = 'cursor_attention'; + continue; + } + if ((int) $fact->lifetime_download_bytes + !== (int) $fact->accounted_download_bytes + || (int) $fact->lifetime_upload_bytes + !== (int) $fact->accounted_upload_bytes + || (int) $fact->traffic_synced_at + > (int) $fact->last_observed_at) { + $unsettled[$instanceId] = true; + if ($status !== 'attention') { + $status = 'delayed'; + $code = 'settlement_delayed'; + } + } + if ((int) $fact->traffic_synced_at + < $now - self::DELAY_SECONDS + || (int) $fact->last_observed_at + < $now - self::DELAY_SECONDS) { + $stale[$instanceId] = true; + if ($status !== 'attention') { + $status = 'delayed'; + $code = 'sample_stale'; + } + } + if ($fact->period_failure_id !== null + || $fact->instance_failure_id !== null) { + $status = 'attention'; + $code = 'accounting_failure'; + } + } + $due = $dueByPool[(int) $snapshot['pool_id']] ?? [ + 'count' => 0, + 'oldest' => $now, + ]; + $dueLag = $due['count'] > 0 + ? max(0, $now - (int) $due['oldest']) : 0; + if ($dueLag > self::ATTENTION_SECONDS) { + $status = 'attention'; + $code = 'settlement_overdue'; + } elseif ($dueLag > self::DELAY_SECONDS + && $status === 'current') { + $status = 'delayed'; + $code = 'settlement_delayed'; + } + $lastConfirmed = $confirmed === [] + ? ((($factsByKey[$key] ?? []) === []) + ? (($snapshot['last_observed_at'] ?? null) === null + ? null : (int) $snapshot['last_observed_at']) + : null) + : min($confirmed); + $result[$key] = [ + 'status' => $status, + 'last_confirmed_at' => $lastConfirmed, + 'unsettled_instance_count' => count($unsettled), + 'stale_cursor_count' => count($stale), + 'overdue_bucket_count' => (int) $due['count'], + 'safe_code' => $code, + ]; + } + return $result; + } + + /** @return array */ + public static function forGroup( + int $trafficPoolGroupId, + ?int $now = null + ): array { + return self::forGroups([$trafficPoolGroupId], $now)[ + $trafficPoolGroupId + ] ?? self::empty('no_pools') + ['pool_count' => 0]; + } + + /** @return array> */ + public static function forGroups( + array $trafficPoolGroupIds, + ?int $now = null + ): array { + $now ??= time(); + $groupIds = array_values(array_unique(array_filter(array_map( + 'intval', + $trafficPoolGroupIds + ), static fn (int $id): bool => $id > 0))); + if ($groupIds === []) { + return []; + } + $identities = CloudTrafficPool::whereIn( + 'traffic_pool_group_id', $groupIds + )->orderBy('id')->get(['user_id', 'traffic_pool_group_id'])->map( + static fn (CloudTrafficPool $pool): array => [ + 'user_id' => (int) $pool->user_id, + 'traffic_pool_group_id' => + (int) $pool->traffic_pool_group_id, + ] + )->all(); + $groupByKey = []; + foreach ($identities as $identity) { + $groupByKey[(int) $identity['user_id'] . ':' + . (int) $identity['traffic_pool_group_id']] = + (int) $identity['traffic_pool_group_id']; + } + $snapshots = self::snapshots($identities, $now); + $byGroup = []; + foreach ($snapshots as $key => $snapshot) { + $groupId = (int) ($groupByKey[$key] ?? 0); + if ($groupId > 0) { + $byGroup[$groupId][] = $snapshot; + } + } + $result = []; + foreach ($groupIds as $groupId) { + $result[$groupId] = self::aggregate( + $byGroup[$groupId] ?? [] + ); + } + return $result; + } + + /** @return array */ + private static function aggregate(array $snapshots): array + { + if ($snapshots === []) { + return self::empty('no_pools') + ['pool_count' => 0]; + } + $rank = ['current' => 0, 'delayed' => 1, 'attention' => 2]; + $status = 'current'; + $lastConfirmed = []; + $unsettled = 0; + $stale = 0; + $overdue = 0; + foreach ($snapshots as $snapshot) { + if ($rank[$snapshot['status']] > $rank[$status]) { + $status = $snapshot['status']; + } + if ($snapshot['last_confirmed_at'] !== null) { + $lastConfirmed[] = (int) $snapshot['last_confirmed_at']; + } + $unsettled += (int) $snapshot['unsettled_instance_count']; + $stale += (int) $snapshot['stale_cursor_count']; + $overdue += (int) $snapshot['overdue_bucket_count']; + } + return [ + 'status' => $status, + 'last_confirmed_at' => count($lastConfirmed) === count($snapshots) + ? min($lastConfirmed) : null, + 'unsettled_instance_count' => $unsettled, + 'stale_cursor_count' => $stale, + 'overdue_bucket_count' => $overdue, + 'safe_code' => $status === 'current' + ? 'current' : 'group_' . $status, + 'pool_count' => count($snapshots), + ]; + } + + /** @return array */ + private static function empty(string $code): array + { + return [ + 'status' => $code === 'no_pools' ? 'current' : 'delayed', + 'last_confirmed_at' => null, + 'unsettled_instance_count' => 0, + 'stale_cursor_count' => 0, + 'overdue_bucket_count' => 0, + 'safe_code' => $code, + ]; + } +} diff --git a/web/app/Services/Cloud/CloudTrafficPoolReadModel.php b/web/app/Services/Cloud/CloudTrafficPoolReadModel.php index 97ac5300..3e8554fd 100644 --- a/web/app/Services/Cloud/CloudTrafficPoolReadModel.php +++ b/web/app/Services/Cloud/CloudTrafficPoolReadModel.php @@ -87,6 +87,11 @@ final class CloudTrafficPoolReadModel 'traffic_pool_group_id' => $groupId, ], $visibleGroupIds); $snapshots = CloudTrafficPoolAccounting::snapshots($identities, $now); + $freshness = CloudTrafficPoolFreshness::snapshots( + $identities, + $now, + $snapshots + ); $entitlements = $currentPeriods === [] ? collect() : CloudTrafficEntitlement::whereIn( 'service_period_id', array_keys($currentPeriods) @@ -132,7 +137,9 @@ final class CloudTrafficPoolReadModel $instancesByGroup[$groupId] ?? [], $networkStates[$groupId] ?? 'clear', $snapshots[$userId . ':' . $groupId], - isset($pendingGroups[$groupId]) + isset($pendingGroups[$groupId]), + $freshness[$userId . ':' . $groupId] + ?? self::pendingFreshness() ); $items[] = $item; } @@ -211,6 +218,11 @@ final class CloudTrafficPoolReadModel array_values($identities), $now ); + $freshness = CloudTrafficPoolFreshness::snapshots( + array_values($identities), + $now, + $snapshots + ); $entitlements = $finite === [] ? collect() : CloudTrafficEntitlement::whereIn( 'service_period_id', array_keys($finite) @@ -255,7 +267,9 @@ final class CloudTrafficPoolReadModel (string) $snapshot['state'] === 'attention' ? 'attention' : 'clear', $snapshot, - isset($pendingByPool[$cacheKey]) + isset($pendingByPool[$cacheKey]), + $freshness[$cacheKey] + ?? self::pendingFreshness() ); } $results[$periodId] = [ @@ -275,7 +289,8 @@ final class CloudTrafficPoolReadModel array $instances, string $networkState, array $snapshot, - bool $forcePreparing = false + bool $forcePreparing, + array $freshness ): array { $projectionReady = !$forcePreparing && $snapshot['pool_id'] !== null; @@ -296,11 +311,37 @@ final class CloudTrafficPoolReadModel 'next_expiry_bytes' => (int) $snapshot['next_expiry_bytes'], 'last_observed_at' => $snapshot['last_observed_at'] === null ? null : (int) $snapshot['last_observed_at'], + 'accounting_freshness' => [ + 'status' => (string) ($freshness['status'] ?? 'delayed'), + 'last_confirmed_at' => + ($freshness['last_confirmed_at'] ?? null) === null + ? null : (int) $freshness['last_confirmed_at'], + 'unsettled_instance_count' => (int) ( + $freshness['unsettled_instance_count'] ?? 0 + ), + 'stale_cursor_count' => (int) ( + $freshness['stale_cursor_count'] ?? 0 + ), + 'safe_code' => (string) ( + $freshness['safe_code'] ?? 'projection_pending' + ), + ], 'network_restriction_state' => $networkState, 'instances' => array_values($instances), ]; } + private static function pendingFreshness(): array + { + return [ + 'status' => 'delayed', + 'last_confirmed_at' => null, + 'unsettled_instance_count' => 0, + 'stale_cursor_count' => 0, + 'safe_code' => 'projection_pending', + ]; + } + /** @return array>> */ private static function instancesByGroup( int $userId, diff --git a/web/tests/CloudAdminTrafficPoolServiceTest.php b/web/tests/CloudAdminTrafficPoolServiceTest.php index 56dfce6b..f23e5e68 100644 --- a/web/tests/CloudAdminTrafficPoolServiceTest.php +++ b/web/tests/CloudAdminTrafficPoolServiceTest.php @@ -66,6 +66,7 @@ $schema->create('cloud_orders', static function (Blueprint $t): void { }); $schema->create('cloud_instances', static function (Blueprint $t): void { $t->increments('id'); + $t->integer('user_id'); $t->integer('resource_pool_id')->nullable(); $t->string('status')->default('active'); $t->string('network_status')->default('active'); @@ -280,7 +281,9 @@ $created = CloudAdminTrafficPoolService::create([ ]); $groupId = (int) $created['item']['id']; $assert($created['item']['mode'] === 'disabled' - && $created['item']['revision'] === 1, + && $created['item']['revision'] === 1 + && $created['item']['accounting_freshness']['status'] === 'current' + && $created['item']['accounting_freshness']['safe_code'] === 'no_pools', 'A new traffic-pool group did not start disabled at revision one.'); $mapped = CloudAdminTrafficPoolService::replaceLines($groupId, [ @@ -499,6 +502,7 @@ Capsule::table('cloud_traffic_entitlements')->where('id', 25)->update([ Capsule::table('cloud_instances')->insert([ 'id' => 100, + 'user_id' => 50, 'resource_pool_id' => 3, 'status' => 'active', 'network_status' => 'active', @@ -599,6 +603,7 @@ $assert($ready['ready'] === true && $ready['blockers'] === [], 'A fully settled active projection did not pass readiness.'); Capsule::table('cloud_instances')->insert([ 'id' => 101, + 'user_id' => 50, 'resource_pool_id' => 3, 'status' => 'active', 'network_status' => 'active', @@ -654,7 +659,12 @@ $enforced = CloudAdminTrafficPoolService::update($groupId, [ 'expected_revision' => 3, ]); $assert($enforced['item']['mode'] === 'enforced' - && $enforced['item']['revision'] === 4, + && $enforced['item']['revision'] === 4 + && in_array( + $enforced['item']['accounting_freshness']['status'], + ['current', 'delayed', 'attention'], + true + ), 'A ready shadow group did not enter enforced mode.'); $expectConflict( static fn (): array => CloudAdminTrafficPoolService::update( diff --git a/web/tests/CloudAdminTrafficPoolUiContractTest.php b/web/tests/CloudAdminTrafficPoolUiContractTest.php index 89bf568a..6cae5c8e 100644 --- a/web/tests/CloudAdminTrafficPoolUiContractTest.php +++ b/web/tests/CloudAdminTrafficPoolUiContractTest.php @@ -20,6 +20,9 @@ $resourceService = $read( $trafficService = $read( $root . '/app/Services/Cloud/CloudAdminTrafficPoolService.php' ); +$freshnessService = $read( + $root . '/app/Services/Cloud/CloudTrafficPoolFreshness.php' +); $template = $read( $root . '/resources/views/venix/admin/cloud/resources.tpl' ); @@ -38,6 +41,10 @@ $assert(str_contains($resourceService, 'Traffic-pool administration must have a database-owned SSR first paint inside resources.'); $assert(str_contains($trafficService, 'private const BLOCKER_LABELS = [') + && str_contains($trafficService, 'CloudTrafficPoolFreshness::forGroups(') + && str_contains($trafficService, "'accounting_freshness' =>") + && str_contains($freshnessService, + 'public static function forGroups(') && str_contains($trafficService, "'label' => self::BLOCKER_LABELS[\$code]") && str_contains($template, '{$blocker.label|escape}') && str_contains($template, '{$blocker.code|escape}'), diff --git a/web/tests/CloudTrafficPoolFreshnessTest.php b/web/tests/CloudTrafficPoolFreshnessTest.php new file mode 100644 index 00000000..ac9b78a7 --- /dev/null +++ b/web/tests/CloudTrafficPoolFreshnessTest.php @@ -0,0 +1,168 @@ +addConnection([ + 'driver' => 'sqlite', 'database' => ':memory:', +], 'default'); +$capsule->setAsGlobal(); +$capsule->bootEloquent(); +$schema = $capsule->schema('default'); + +$schema->create('cloud_traffic_pools', static function (Blueprint $t): void { + $t->increments('id'); + $t->integer('user_id'); + $t->integer('traffic_pool_group_id'); + $t->string('state'); + $t->integer('available_bytes')->default(0); + $t->integer('overage_bytes')->default(0); + $t->integer('version')->default(1); + $t->integer('updated_at'); +}); +$schema->create('cloud_traffic_entitlements', + static function (Blueprint $t): void { + $t->increments('id'); + $t->integer('pool_id'); + $t->string('quota_mode'); + $t->string('state'); + $t->integer('starts_at'); + $t->integer('ends_at'); + $t->integer('granted_bytes'); + $t->integer('consumed_bytes'); + $t->integer('forfeited_bytes')->default(0); + }); +$schema->create('cloud_service_periods', static function (Blueprint $t): void { + $t->increments('id'); + $t->integer('instance_id'); + $t->integer('user_id'); + $t->integer('traffic_pool_group_id'); + $t->string('traffic_quota_mode'); + $t->string('status'); + $t->integer('starts_at'); + $t->integer('ends_at'); +}); +$schema->create('cloud_instances', static function (Blueprint $t): void { + $t->increments('id'); + $t->integer('user_id'); + $t->integer('lifetime_download_bytes'); + $t->integer('lifetime_upload_bytes'); + $t->integer('traffic_synced_at'); +}); +$schema->create('cloud_traffic_instance_cursors', + static function (Blueprint $t): void { + $t->integer('instance_id')->primary(); + $t->integer('user_id'); + $t->integer('pool_id'); + $t->integer('accounted_download_bytes'); + $t->integer('accounted_upload_bytes'); + $t->integer('last_observed_at'); + $t->string('state'); + }); +$schema->create('cloud_traffic_scan_failures', + static function (Blueprint $t): void { + $t->increments('id'); + $t->string('scan_kind'); + $t->integer('subject_id'); + }); +$schema->create('cloud_traffic_usage_settlement_buckets', + static function (Blueprint $t): void { + $t->increments('id'); + $t->integer('pool_id'); + $t->string('state'); + $t->integer('seal_at'); + }); + +$now = 2_000_000; +Capsule::table('cloud_traffic_pools')->insert([ + 'id' => 1, 'user_id' => 7, 'traffic_pool_group_id' => 3, + 'state' => 'available', 'updated_at' => $now - 60, +]); +Capsule::table('cloud_service_periods')->insert([ + 'id' => 10, 'instance_id' => 20, 'user_id' => 7, + 'traffic_pool_group_id' => 3, 'traffic_quota_mode' => 'finite', + 'status' => 'active', 'starts_at' => $now - 1000, + 'ends_at' => $now + 1000, +]); +Capsule::table('cloud_traffic_entitlements')->insert([ + 'id' => 30, 'pool_id' => 1, 'quota_mode' => 'finite', + 'state' => 'active', 'starts_at' => $now - 1000, + 'ends_at' => $now + 1000, 'granted_bytes' => 1000, + 'consumed_bytes' => 120, 'forfeited_bytes' => 0, +]); +Capsule::table('cloud_instances')->insert([ + 'id' => 20, 'user_id' => 7, 'lifetime_download_bytes' => 100, + 'lifetime_upload_bytes' => 20, 'traffic_synced_at' => $now - 60, +]); +Capsule::table('cloud_traffic_instance_cursors')->insert([ + 'instance_id' => 20, 'user_id' => 7, 'pool_id' => 1, + 'accounted_download_bytes' => 100, 'accounted_upload_bytes' => 20, + 'last_observed_at' => $now - 60, 'state' => 'ready', +]); + +$current = CloudTrafficPoolFreshness::snapshot(7, 3, $now); +$assert($current['status'] === 'current' + && $current['safe_code'] === 'current' + && $current['last_confirmed_at'] === $now - 60 + && $current['unsettled_instance_count'] === 0, + 'Fully accounted counters were not projected as current.'); + +Capsule::table('cloud_instances')->where('id', 20)->update([ + 'lifetime_download_bytes' => 130, + 'traffic_synced_at' => $now - 10, +]); +$delayed = CloudTrafficPoolFreshness::snapshot(7, 3, $now); +$assert($delayed['status'] === 'delayed' + && $delayed['safe_code'] === 'settlement_delayed' + && $delayed['unsettled_instance_count'] === 1 + && $delayed['last_confirmed_at'] === $now - 60, + 'Persisted but unsettled counters did not retain the last confirmation.'); + +Capsule::table('cloud_traffic_instance_cursors')->where('instance_id', 20) + ->update(['state' => 'attention']); +$attention = CloudTrafficPoolFreshness::snapshot(7, 3, $now); +$assert($attention['status'] === 'attention' + && $attention['safe_code'] === 'cursor_attention', + 'Attention cursor was presented as ordinary delay.'); + +Capsule::table('cloud_instances')->where('id', 20)->update([ + 'lifetime_download_bytes' => 100, + 'traffic_synced_at' => $now - 60, +]); +Capsule::table('cloud_traffic_instance_cursors')->where('instance_id', 20) + ->update(['state' => 'ready']); +Capsule::table('cloud_traffic_usage_settlement_buckets')->insert([ + 'pool_id' => 1, 'state' => 'open', 'seal_at' => $now - 400, +]); +$overdue = CloudTrafficPoolFreshness::snapshot(7, 3, $now); +$assert($overdue['status'] === 'delayed' + && $overdue['overdue_bucket_count'] === 1, + 'Five-minute settlement delay was hidden.'); +Capsule::table('cloud_traffic_usage_settlement_buckets')->where('pool_id', 1) + ->update(['seal_at' => $now - 4000]); +$overdueAttention = CloudTrafficPoolFreshness::snapshot(7, 3, $now); +$assert($overdueAttention['status'] === 'attention' + && $overdueAttention['safe_code'] === 'settlement_overdue', + 'One-hour settlement delay did not escalate to attention.'); + +$pending = CloudTrafficPoolFreshness::snapshot(9, 3, $now); +$assert($pending['status'] === 'delayed' + && $pending['safe_code'] === 'projection_pending' + && $pending['last_confirmed_at'] === null, + 'Missing projection fabricated current accounting.'); +$group = CloudTrafficPoolFreshness::forGroup(3, $now); +$assert($group['status'] === 'attention' + && $group['pool_count'] === 1 + && $group['overdue_bucket_count'] === 1, + 'Administrator group projection drifted from the user freshness model.'); + +echo "Traffic-pool freshness projection checks passed.\n"; diff --git a/web/tests/CloudTrafficPoolUserReadModelTest.php b/web/tests/CloudTrafficPoolUserReadModelTest.php index ca1d6999..d85a4aca 100644 --- a/web/tests/CloudTrafficPoolUserReadModelTest.php +++ b/web/tests/CloudTrafficPoolUserReadModelTest.php @@ -98,6 +98,9 @@ $schema->create('cloud_instances', static function (Blueprint $table): void { $table->integer('expires_at')->nullable(); $table->integer('traffic_download_bytes')->default(0); $table->integer('traffic_upload_bytes')->default(0); + $table->integer('lifetime_download_bytes')->default(0); + $table->integer('lifetime_upload_bytes')->default(0); + $table->integer('traffic_synced_at')->default(0); }); $schema->create('cloud_service_periods', static function (Blueprint $table): void { $table->increments('id'); @@ -142,6 +145,17 @@ $schema->create('cloud_traffic_instance_cursors', static function (Blueprint $ta $table->integer('version')->default(1); $table->integer('updated_at'); }); +$schema->create('cloud_traffic_scan_failures', static function (Blueprint $table): void { + $table->increments('id'); + $table->string('scan_kind'); + $table->integer('subject_id'); +}); +$schema->create('cloud_traffic_usage_settlement_buckets', static function (Blueprint $table): void { + $table->increments('id'); + $table->integer('pool_id'); + $table->string('state'); + $table->integer('seal_at'); +}); $schema->create('cloud_instance_network_restrictions', static function (Blueprint $table): void { $table->increments('id'); $table->integer('instance_id'); @@ -362,7 +376,7 @@ Capsule::connection('default')->enableQueryLog(); $payload = CloudTrafficPoolReadModel::forUser(1, $now); $userProjectionQueries = count(Capsule::connection('default')->getQueryLog()); Capsule::connection('default')->disableQueryLog(); -$assert($userProjectionQueries <= 13, +$assert($userProjectionQueries <= 15, 'The line-pool projection added a query loop per pool or instance: ' . $userProjectionQueries); $assert(array_keys($payload) === [ @@ -436,6 +450,14 @@ $assert($lineA['active_entitlement_bytes'] === 1500 && $lineA['next_expiry_bytes'] === 400 && $lineA['last_observed_at'] === $now - 5, 'User projection did not preserve the canonical FEFO snapshot.'); +$assert($lineA['accounting_freshness'] === [ + 'status' => 'delayed', + 'last_confirmed_at' => $now - 5, + 'unsettled_instance_count' => 0, + 'stale_cursor_count' => 1, + 'safe_code' => 'sample_stale', + ], + 'User projection did not expose the bounded actor-safe freshness state.'); $assert(count($lineA['instances']) === 1 && $lineA['instances'][0]['id'] === '1' && $lineA['instances'][0]['traffic_used_bytes'] === 150 @@ -469,7 +491,7 @@ Capsule::connection('default')->enableQueryLog(); $batch = CloudTrafficPoolReadModel::forPeriods($batchPeriods, $now); $batchQueries = count(Capsule::connection('default')->getQueryLog()); Capsule::connection('default')->disableQueryLog(); -$assert($batchQueries <= 5 && count($batch) === 4, +$assert($batchQueries <= 7 && count($batch) === 4, 'Multi-user period projection regressed to a query loop per pool.'); $pooled = CloudTrafficPoolReadModel::forPeriod( diff --git a/web/tests/CloudTrafficPoolUserUiContractTest.php b/web/tests/CloudTrafficPoolUserUiContractTest.php index 06a9515b..0c74de69 100644 --- a/web/tests/CloudTrafficPoolUserUiContractTest.php +++ b/web/tests/CloudTrafficPoolUserUiContractTest.php @@ -15,6 +15,7 @@ $assert = static function (bool $condition, string $message): void { }; $readModel = $read('app/Services/Cloud/CloudTrafficPoolReadModel.php'); +$freshness = $read('app/Services/Cloud/CloudTrafficPoolFreshness.php'); $pageService = $read('app/Services/Cloud/CloudInstancePageService.php'); $pageController = $read('app/Controllers/CloudPageController.php'); $apiController = $read('app/Controllers/CloudApiController.php'); @@ -35,6 +36,10 @@ $assert(str_contains($readModel, "->where('traffic_pool.user_id', \$userId)") && str_contains($readModel, "->where('mode', 'enforced')") && str_contains($readModel, 'CloudTrafficPoolAccounting::snapshots(') + && str_contains($readModel, 'CloudTrafficPoolFreshness::snapshots(') + && str_contains($readModel, "'accounting_freshness' => [") + && str_contains($freshness, 'public const DELAY_SECONDS = 300;') + && str_contains($freshness, 'public const ATTENTION_SECONDS = 3600;') && str_contains($readModel, "CloudInstance::where('user_id', \$userId)") && str_contains($readModel,