feat(traffic): expose pool accounting freshness

go
codex 21 hours ago
parent 9cc0f9dca9
commit adc3f7b2e5

@ -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',

@ -0,0 +1,359 @@
<?php
namespace App\Services\Cloud;
use App\Models\CloudServicePeriod;
use App\Models\CloudTrafficPool;
use App\Models\CloudTrafficUsageSettlementBucket;
/** Canonical accounting-freshness projection shared by user and admin views. */
final class CloudTrafficPoolFreshness
{
public const DELAY_SECONDS = 300;
public const ATTENTION_SECONDS = 3600;
/** @return array<string,int|string|null> */
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<string,array<string,int|string|null>> */
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<string,int|string|null> */
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<int,array<string,int|string|null>> */
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<string,int|string|null> */
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<string,int|string|null> */
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,
];
}
}

@ -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<int,list<array<string,mixed>>> */
private static function instancesByGroup(
int $userId,

@ -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(

@ -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}'),

@ -0,0 +1,168 @@
<?php
require dirname(__DIR__) . '/vendor/autoload.php';
use App\Services\Cloud\CloudTrafficPoolFreshness;
use Illuminate\Database\Capsule\Manager as Capsule;
use Illuminate\Database\Schema\Blueprint;
$assert = static function (bool $condition, string $message): void {
if (!$condition) {
throw new RuntimeException($message);
}
};
$capsule = new Capsule();
$capsule->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";

@ -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(

@ -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,

Loading…
Cancel
Save