feat(traffic): expose pool accounting freshness
parent
9cc0f9dca9
commit
adc3f7b2e5
@ -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,
|
||||
];
|
||||
}
|
||||
}
|
||||
@ -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";
|
||||
Loading…
Reference in New Issue