qwer-xyz
1691 lines
54 KiB
TypeScript
1691 lines
54 KiB
TypeScript
import 'dotenv/config'
|
|
|
|
// @ts-ignore - bcryptjs ships its own types in this repo setup
|
|
import bcrypt from 'bcryptjs'
|
|
|
|
import { prisma } from '../src/db/prisma.js'
|
|
|
|
type SeedRole = 'admin' | 'user'
|
|
type SeedUserStatus = 'active' | 'banned'
|
|
type SeedHostStatus = 'online' | 'offline' | 'maintenance'
|
|
type SeedHostInstanceType = 'container' | 'vm' | 'both'
|
|
type SeedPackageInstanceType = 'container' | 'vm'
|
|
type SeedNetworkMode = 'nat' | 'nat_ipv6' | 'nat_ipv6_nat' | 'ipv6_only' | 'ipv6_nat'
|
|
type SeedInstanceStatus = 'running' | 'stopped' | 'suspended' | 'error'
|
|
type SeedTrafficStatus = 'NORMAL' | 'WARNING' | 'LIMITED'
|
|
type SeedProtocol = 'tcp' | 'udp'
|
|
type SeedProxyStatus = 'pending' | 'active' | 'error'
|
|
type SeedBackupStatus = 'ready' | 'error'
|
|
type SeedTicketPriority = 'low' | 'normal' | 'high' | 'urgent'
|
|
type SeedTicketStatus = 'open' | 'in_progress' | 'resolved' | 'closed'
|
|
type SeedBalanceLogType = 'recharge' | 'consume' | 'gift' | 'admin_adjust'
|
|
type SeedNotificationChannelType = 'telegram' | 'discord' | 'email' | 'webhook'
|
|
type SeedAnnouncementType = 'system_broadcast' | 'host_broadcast' | 'admin_message' | 'host_message'
|
|
type SeedPaymentProviderType = 'yipay' | 'stripe' | 'alipay_direct' | 'wechat_direct' | 'manual'
|
|
type SeedRechargeStatus = 'pending' | 'paid' | 'completed' | 'failed' | 'cancelled' | 'refunded'
|
|
type SeedAffLogType = 'new_purchase' | 'renew' | 'convert'
|
|
type SeedAffWithdrawalStatus = 'pending' | 'approved' | 'rejected'
|
|
type SeedRedeemCodeType = 'c' | 'r' | 'd' | 't' | 'p'
|
|
|
|
type SeedQuota = {
|
|
hostLimit: number
|
|
packageLimit: number
|
|
monthlyTrafficLimit: bigint | null
|
|
}
|
|
|
|
type SeedUserSpec = {
|
|
username: string
|
|
email: string
|
|
role: SeedRole
|
|
status: SeedUserStatus
|
|
banReason: string | null
|
|
avatarStyle: string
|
|
quota: SeedQuota
|
|
}
|
|
|
|
type SeedHostSpec = {
|
|
ownerUsername: string
|
|
name: string
|
|
url: string
|
|
location: string
|
|
countryCode: string
|
|
architecture: 'x86_64' | 'aarch64'
|
|
status: SeedHostStatus
|
|
instanceType: SeedHostInstanceType
|
|
natPublicIp: string
|
|
natPublicIpv6: string
|
|
natBindIp: string
|
|
natBindIpv6: string
|
|
natPortStart: number
|
|
natPortEnd: number
|
|
ipAddress: string
|
|
ipv6Subnet: string
|
|
ipv6Gateway: string
|
|
tags: string[]
|
|
storageSize: number
|
|
cpuAllowanceMax: number
|
|
memoryMax: number
|
|
caddyEnabled: boolean
|
|
}
|
|
|
|
type SeedStoragePoolSpec = {
|
|
name: string
|
|
driver: string
|
|
purpose: 'instance_data' | 'instance_storage'
|
|
description: string
|
|
}
|
|
|
|
type SeedPlanSpec = {
|
|
name: string
|
|
description: string
|
|
cpu: number
|
|
memory: number
|
|
disk: number
|
|
portLimit: number
|
|
snapshotLimit: number
|
|
backupLimit: number
|
|
siteLimit: number
|
|
swapSize: number
|
|
trafficLimit: bigint
|
|
trafficLimitSpeed: string
|
|
price: number
|
|
billingCycle: number
|
|
setupFee: number
|
|
isActive: boolean
|
|
sortOrder: number
|
|
slaGuarantee: number | null
|
|
}
|
|
|
|
type SeedPackageSpec = {
|
|
key: string
|
|
ownerUsername: string
|
|
name: string
|
|
description: string
|
|
hostNames: string[]
|
|
cpuMax: number
|
|
memoryMax: number
|
|
diskMax: number
|
|
bandwidthMax: number
|
|
networkMode: SeedNetworkMode
|
|
instanceType: SeedPackageInstanceType
|
|
privileged: boolean
|
|
nested: boolean
|
|
active: boolean
|
|
portLimit: number
|
|
snapshotLimit: number
|
|
backupLimit: number
|
|
siteLimit: number
|
|
monthlyTrafficLimit: bigint
|
|
ioLimitMode: 'throughput' | 'iops'
|
|
limitsRead: string
|
|
limitsWrite: string
|
|
limitsReadIops: number
|
|
limitsWriteIops: number
|
|
limitsIngress: string
|
|
limitsEgress: string
|
|
limitsProcesses: number
|
|
limitsCpuPriority: number
|
|
bootAutostart: boolean
|
|
bootAutostartPriority: number
|
|
bootAutostartDelay: number
|
|
bootHostShutdownTimeout: number
|
|
globalShared: boolean
|
|
globalQuotaMultiplier: number | null
|
|
globalMaxInstances: number | null
|
|
allowInstanceDeletion: boolean
|
|
plans: SeedPlanSpec[]
|
|
}
|
|
|
|
type GeneratedPackageRecord = {
|
|
id: number
|
|
spec: SeedPackageSpec
|
|
planIdsByName: Map<string, number>
|
|
}
|
|
|
|
type SeedInstanceSpec = {
|
|
name: string
|
|
incusId: string
|
|
userUsername: string
|
|
packageKey: string
|
|
planName: string
|
|
hostName: string
|
|
image: string
|
|
status: SeedInstanceStatus
|
|
createdAt: Date
|
|
expiresAt: Date | null
|
|
suspendedAt: Date | null
|
|
suspendedBy: number | null
|
|
suspendReason: string | null
|
|
autoRenew: boolean
|
|
cloudInitState: string | null
|
|
cloudInitSource: string | null
|
|
ipv4: string | null
|
|
ipv6: string | null
|
|
sshPort: number | null
|
|
monthlyTrafficUsed: bigint
|
|
trafficStatus: SeedTrafficStatus
|
|
lastIpv6ReassignAt: Date | null
|
|
lastPlanChangeAt: Date | null
|
|
lastSyncedAt: Date
|
|
}
|
|
|
|
type SeedBalanceLogSpec = {
|
|
userId: number
|
|
type: SeedBalanceLogType
|
|
amount: number
|
|
balanceBefore: number
|
|
balanceAfter: number
|
|
orderId: string | null
|
|
remark: string
|
|
}
|
|
|
|
type GeneratedInstanceRecord = {
|
|
id: number
|
|
userId: number
|
|
hostId: number
|
|
packageId: number
|
|
packagePlanId: number
|
|
spec: SeedInstanceSpec
|
|
packageSpec: SeedPackageSpec
|
|
plan: SeedPlanSpec
|
|
}
|
|
|
|
type CreatedNotificationChannel = {
|
|
id: number
|
|
userId: number
|
|
type: SeedNotificationChannelType
|
|
}
|
|
|
|
type CreatedAffCode = {
|
|
id: number
|
|
userId: number
|
|
packagePlanId: number | null
|
|
code: string
|
|
}
|
|
|
|
const SEED_PREFIX = 'bulkseed'
|
|
const SEED_MARK = `[${SEED_PREFIX}]`
|
|
const SEED_CODE_PREFIX = SEED_PREFIX.toUpperCase()
|
|
const SHARED_PASSWORD = 'BulkSeed123!'
|
|
const LOCAL_PASSWORD_SALT = '$2a$10$1234567890123456789012'
|
|
const TODAY = new Date()
|
|
|
|
const avatarStyles = ['bigSmile', 'croodles', 'notionists', 'lorelei']
|
|
const countries = ['us', 'sg', 'jp', 'de', 'nl', 'au']
|
|
const cities = ['Los Angeles', 'Singapore', 'Tokyo', 'Frankfurt', 'Amsterdam', 'Sydney']
|
|
const containerImages = [
|
|
'images:ubuntu/24.04/cloud',
|
|
'images:debian/12/cloud',
|
|
'images:almalinux/9/cloud',
|
|
'images:rockylinux/9/cloud'
|
|
]
|
|
const vmImages = [
|
|
'images:ubuntu/24.04/cloud',
|
|
'images:debian/12/cloud',
|
|
'images:almalinux/9/cloud'
|
|
]
|
|
const redeemCodeTypes: SeedRedeemCodeType[] = ['c', 'r', 'd', 't', 'p']
|
|
|
|
const ownerUsers: SeedUserSpec[] = [
|
|
createOwnerUser(1, 'admin', 'admin', 24, 40),
|
|
createOwnerUser(2, 'apac', 'user', 18, 32),
|
|
createOwnerUser(3, 'eu', 'user', 18, 32),
|
|
createOwnerUser(4, 'us', 'user', 18, 32),
|
|
createOwnerUser(5, 'edge', 'user', 18, 32),
|
|
createOwnerUser(6, 'lab', 'user', 18, 32)
|
|
]
|
|
|
|
const customerUsers: SeedUserSpec[] = Array.from({ length: 30 }, (_, index) => {
|
|
const id = index + 1
|
|
const status: SeedUserStatus = id % 17 === 0 ? 'banned' : 'active'
|
|
return {
|
|
username: `${SEED_PREFIX}-user-${pad(id, 2)}`,
|
|
email: `${SEED_PREFIX}-user-${pad(id, 2)}@incudal.local`,
|
|
role: 'user',
|
|
status,
|
|
banReason: status === 'banned' ? `${SEED_MARK} banned sample user` : null,
|
|
avatarStyle: avatarStyles[index % avatarStyles.length],
|
|
quota: {
|
|
hostLimit: 0,
|
|
packageLimit: 0,
|
|
monthlyTrafficLimit: bytesFromGb(800)
|
|
}
|
|
}
|
|
})
|
|
|
|
const allSeedUsers = [...ownerUsers, ...customerUsers]
|
|
|
|
const hostSpecs: SeedHostSpec[] = [
|
|
createHostSpec(1, ownerUsers[0].username, 'official-us-west', 'Los Angeles, US', 'us', 'x86_64', 'both', 'online'),
|
|
createHostSpec(2, ownerUsers[0].username, 'official-eu-vm', 'Frankfurt, DE', 'de', 'x86_64', 'vm', 'online'),
|
|
createHostSpec(3, ownerUsers[1].username, 'apac-sg-edge', 'Singapore, SG', 'sg', 'x86_64', 'both', 'online'),
|
|
createHostSpec(4, ownerUsers[1].username, 'apac-tokyo-arm', 'Tokyo, JP', 'jp', 'aarch64', 'container', 'online'),
|
|
createHostSpec(5, ownerUsers[2].username, 'eu-amsterdam', 'Amsterdam, NL', 'nl', 'x86_64', 'both', 'online'),
|
|
createHostSpec(6, ownerUsers[2].username, 'eu-madrid-vm', 'Madrid, ES', 'us', 'x86_64', 'vm', 'online'),
|
|
createHostSpec(7, ownerUsers[3].username, 'us-ashburn', 'Ashburn, US', 'us', 'x86_64', 'both', 'online'),
|
|
createHostSpec(8, ownerUsers[3].username, 'us-dallas-container', 'Dallas, US', 'us', 'x86_64', 'container', 'online'),
|
|
createHostSpec(9, ownerUsers[4].username, 'edge-seoul', 'Seoul, KR', 'jp', 'aarch64', 'container', 'online'),
|
|
createHostSpec(10, ownerUsers[4].username, 'edge-sydney', 'Sydney, AU', 'au', 'x86_64', 'both', 'online'),
|
|
createHostSpec(11, ownerUsers[5].username, 'lab-london', 'London, GB', 'de', 'x86_64', 'both', 'online'),
|
|
createHostSpec(12, ownerUsers[5].username, 'lab-warsaw-vm', 'Warsaw, PL', 'nl', 'x86_64', 'vm', 'online')
|
|
]
|
|
|
|
const storagePools: SeedStoragePoolSpec[] = [
|
|
{
|
|
name: 'default',
|
|
driver: 'zfs',
|
|
purpose: 'instance_data',
|
|
description: `${SEED_MARK} default pool`
|
|
},
|
|
{
|
|
name: 'archive',
|
|
driver: 'dir',
|
|
purpose: 'instance_storage',
|
|
description: `${SEED_MARK} archive pool`
|
|
}
|
|
]
|
|
|
|
const packageSpecs = buildPackageSpecs()
|
|
const instanceSpecs = buildInstanceSpecs(packageSpecs)
|
|
|
|
function createOwnerUser(index: number, slug: string, role: SeedRole, hostLimit: number, packageLimit: number): SeedUserSpec {
|
|
return {
|
|
username: `${SEED_PREFIX}-owner-${slug}`,
|
|
email: `${SEED_PREFIX}-owner-${slug}@incudal.local`,
|
|
role,
|
|
status: 'active',
|
|
banReason: null,
|
|
avatarStyle: avatarStyles[(index - 1) % avatarStyles.length],
|
|
quota: {
|
|
hostLimit,
|
|
packageLimit,
|
|
monthlyTrafficLimit: bytesFromGb(3000)
|
|
}
|
|
}
|
|
}
|
|
|
|
function createHostSpec(
|
|
index: number,
|
|
ownerUsername: string,
|
|
slug: string,
|
|
location: string,
|
|
countryCode: string,
|
|
architecture: 'x86_64' | 'aarch64',
|
|
instanceType: SeedHostInstanceType,
|
|
status: SeedHostStatus
|
|
): SeedHostSpec {
|
|
const natBase = 40 + index
|
|
const hex = (0x40 + index).toString(16)
|
|
return {
|
|
ownerUsername,
|
|
name: `${SEED_PREFIX}-host-${pad(index, 2)}-${slug}`,
|
|
url: `https://${SEED_PREFIX}-host-${pad(index, 2)}-${slug}.local`,
|
|
location,
|
|
countryCode,
|
|
architecture,
|
|
status,
|
|
instanceType,
|
|
natPublicIp: `198.51.100.${natBase}`,
|
|
natPublicIpv6: `2001:db8:feed:${hex}::${index}`,
|
|
natBindIp: `10.255.${index}.10`,
|
|
natBindIpv6: `fd00:255:${hex}::10`,
|
|
natPortStart: 20000 + (index - 1) * 400,
|
|
natPortEnd: 20000 + (index - 1) * 400 + 399,
|
|
ipAddress: `10.20.${index}.10`,
|
|
ipv6Subnet: `2001:db8:${hex}::/64`,
|
|
ipv6Gateway: `2001:db8:${hex}::1`,
|
|
tags: [SEED_PREFIX, slug, architecture, instanceType],
|
|
storageSize: 200 + index * 15,
|
|
cpuAllowanceMax: 2200 + index * 180,
|
|
memoryMax: 65536 + index * 4096,
|
|
caddyEnabled: index % 2 === 0
|
|
}
|
|
}
|
|
|
|
function bytesFromGb(gb: number): bigint {
|
|
return BigInt(gb) * 1024n * 1024n * 1024n
|
|
}
|
|
|
|
function pad(value: number, digits: number): string {
|
|
return String(value).padStart(digits, '0')
|
|
}
|
|
|
|
function daysAgo(days: number, hour = 10): Date {
|
|
const date = new Date(TODAY)
|
|
date.setUTCDate(date.getUTCDate() - days)
|
|
date.setUTCHours(hour, 0, 0, 0)
|
|
return date
|
|
}
|
|
|
|
function daysFromNow(days: number, hour = 10): Date {
|
|
const date = new Date(TODAY)
|
|
date.setUTCDate(date.getUTCDate() + days)
|
|
date.setUTCHours(hour, 0, 0, 0)
|
|
return date
|
|
}
|
|
|
|
function addMonths(input: Date, months: number): Date {
|
|
const output = new Date(input)
|
|
output.setUTCMonth(output.getUTCMonth() + months)
|
|
return output
|
|
}
|
|
|
|
function roundToStep(value: number, step: number): number {
|
|
return Math.max(step, Math.round(value / step) * step)
|
|
}
|
|
|
|
function getBaseRechargeAmount(user: SeedUserSpec, index: number, spend: number): number {
|
|
return Math.max(
|
|
user.role === 'admin' ? 30000 + index * 500 : 9000 + index * 120,
|
|
spend + 2000 + index * 50
|
|
)
|
|
}
|
|
|
|
function getGiftAmount(user: SeedUserSpec, index: number): number {
|
|
return user.role === 'admin' ? 1500 : 300 + index * 10
|
|
}
|
|
|
|
function getSeedOrderNo(index: number): string {
|
|
return `${SEED_PREFIX}-recharge-${pad(index + 1, 3)}`
|
|
}
|
|
|
|
function buildDemoPublicKey(username: string, index: number): string {
|
|
const body = Buffer.from(`${SEED_PREFIX}:${username}:${index}`).toString('base64')
|
|
return `ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI${body.slice(0, 40)} ${username}@seed.local`
|
|
}
|
|
|
|
function buildDemoFingerprint(username: string, index: number): string {
|
|
const body = Buffer.from(`${username}:${index}:${SEED_PREFIX}`).toString('base64')
|
|
return `SHA256:${body.slice(0, 32)}`
|
|
}
|
|
|
|
function getOwnerHosts(ownerUsername: string): SeedHostSpec[] {
|
|
return hostSpecs.filter(host => host.ownerUsername === ownerUsername)
|
|
}
|
|
|
|
function buildPackageSpecs(): SeedPackageSpec[] {
|
|
const thirdModes: SeedNetworkMode[] = ['nat_ipv6_nat', 'ipv6_only', 'ipv6_nat']
|
|
const packageList: SeedPackageSpec[] = []
|
|
|
|
ownerUsers.forEach((owner, ownerIndex) => {
|
|
const hosts = getOwnerHosts(owner.username)
|
|
const containerHosts = hosts.filter(host => host.instanceType !== 'vm')
|
|
const vmHosts = hosts.filter(host => host.instanceType !== 'container')
|
|
const cpuBase = 220 + ownerIndex * 20
|
|
const memoryBase = 8192 + ownerIndex * 1024
|
|
const diskBase = 102400 + ownerIndex * 10240
|
|
const thirdMode = thirdModes[ownerIndex % thirdModes.length]
|
|
|
|
packageList.push(
|
|
createPackageSpec({
|
|
index: packageList.length + 1,
|
|
ownerUsername: owner.username,
|
|
suffix: 'nat-box',
|
|
title: `NAT Box ${ownerIndex + 1}`,
|
|
description: `${SEED_MARK} public IPv4 NAT container package`,
|
|
hostNames: uniqueNames(containerHosts.map(host => host.name)),
|
|
networkMode: 'nat',
|
|
instanceType: 'container',
|
|
cpuMax: cpuBase,
|
|
memoryMax: memoryBase,
|
|
diskMax: diskBase,
|
|
bandwidthMax: 1200 + ownerIndex * 120,
|
|
globalShared: true,
|
|
portLimit: 24,
|
|
snapshotLimit: 5,
|
|
backupLimit: 3,
|
|
siteLimit: 4,
|
|
monthlyTrafficLimit: bytesFromGb(480 + ownerIndex * 40),
|
|
ioLimitMode: ownerIndex % 2 === 0 ? 'throughput' : 'iops',
|
|
globalQuotaMultiplier: 1.5
|
|
}),
|
|
createPackageSpec({
|
|
index: packageList.length + 2,
|
|
ownerUsername: owner.username,
|
|
suffix: 'dual-stack',
|
|
title: `Dual Stack ${ownerIndex + 1}`,
|
|
description: `${SEED_MARK} IPv4 NAT + routed IPv6 package`,
|
|
hostNames: uniqueNames(containerHosts.map(host => host.name)),
|
|
networkMode: 'nat_ipv6',
|
|
instanceType: 'container',
|
|
cpuMax: cpuBase + 30,
|
|
memoryMax: memoryBase + 1024,
|
|
diskMax: diskBase + 10240,
|
|
bandwidthMax: 1400 + ownerIndex * 120,
|
|
globalShared: ownerIndex % 2 === 0,
|
|
portLimit: 28,
|
|
snapshotLimit: 6,
|
|
backupLimit: 3,
|
|
siteLimit: 5,
|
|
monthlyTrafficLimit: bytesFromGb(560 + ownerIndex * 40),
|
|
ioLimitMode: 'throughput',
|
|
globalQuotaMultiplier: 1.8
|
|
}),
|
|
createPackageSpec({
|
|
index: packageList.length + 3,
|
|
ownerUsername: owner.username,
|
|
suffix: `ipv6-${thirdMode}`,
|
|
title: `IPv6 Mix ${ownerIndex + 1}`,
|
|
description: `${SEED_MARK} IPv6-heavy container package`,
|
|
hostNames: uniqueNames(containerHosts.map(host => host.name)),
|
|
networkMode: thirdMode,
|
|
instanceType: 'container',
|
|
cpuMax: cpuBase + 10,
|
|
memoryMax: memoryBase + 512,
|
|
diskMax: diskBase,
|
|
bandwidthMax: 1000 + ownerIndex * 100,
|
|
globalShared: true,
|
|
portLimit: thirdMode === 'ipv6_only' ? 0 : 18,
|
|
snapshotLimit: 4,
|
|
backupLimit: 2,
|
|
siteLimit: 4,
|
|
monthlyTrafficLimit: bytesFromGb(360 + ownerIndex * 30),
|
|
ioLimitMode: 'throughput',
|
|
globalQuotaMultiplier: 1.2
|
|
}),
|
|
createPackageSpec({
|
|
index: packageList.length + 4,
|
|
ownerUsername: owner.username,
|
|
suffix: 'vm-flex',
|
|
title: `VM Flex ${ownerIndex + 1}`,
|
|
description: `${SEED_MARK} KVM package for billing and lifecycle screens`,
|
|
hostNames: uniqueNames(vmHosts.map(host => host.name)),
|
|
networkMode: ownerIndex % 2 === 0 ? 'nat_ipv6' : 'nat',
|
|
instanceType: 'vm',
|
|
cpuMax: 300 + ownerIndex * 30,
|
|
memoryMax: 12288 + ownerIndex * 1024,
|
|
diskMax: 153600 + ownerIndex * 10240,
|
|
bandwidthMax: 1800 + ownerIndex * 100,
|
|
globalShared: ownerIndex % 3 !== 0,
|
|
portLimit: 10,
|
|
snapshotLimit: 4,
|
|
backupLimit: 3,
|
|
siteLimit: 1,
|
|
monthlyTrafficLimit: bytesFromGb(700 + ownerIndex * 50),
|
|
ioLimitMode: 'iops',
|
|
globalQuotaMultiplier: 1.0
|
|
})
|
|
)
|
|
})
|
|
|
|
return packageList
|
|
}
|
|
|
|
function createPackageSpec(input: {
|
|
index: number
|
|
ownerUsername: string
|
|
suffix: string
|
|
title: string
|
|
description: string
|
|
hostNames: string[]
|
|
networkMode: SeedNetworkMode
|
|
instanceType: SeedPackageInstanceType
|
|
cpuMax: number
|
|
memoryMax: number
|
|
diskMax: number
|
|
bandwidthMax: number
|
|
globalShared: boolean
|
|
portLimit: number
|
|
snapshotLimit: number
|
|
backupLimit: number
|
|
siteLimit: number
|
|
monthlyTrafficLimit: bigint
|
|
ioLimitMode: 'throughput' | 'iops'
|
|
globalQuotaMultiplier: number | null
|
|
}): SeedPackageSpec {
|
|
const isVm = input.instanceType === 'vm'
|
|
const key = `${SEED_PREFIX}-pkg-${pad(input.index, 2)}`
|
|
const planNames = isVm ? ['Starter', 'Business', 'Scale'] : ['Nano', 'Plus', 'Prime']
|
|
const planScales = isVm ? [0.28, 0.46, 0.68] : [0.18, 0.36, 0.58]
|
|
|
|
const plans = planNames.map((planName, index) => {
|
|
const scale = planScales[index]
|
|
const baseCpu = roundToStep(input.cpuMax * scale, isVm ? 20 : 5)
|
|
const baseMemory = roundToStep(input.memoryMax * scale, 256)
|
|
const baseDisk = roundToStep(input.diskMax * scale, 1024)
|
|
return {
|
|
name: planName,
|
|
description: `${SEED_MARK} ${planName} plan for ${input.title}`,
|
|
cpu: baseCpu,
|
|
memory: baseMemory,
|
|
disk: baseDisk,
|
|
portLimit: input.networkMode === 'ipv6_only' ? 0 : Math.max(0, Math.min(input.portLimit, 6 + index * (isVm ? 2 : 6))),
|
|
snapshotLimit: Math.min(input.snapshotLimit, 2 + index),
|
|
backupLimit: Math.min(input.backupLimit, 1 + Math.floor(index / 1)),
|
|
siteLimit: isVm ? Math.min(input.siteLimit, index === 2 ? 1 : 0) : Math.min(input.siteLimit, 1 + index * 2),
|
|
swapSize: isVm ? 0 : index === 0 ? 0 : index * 512,
|
|
trafficLimit: bytesFromGb((isVm ? 180 : 90) + index * (isVm ? 160 : 80) + input.index * 5),
|
|
trafficLimitSpeed: ['2Mbit', '5Mbit', '10Mbit'][index],
|
|
price: (isVm ? 2990 : 890) + input.index * (isVm ? 60 : 25) + index * (isVm ? 1800 : 900),
|
|
billingCycle: index === 2 && isVm ? 3 : 1,
|
|
setupFee: isVm ? index * 300 : 0,
|
|
isActive: true,
|
|
sortOrder: (index + 1) * 10,
|
|
slaGuarantee: [99.5, 99.9, 99.95][index]
|
|
}
|
|
})
|
|
|
|
return {
|
|
key,
|
|
ownerUsername: input.ownerUsername,
|
|
name: `${key}-${input.suffix}`,
|
|
description: input.description,
|
|
hostNames: input.hostNames,
|
|
networkMode: input.networkMode,
|
|
instanceType: input.instanceType,
|
|
cpuMax: input.cpuMax,
|
|
memoryMax: input.memoryMax,
|
|
diskMax: input.diskMax,
|
|
bandwidthMax: input.bandwidthMax,
|
|
privileged: !isVm,
|
|
nested: !isVm,
|
|
active: true,
|
|
portLimit: input.portLimit,
|
|
snapshotLimit: input.snapshotLimit,
|
|
backupLimit: input.backupLimit,
|
|
siteLimit: input.siteLimit,
|
|
monthlyTrafficLimit: input.monthlyTrafficLimit,
|
|
ioLimitMode: input.ioLimitMode,
|
|
limitsRead: isVm ? '350MB' : '220MB',
|
|
limitsWrite: isVm ? '350MB' : '220MB',
|
|
limitsReadIops: isVm ? 2200 : 1100,
|
|
limitsWriteIops: isVm ? 2200 : 1100,
|
|
limitsIngress: isVm ? '1Gbit' : '600Mbit',
|
|
limitsEgress: isVm ? '1Gbit' : '600Mbit',
|
|
limitsProcesses: isVm ? 800 : 1200,
|
|
limitsCpuPriority: isVm ? 8 : 10,
|
|
bootAutostart: true,
|
|
bootAutostartPriority: 10 + (input.index % 10),
|
|
bootAutostartDelay: 10 + (input.index % 5) * 5,
|
|
bootHostShutdownTimeout: isVm ? 60 : 45,
|
|
globalShared: input.globalShared,
|
|
globalQuotaMultiplier: input.globalQuotaMultiplier,
|
|
globalMaxInstances: 12,
|
|
allowInstanceDeletion: true,
|
|
plans
|
|
}
|
|
}
|
|
|
|
function uniqueNames(values: string[]): string[] {
|
|
return Array.from(new Set(values))
|
|
}
|
|
|
|
function buildInstanceSpecs(packages: SeedPackageSpec[]): SeedInstanceSpec[] {
|
|
return Array.from({ length: 64 }, (_, index) => {
|
|
const id = index + 1
|
|
const packageSpec = packages[index % packages.length]
|
|
const planName = packageSpec.plans[index % packageSpec.plans.length].name
|
|
const hostName = packageSpec.hostNames[index % packageSpec.hostNames.length]
|
|
const status = pickInstanceStatus(index)
|
|
const createdAt = daysAgo(4 + (index % 120), 8 + (index % 6))
|
|
const expiresAt = status === 'suspended' ? daysAgo(1 + (index % 4), 9) : daysFromNow(20 + (index % 90), 9)
|
|
const ipv4 = ['nat', 'nat_ipv6', 'nat_ipv6_nat'].includes(packageSpec.networkMode)
|
|
? `10.${60 + (index % 20)}.${1 + Math.floor(index / 20)}.${20 + (index % 180)}`
|
|
: null
|
|
const routedIpv6 = packageSpec.networkMode === 'nat_ipv6' || packageSpec.networkMode === 'ipv6_only'
|
|
? `2001:db8:${(0x900 + index).toString(16)}::${100 + id}`
|
|
: null
|
|
const sharedIpv6 = packageSpec.networkMode === 'nat_ipv6_nat' || packageSpec.networkMode === 'ipv6_nat'
|
|
? `2001:db8:share::${id}`
|
|
: null
|
|
const primaryIpv6 = routedIpv6 ?? sharedIpv6
|
|
const firstPublicPort = packageSpec.networkMode === 'ipv6_only' ? null : 21000 + index * 6
|
|
const trafficStatus: SeedTrafficStatus = index % 11 === 0 ? 'LIMITED' : index % 7 === 0 ? 'WARNING' : 'NORMAL'
|
|
const monthlyTrafficUsed = trafficStatus === 'LIMITED'
|
|
? bytesFromGb(240 + index * 3)
|
|
: trafficStatus === 'WARNING'
|
|
? bytesFromGb(180 + index * 2)
|
|
: bytesFromGb(70 + index * 2)
|
|
|
|
return {
|
|
name: `${SEED_PREFIX}-inst-${pad(id, 3)}`,
|
|
incusId: `${SEED_PREFIX}-incus-${pad(id, 3)}`,
|
|
userUsername: customerUsers[(index * 7) % customerUsers.length].username,
|
|
packageKey: packageSpec.key,
|
|
planName,
|
|
hostName,
|
|
image: packageSpec.instanceType === 'vm'
|
|
? vmImages[index % vmImages.length]
|
|
: containerImages[index % containerImages.length],
|
|
status,
|
|
createdAt,
|
|
expiresAt,
|
|
suspendedAt: status === 'suspended' ? daysAgo(index % 4, 9) : null,
|
|
suspendedBy: status === 'suspended' && index % 2 === 0 ? 1 : null,
|
|
suspendReason: status === 'suspended' ? `${SEED_MARK} expired sample` : null,
|
|
autoRenew: index % 3 !== 0,
|
|
cloudInitState: status === 'error' ? 'error' : 'done',
|
|
cloudInitSource: packageSpec.instanceType === 'vm' ? 'cloud-init' : 'lxd-agent',
|
|
ipv4,
|
|
ipv6: primaryIpv6,
|
|
sshPort: firstPublicPort ?? 22,
|
|
monthlyTrafficUsed,
|
|
trafficStatus,
|
|
lastIpv6ReassignAt: packageSpec.networkMode === 'nat_ipv6' && index % 5 === 0 ? daysAgo(index % 3, 7) : null,
|
|
lastPlanChangeAt: index % 6 === 0 ? daysAgo(2 + (index % 9), 11) : null,
|
|
lastSyncedAt: daysAgo(index % 5, 14)
|
|
}
|
|
})
|
|
}
|
|
|
|
function pickInstanceStatus(index: number): SeedInstanceStatus {
|
|
const mod = index % 20
|
|
if (mod === 17) return 'error'
|
|
if (mod === 18) return 'suspended'
|
|
if (mod === 19 || mod === 14 || mod === 15) return 'stopped'
|
|
return 'running'
|
|
}
|
|
|
|
async function ensureLocalDevGuard(): Promise<void> {
|
|
const databaseUrl = process.env.DATABASE_URL || ''
|
|
const isDevDb = databaseUrl.includes('incudal_dev_password@db:5432/incudal')
|
|
if (!isDevDb && process.env.FORCE_BULK_SEED !== '1') {
|
|
throw new Error(
|
|
`Refusing to run ${SEED_PREFIX} seed outside the local dev database. Set FORCE_BULK_SEED=1 to override.`
|
|
)
|
|
}
|
|
}
|
|
|
|
async function buildPasswordHash(password: string): Promise<string> {
|
|
return bcrypt.hash(password, LOCAL_PASSWORD_SALT)
|
|
}
|
|
|
|
async function syncUsers(passwordHash: string): Promise<Map<string, number>> {
|
|
const userIds = new Map<string, number>()
|
|
|
|
for (const [index, user] of allSeedUsers.entries()) {
|
|
const saved = await prisma.user.upsert({
|
|
where: { username: user.username },
|
|
create: {
|
|
username: user.username,
|
|
email: user.email,
|
|
passwordHash,
|
|
role: user.role,
|
|
status: user.status,
|
|
banReason: user.banReason,
|
|
balance: 0,
|
|
avatarStyle: user.avatarStyle
|
|
},
|
|
update: {
|
|
email: user.email,
|
|
passwordHash,
|
|
role: user.role,
|
|
status: user.status,
|
|
banReason: user.banReason,
|
|
avatarStyle: user.avatarStyle
|
|
}
|
|
})
|
|
|
|
await prisma.userQuota.upsert({
|
|
where: { userId: saved.id },
|
|
create: {
|
|
userId: saved.id,
|
|
hostLimit: user.quota.hostLimit,
|
|
packageLimit: user.quota.packageLimit,
|
|
monthlyTrafficLimit: user.quota.monthlyTrafficLimit
|
|
},
|
|
update: {
|
|
hostLimit: user.quota.hostLimit,
|
|
packageLimit: user.quota.packageLimit,
|
|
monthlyTrafficLimit: user.quota.monthlyTrafficLimit
|
|
}
|
|
})
|
|
|
|
userIds.set(user.username, saved.id)
|
|
}
|
|
|
|
const seedUserIds = Array.from(userIds.values())
|
|
await prisma.loginRecord.deleteMany({
|
|
where: {
|
|
userId: { in: seedUserIds },
|
|
userAgent: { startsWith: `${SEED_PREFIX}/` }
|
|
}
|
|
})
|
|
|
|
for (const [index, user] of allSeedUsers.entries()) {
|
|
const userId = userIds.get(user.username)!
|
|
const firstCountry = countries[index % countries.length]
|
|
const secondCountry = countries[(index + 2) % countries.length]
|
|
await prisma.loginRecord.createMany({
|
|
data: [
|
|
{
|
|
userId,
|
|
ip: `172.19.${10 + (index % 20)}.${20 + (index % 180)}`,
|
|
country: firstCountry.toUpperCase(),
|
|
region: cities[index % cities.length],
|
|
city: cities[index % cities.length],
|
|
isp: 'BulkSeedNet',
|
|
timezone: 'Asia/Shanghai',
|
|
userAgent: `${SEED_PREFIX}/web-chrome`
|
|
},
|
|
{
|
|
userId,
|
|
ip: `172.20.${10 + (index % 20)}.${40 + (index % 180)}`,
|
|
country: secondCountry.toUpperCase(),
|
|
region: cities[(index + 1) % cities.length],
|
|
city: cities[(index + 1) % cities.length],
|
|
isp: 'BulkSeedMobile',
|
|
timezone: 'Asia/Shanghai',
|
|
userAgent: `${SEED_PREFIX}/mobile-safari`
|
|
}
|
|
]
|
|
})
|
|
}
|
|
|
|
return userIds
|
|
}
|
|
|
|
async function syncHosts(userIds: Map<string, number>): Promise<Map<string, number>> {
|
|
const hostIds = new Map<string, number>()
|
|
|
|
for (const host of hostSpecs) {
|
|
const userId = userIds.get(host.ownerUsername)
|
|
if (!userId) {
|
|
throw new Error(`Missing owner for host ${host.name}`)
|
|
}
|
|
|
|
const saved = await prisma.host.upsert({
|
|
where: {
|
|
userId_name: {
|
|
userId,
|
|
name: host.name
|
|
}
|
|
},
|
|
create: {
|
|
userId,
|
|
name: host.name,
|
|
url: host.url,
|
|
location: host.location,
|
|
countryCode: host.countryCode,
|
|
architecture: host.architecture,
|
|
status: host.status,
|
|
natPublicIp: host.natPublicIp,
|
|
natPublicIpv6: host.natPublicIpv6,
|
|
natBindIp: host.natBindIp,
|
|
natBindIpv6: host.natBindIpv6,
|
|
natPortStart: host.natPortStart,
|
|
natPortEnd: host.natPortEnd,
|
|
tags: host.tags,
|
|
cpuAllowanceMax: host.cpuAllowanceMax,
|
|
memoryMax: host.memoryMax,
|
|
instanceType: host.instanceType,
|
|
ipAddress: host.ipAddress,
|
|
storageDriver: 'zfs',
|
|
storageType: 'loop',
|
|
storageSize: host.storageSize,
|
|
ipv6Mode: 1,
|
|
ipv6Subnet: host.ipv6Subnet,
|
|
ipv6Gateway: host.ipv6Gateway,
|
|
ipv6ParentInterface: 'eth0',
|
|
enableApi: true,
|
|
isInstalled: true,
|
|
caddyEnabled: host.caddyEnabled,
|
|
caddyUsername: host.caddyEnabled ? `${SEED_PREFIX}-caddy` : null,
|
|
caddyPassword: host.caddyEnabled ? `${SEED_PREFIX}-password` : null,
|
|
caddyPort: 8444 + (host.natPortStart % 10),
|
|
transferEnabled: true,
|
|
trafficResetDay: 1 + (host.natPortStart % 20),
|
|
announcement: `${SEED_MARK} ${host.location} demo host`,
|
|
notifyPurchase: true,
|
|
notifyRenew: true,
|
|
notifyDestroy: host.instanceType === 'vm',
|
|
enableResourcePool: true,
|
|
probeUrl: `https://${host.name}.probe.local/health`
|
|
},
|
|
update: {
|
|
url: host.url,
|
|
location: host.location,
|
|
countryCode: host.countryCode,
|
|
architecture: host.architecture,
|
|
status: host.status,
|
|
natPublicIp: host.natPublicIp,
|
|
natPublicIpv6: host.natPublicIpv6,
|
|
natBindIp: host.natBindIp,
|
|
natBindIpv6: host.natBindIpv6,
|
|
natPortStart: host.natPortStart,
|
|
natPortEnd: host.natPortEnd,
|
|
tags: host.tags,
|
|
cpuAllowanceMax: host.cpuAllowanceMax,
|
|
memoryMax: host.memoryMax,
|
|
instanceType: host.instanceType,
|
|
ipAddress: host.ipAddress,
|
|
storageDriver: 'zfs',
|
|
storageType: 'loop',
|
|
storageSize: host.storageSize,
|
|
ipv6Mode: 1,
|
|
ipv6Subnet: host.ipv6Subnet,
|
|
ipv6Gateway: host.ipv6Gateway,
|
|
ipv6ParentInterface: 'eth0',
|
|
enableApi: true,
|
|
isInstalled: true,
|
|
caddyEnabled: host.caddyEnabled,
|
|
caddyUsername: host.caddyEnabled ? `${SEED_PREFIX}-caddy` : null,
|
|
caddyPassword: host.caddyEnabled ? `${SEED_PREFIX}-password` : null,
|
|
transferEnabled: true,
|
|
announcement: `${SEED_MARK} ${host.location} demo host`,
|
|
probeUrl: `https://${host.name}.probe.local/health`
|
|
}
|
|
})
|
|
|
|
hostIds.set(host.name, saved.id)
|
|
|
|
for (const pool of storagePools) {
|
|
await prisma.storagePool.upsert({
|
|
where: {
|
|
hostId_name: {
|
|
hostId: saved.id,
|
|
name: pool.name
|
|
}
|
|
},
|
|
create: {
|
|
hostId: saved.id,
|
|
name: pool.name,
|
|
driver: pool.driver,
|
|
purpose: pool.purpose,
|
|
description: pool.description,
|
|
config: {
|
|
generatedBy: SEED_PREFIX,
|
|
host: host.name
|
|
}
|
|
},
|
|
update: {
|
|
driver: pool.driver,
|
|
purpose: pool.purpose,
|
|
description: pool.description,
|
|
config: {
|
|
generatedBy: SEED_PREFIX,
|
|
host: host.name
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
return hostIds
|
|
}
|
|
|
|
async function syncPackages(
|
|
userIds: Map<string, number>,
|
|
hostIds: Map<string, number>
|
|
): Promise<Map<string, GeneratedPackageRecord>> {
|
|
const packageMap = new Map<string, GeneratedPackageRecord>()
|
|
|
|
for (const pkg of packageSpecs) {
|
|
const userId = userIds.get(pkg.ownerUsername)
|
|
if (!userId) {
|
|
throw new Error(`Missing package owner ${pkg.ownerUsername}`)
|
|
}
|
|
|
|
const saved = await prisma.package.upsert({
|
|
where: {
|
|
userId_name: {
|
|
userId,
|
|
name: pkg.name
|
|
}
|
|
},
|
|
create: {
|
|
userId,
|
|
name: pkg.name,
|
|
description: pkg.description,
|
|
cpuMax: pkg.cpuMax,
|
|
memoryMax: pkg.memoryMax,
|
|
diskMax: pkg.diskMax,
|
|
bandwidthMax: pkg.bandwidthMax,
|
|
networkMode: pkg.networkMode,
|
|
instanceType: pkg.instanceType,
|
|
privileged: pkg.privileged,
|
|
nested: pkg.nested,
|
|
active: pkg.active,
|
|
portLimit: pkg.portLimit,
|
|
snapshotLimit: pkg.snapshotLimit,
|
|
backupLimit: pkg.backupLimit,
|
|
siteLimit: pkg.siteLimit,
|
|
monthlyTrafficLimit: pkg.monthlyTrafficLimit,
|
|
ioLimitMode: pkg.ioLimitMode,
|
|
limitsRead: pkg.limitsRead,
|
|
limitsWrite: pkg.limitsWrite,
|
|
limitsReadIops: pkg.limitsReadIops,
|
|
limitsWriteIops: pkg.limitsWriteIops,
|
|
limitsIngress: pkg.limitsIngress,
|
|
limitsEgress: pkg.limitsEgress,
|
|
limitsProcesses: pkg.limitsProcesses,
|
|
limitsCpuPriority: pkg.limitsCpuPriority,
|
|
bootAutostart: pkg.bootAutostart,
|
|
bootAutostartPriority: pkg.bootAutostartPriority,
|
|
bootAutostartDelay: pkg.bootAutostartDelay,
|
|
bootHostShutdownTimeout: pkg.bootHostShutdownTimeout,
|
|
globalShared: pkg.globalShared,
|
|
globalQuotaMultiplier: pkg.globalQuotaMultiplier,
|
|
globalMaxInstances: pkg.globalMaxInstances,
|
|
allowInstanceDeletion: pkg.allowInstanceDeletion
|
|
},
|
|
update: {
|
|
description: pkg.description,
|
|
cpuMax: pkg.cpuMax,
|
|
memoryMax: pkg.memoryMax,
|
|
diskMax: pkg.diskMax,
|
|
bandwidthMax: pkg.bandwidthMax,
|
|
networkMode: pkg.networkMode,
|
|
instanceType: pkg.instanceType,
|
|
privileged: pkg.privileged,
|
|
nested: pkg.nested,
|
|
active: pkg.active,
|
|
portLimit: pkg.portLimit,
|
|
snapshotLimit: pkg.snapshotLimit,
|
|
backupLimit: pkg.backupLimit,
|
|
siteLimit: pkg.siteLimit,
|
|
monthlyTrafficLimit: pkg.monthlyTrafficLimit,
|
|
ioLimitMode: pkg.ioLimitMode,
|
|
limitsRead: pkg.limitsRead,
|
|
limitsWrite: pkg.limitsWrite,
|
|
limitsReadIops: pkg.limitsReadIops,
|
|
limitsWriteIops: pkg.limitsWriteIops,
|
|
limitsIngress: pkg.limitsIngress,
|
|
limitsEgress: pkg.limitsEgress,
|
|
limitsProcesses: pkg.limitsProcesses,
|
|
limitsCpuPriority: pkg.limitsCpuPriority,
|
|
bootAutostart: pkg.bootAutostart,
|
|
bootAutostartPriority: pkg.bootAutostartPriority,
|
|
bootAutostartDelay: pkg.bootAutostartDelay,
|
|
bootHostShutdownTimeout: pkg.bootHostShutdownTimeout,
|
|
globalShared: pkg.globalShared,
|
|
globalQuotaMultiplier: pkg.globalQuotaMultiplier,
|
|
globalMaxInstances: pkg.globalMaxInstances,
|
|
allowInstanceDeletion: pkg.allowInstanceDeletion
|
|
}
|
|
})
|
|
|
|
await prisma.packageHost.deleteMany({ where: { packageId: saved.id } })
|
|
await prisma.packageHost.createMany({
|
|
data: pkg.hostNames.map(hostName => {
|
|
const hostId = hostIds.get(hostName)
|
|
if (!hostId) {
|
|
throw new Error(`Missing host ${hostName} for package ${pkg.name}`)
|
|
}
|
|
return {
|
|
packageId: saved.id,
|
|
hostId,
|
|
storagePoolName: 'default'
|
|
}
|
|
})
|
|
})
|
|
|
|
for (const plan of pkg.plans) {
|
|
await prisma.packagePlan.upsert({
|
|
where: {
|
|
packageId_name: {
|
|
packageId: saved.id,
|
|
name: plan.name
|
|
}
|
|
},
|
|
create: {
|
|
packageId: saved.id,
|
|
name: plan.name,
|
|
description: plan.description,
|
|
cpu: plan.cpu,
|
|
memory: plan.memory,
|
|
disk: plan.disk,
|
|
portLimit: plan.portLimit,
|
|
snapshotLimit: plan.snapshotLimit,
|
|
backupLimit: plan.backupLimit,
|
|
siteLimit: plan.siteLimit,
|
|
swapSize: plan.swapSize,
|
|
trafficLimit: plan.trafficLimit,
|
|
trafficLimitSpeed: plan.trafficLimitSpeed,
|
|
price: plan.price,
|
|
billingCycle: plan.billingCycle,
|
|
setupFee: plan.setupFee,
|
|
isActive: plan.isActive,
|
|
sortOrder: plan.sortOrder,
|
|
slaGuarantee: plan.slaGuarantee
|
|
},
|
|
update: {
|
|
description: plan.description,
|
|
cpu: plan.cpu,
|
|
memory: plan.memory,
|
|
disk: plan.disk,
|
|
portLimit: plan.portLimit,
|
|
snapshotLimit: plan.snapshotLimit,
|
|
backupLimit: plan.backupLimit,
|
|
siteLimit: plan.siteLimit,
|
|
swapSize: plan.swapSize,
|
|
trafficLimit: plan.trafficLimit,
|
|
trafficLimitSpeed: plan.trafficLimitSpeed,
|
|
price: plan.price,
|
|
billingCycle: plan.billingCycle,
|
|
setupFee: plan.setupFee,
|
|
isActive: plan.isActive,
|
|
sortOrder: plan.sortOrder,
|
|
slaGuarantee: plan.slaGuarantee
|
|
}
|
|
})
|
|
}
|
|
|
|
const savedPlans = await prisma.packagePlan.findMany({
|
|
where: { packageId: saved.id },
|
|
orderBy: { sortOrder: 'asc' }
|
|
})
|
|
|
|
packageMap.set(pkg.key, {
|
|
id: saved.id,
|
|
spec: pkg,
|
|
planIdsByName: new Map(savedPlans.map(plan => [plan.name, plan.id]))
|
|
})
|
|
}
|
|
|
|
return packageMap
|
|
}
|
|
|
|
async function syncInstances(
|
|
userIds: Map<string, number>,
|
|
hostIds: Map<string, number>,
|
|
packagesByKey: Map<string, GeneratedPackageRecord>
|
|
): Promise<GeneratedInstanceRecord[]> {
|
|
const records: GeneratedInstanceRecord[] = []
|
|
|
|
for (const [index, instance] of instanceSpecs.entries()) {
|
|
const userId = userIds.get(instance.userUsername)
|
|
const pkg = packagesByKey.get(instance.packageKey)
|
|
const hostId = hostIds.get(instance.hostName)
|
|
const hostSpec = hostSpecs.find(candidate => candidate.name === instance.hostName)
|
|
if (!userId || !pkg || !hostId || !hostSpec) {
|
|
throw new Error(`Missing relation while seeding instance ${instance.name}`)
|
|
}
|
|
|
|
const planId = pkg.planIdsByName.get(instance.planName)
|
|
const plan = pkg.spec.plans.find(candidate => candidate.name === instance.planName)
|
|
if (!planId || !plan) {
|
|
throw new Error(`Missing plan ${instance.planName} for ${instance.name}`)
|
|
}
|
|
|
|
const existing = await prisma.instance.findFirst({
|
|
where: {
|
|
userId,
|
|
name: instance.name
|
|
}
|
|
})
|
|
|
|
const saved = existing
|
|
? await prisma.instance.update({
|
|
where: { id: existing.id },
|
|
data: buildInstanceData(instance, userId, hostId, hostSpec, pkg.id, planId, pkg.spec, plan, index)
|
|
})
|
|
: await prisma.instance.create({
|
|
data: buildInstanceData(instance, userId, hostId, hostSpec, pkg.id, planId, pkg.spec, plan, index)
|
|
})
|
|
|
|
await syncInstanceChildren(saved.id, userId, hostId, hostSpec, instance, pkg.spec, plan, index)
|
|
|
|
records.push({
|
|
id: saved.id,
|
|
userId,
|
|
hostId,
|
|
packageId: pkg.id,
|
|
packagePlanId: planId,
|
|
spec: instance,
|
|
packageSpec: pkg.spec,
|
|
plan
|
|
})
|
|
}
|
|
|
|
return records
|
|
}
|
|
|
|
function buildInstanceData(
|
|
spec: SeedInstanceSpec,
|
|
userId: number,
|
|
hostId: number,
|
|
hostSpec: SeedHostSpec,
|
|
packageId: number,
|
|
packagePlanId: number,
|
|
pkg: SeedPackageSpec,
|
|
plan: SeedPlanSpec,
|
|
index: number
|
|
) {
|
|
return {
|
|
incusId: spec.incusId,
|
|
name: spec.name,
|
|
userId,
|
|
hostId,
|
|
packageId,
|
|
packagePlanId,
|
|
storagePoolName: 'default',
|
|
image: spec.image,
|
|
status: spec.status,
|
|
cpu: plan.cpu,
|
|
memory: plan.memory,
|
|
disk: plan.disk,
|
|
ipv4: spec.ipv4,
|
|
ipv6: spec.ipv6,
|
|
networkMode: pkg.networkMode,
|
|
sshPort: pkg.networkMode === 'ipv6_only' ? 22 : hostSpec.natPortStart + 20 + index * 4,
|
|
rootPassword: `${SHARED_PASSWORD}!${pad(index + 1, 3)}`,
|
|
snapshottedSpecs: {
|
|
generatedBy: SEED_PREFIX,
|
|
packageKey: pkg.key,
|
|
planName: plan.name,
|
|
cpu: plan.cpu,
|
|
memory: plan.memory,
|
|
disk: plan.disk
|
|
},
|
|
portLimit: plan.portLimit,
|
|
snapshotLimit: plan.snapshotLimit,
|
|
backupLimit: plan.backupLimit,
|
|
siteLimit: plan.siteLimit,
|
|
swapEnabled: plan.swapSize > 0,
|
|
swapSize: plan.swapSize,
|
|
monthlyTrafficLimit: plan.trafficLimit,
|
|
monthlyTrafficUsed: spec.monthlyTrafficUsed,
|
|
trafficStatus: spec.trafficStatus,
|
|
limitsRead: pkg.limitsRead,
|
|
limitsWrite: pkg.limitsWrite,
|
|
limitsReadIops: pkg.limitsReadIops,
|
|
limitsWriteIops: pkg.limitsWriteIops,
|
|
limitsIngress: pkg.limitsIngress,
|
|
limitsEgress: pkg.limitsEgress,
|
|
limitsProcesses: pkg.limitsProcesses,
|
|
limitsCpuPriority: pkg.limitsCpuPriority,
|
|
bootAutostart: pkg.bootAutostart,
|
|
bootAutostartPriority: pkg.bootAutostartPriority,
|
|
bootAutostartDelay: pkg.bootAutostartDelay,
|
|
bootHostShutdownTimeout: pkg.bootHostShutdownTimeout,
|
|
expiresAt: spec.expiresAt,
|
|
suspendedAt: spec.suspendedAt,
|
|
suspendedBy: spec.suspendedBy,
|
|
suspendReason: spec.suspendReason,
|
|
billingPrice: plan.price,
|
|
billingCycle: plan.billingCycle,
|
|
autoRenew: spec.autoRenew,
|
|
iconBadgeId: index % 9 === 0 ? 'fire' : null,
|
|
autoRenewAttempts: spec.autoRenew ? index % 3 : 0,
|
|
lastAutoRenewAttemptAt: spec.autoRenew ? daysAgo(index % 5, 16) : null,
|
|
expiryNotifiedAt: spec.status === 'suspended' ? daysAgo(1, 17) : null,
|
|
version: index % 5,
|
|
lastIpv6ReassignAt: spec.lastIpv6ReassignAt,
|
|
lastPlanChangeAt: spec.lastPlanChangeAt,
|
|
cloudInitState: spec.cloudInitState,
|
|
cloudInitSource: spec.cloudInitSource,
|
|
cloudInitLastCheckedAt: spec.lastSyncedAt,
|
|
cloudInitCompletedAt: spec.status === 'error' ? null : addMonths(spec.createdAt, 0),
|
|
cloudInitManualCompletedAt: spec.status === 'error' ? null : null,
|
|
cloudInitManualCompletedBy: null,
|
|
createdAt: spec.createdAt,
|
|
lastSyncedAt: spec.lastSyncedAt
|
|
}
|
|
}
|
|
|
|
async function syncInstanceChildren(
|
|
instanceId: number,
|
|
userId: number,
|
|
hostId: number,
|
|
hostSpec: SeedHostSpec,
|
|
spec: SeedInstanceSpec,
|
|
pkg: SeedPackageSpec,
|
|
plan: SeedPlanSpec,
|
|
index: number
|
|
): Promise<void> {
|
|
await prisma.portMapping.deleteMany({ where: { instanceId } })
|
|
await prisma.snapshot.deleteMany({ where: { instanceId } })
|
|
await prisma.backup.deleteMany({ where: { instanceId } })
|
|
await prisma.proxySite.deleteMany({ where: { instanceId } })
|
|
await prisma.ipAddress.deleteMany({ where: { instanceId } })
|
|
await prisma.ipv6Subnet.deleteMany({ where: { instanceId } })
|
|
await prisma.dailyTraffic.deleteMany({ where: { instanceId } })
|
|
await prisma.instanceBillingRecord.deleteMany({ where: { instanceId } })
|
|
|
|
const publicBase = hostSpec.natPortStart + 20 + index * 4
|
|
const supportsPortMappings = pkg.networkMode !== 'ipv6_only' && plan.portLimit > 0
|
|
if (supportsPortMappings) {
|
|
const portSet = pickPortSet(index, pkg.instanceType)
|
|
const mappings = portSet.map((privatePort, mappingIndex) => ({
|
|
instanceId,
|
|
hostId,
|
|
protocol: pickProtocol(index, mappingIndex),
|
|
publicPort: publicBase + mappingIndex,
|
|
privatePort,
|
|
remark: `${SEED_MARK} ${mappingIndex === 0 ? 'ssh-or-app' : 'service'}`
|
|
}))
|
|
await prisma.portMapping.createMany({ data: mappings })
|
|
}
|
|
|
|
const snapshotsToCreate = index % 3 === 0 ? 2 : index % 2 === 0 ? 1 : 0
|
|
if (snapshotsToCreate > 0) {
|
|
await prisma.snapshot.createMany({
|
|
data: Array.from({ length: snapshotsToCreate }, (_, snapshotIndex) => ({
|
|
instanceId,
|
|
incusName: `${spec.name}/snap-${snapshotIndex + 1}`,
|
|
name: `${SEED_PREFIX}-snap-${snapshotIndex + 1}`,
|
|
description: `${SEED_MARK} snapshot ${snapshotIndex + 1}`,
|
|
stateful: pkg.instanceType === 'vm' && snapshotIndex === 0,
|
|
size: 1024 + snapshotIndex * 512
|
|
}))
|
|
})
|
|
}
|
|
|
|
const backupsToCreate = index % 4 === 0 ? 2 : index % 3 === 0 ? 1 : 0
|
|
if (backupsToCreate > 0) {
|
|
await prisma.backup.createMany({
|
|
data: Array.from({ length: backupsToCreate }, (_, backupIndex) => ({
|
|
instanceId,
|
|
incusName: `${spec.name}/backup-${backupIndex + 1}`,
|
|
name: `${SEED_PREFIX}-backup-${backupIndex + 1}`,
|
|
description: `${SEED_MARK} backup ${backupIndex + 1}`,
|
|
size: 2048 + backupIndex * 768,
|
|
status: backupIndex === backupsToCreate - 1 && index % 8 === 0 ? 'error' : ('ready' as SeedBackupStatus),
|
|
expiresAt: daysFromNow(14 + backupIndex * 7, 6)
|
|
}))
|
|
})
|
|
}
|
|
|
|
if (index % 4 === 0) {
|
|
await prisma.backupPolicy.upsert({
|
|
where: { instanceId },
|
|
create: {
|
|
instanceId,
|
|
enabled: true,
|
|
intervalMinutes: 720,
|
|
lastRunAt: daysAgo(1, 2),
|
|
nextRunAt: daysFromNow(1, 2)
|
|
},
|
|
update: {
|
|
enabled: true,
|
|
intervalMinutes: 720,
|
|
lastRunAt: daysAgo(1, 2),
|
|
nextRunAt: daysFromNow(1, 2)
|
|
}
|
|
})
|
|
} else {
|
|
await prisma.backupPolicy.deleteMany({ where: { instanceId } })
|
|
}
|
|
|
|
if (index % 3 === 0) {
|
|
await prisma.snapshotPolicy.upsert({
|
|
where: { instanceId },
|
|
create: {
|
|
instanceId,
|
|
enabled: true,
|
|
intervalMinutes: 360,
|
|
lastRunAt: daysAgo(1, 4),
|
|
nextRunAt: daysFromNow(1, 4)
|
|
},
|
|
update: {
|
|
enabled: true,
|
|
intervalMinutes: 360,
|
|
lastRunAt: daysAgo(1, 4),
|
|
nextRunAt: daysFromNow(1, 4)
|
|
}
|
|
})
|
|
} else {
|
|
await prisma.snapshotPolicy.deleteMany({ where: { instanceId } })
|
|
}
|
|
|
|
await prisma.trafficSnapshot.upsert({
|
|
where: { instanceId },
|
|
create: {
|
|
instanceId,
|
|
rxRaw: 100_000_000n + BigInt(index) * 10_000n,
|
|
txRaw: 80_000_000n + BigInt(index) * 9_000n
|
|
},
|
|
update: {
|
|
rxRaw: 100_000_000n + BigInt(index) * 10_000n,
|
|
txRaw: 80_000_000n + BigInt(index) * 9_000n
|
|
}
|
|
})
|
|
|
|
await prisma.dailyTraffic.createMany({
|
|
data: Array.from({ length: 7 }, (_, dayOffset) => ({
|
|
instanceId,
|
|
date: daysAgo(6 - dayOffset, 0),
|
|
rxTotal: 2_000_000_000n + BigInt(index + dayOffset) * 30_000_000n,
|
|
txTotal: 1_200_000_000n + BigInt(index + dayOffset) * 20_000_000n
|
|
}))
|
|
})
|
|
|
|
const shouldAddIpv6 = pkg.networkMode === 'nat_ipv6' || pkg.networkMode === 'ipv6_only'
|
|
if (shouldAddIpv6 && spec.ipv6) {
|
|
await prisma.ipAddress.createMany({
|
|
data: [
|
|
{
|
|
instanceId,
|
|
address: spec.ipv6,
|
|
type: 'inet6',
|
|
isPrimary: true,
|
|
isCustom: false,
|
|
device: 'eth1'
|
|
},
|
|
...(index % 5 === 0
|
|
? [
|
|
{
|
|
instanceId,
|
|
address: `${spec.ipv6.split('::')[0]}::${400 + index}`,
|
|
type: 'inet6',
|
|
isPrimary: false,
|
|
isCustom: true,
|
|
device: 'eth1'
|
|
}
|
|
]
|
|
: [])
|
|
]
|
|
})
|
|
}
|
|
|
|
if (shouldAddIpv6 && spec.ipv6 && index % 6 === 0) {
|
|
await prisma.ipv6Subnet.create({
|
|
data: {
|
|
instanceId,
|
|
cidr: `${spec.ipv6.split('::')[0]}:100::/120`,
|
|
primaryIp: `${spec.ipv6.split('::')[0]}:100::1`,
|
|
device: 'eth1'
|
|
}
|
|
})
|
|
}
|
|
|
|
const proxyCount = pkg.instanceType === 'container' && plan.siteLimit > 0 && index % 3 !== 0 ? (index % 5 === 0 ? 2 : 1) : 0
|
|
if (proxyCount > 0) {
|
|
await prisma.proxySite.createMany({
|
|
data: Array.from({ length: proxyCount }, (_, siteIndex) => ({
|
|
instanceId,
|
|
hostId,
|
|
domain: `${spec.name}-${siteIndex + 1}.${SEED_PREFIX}.test`,
|
|
targetPort: [80, 443, 8080][siteIndex % 3],
|
|
httpsEnabled: siteIndex % 2 === 0,
|
|
remark: `${SEED_MARK} proxy ${siteIndex + 1}`,
|
|
status: pickProxyStatus(index, siteIndex),
|
|
enabled: siteIndex % 4 !== 0,
|
|
error: index % 9 === 0 && siteIndex === 0 ? `${SEED_MARK} DNS pending` : null
|
|
}))
|
|
})
|
|
}
|
|
|
|
await prisma.instanceBillingRecord.create({
|
|
data: {
|
|
instanceId,
|
|
userId,
|
|
type: 'newPurchase',
|
|
amount: plan.price,
|
|
months: plan.billingCycle,
|
|
periodStart: spec.createdAt,
|
|
periodEnd: addMonths(spec.createdAt, plan.billingCycle),
|
|
remark: `${SEED_MARK} initial purchase`
|
|
}
|
|
})
|
|
|
|
if (index % 6 === 0) {
|
|
const renewedStart = addMonths(spec.createdAt, plan.billingCycle)
|
|
await prisma.instanceBillingRecord.create({
|
|
data: {
|
|
instanceId,
|
|
userId,
|
|
type: 'renew',
|
|
amount: plan.price,
|
|
months: plan.billingCycle,
|
|
periodStart: renewedStart,
|
|
periodEnd: addMonths(renewedStart, plan.billingCycle),
|
|
remark: `${SEED_MARK} renewal sample`
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
function pickPortSet(index: number, instanceType: SeedPackageInstanceType): number[] {
|
|
if (instanceType === 'vm') {
|
|
return index % 2 === 0 ? [22, 3389] : [22, 8443]
|
|
}
|
|
const sets = [
|
|
[22, 80],
|
|
[22, 443],
|
|
[25565, 19132],
|
|
[8080, 8443]
|
|
]
|
|
return sets[index % sets.length]
|
|
}
|
|
|
|
function pickProtocol(index: number, mappingIndex: number): SeedProtocol {
|
|
if (mappingIndex === 1 && index % 4 === 2) return 'udp'
|
|
return 'tcp'
|
|
}
|
|
|
|
function pickProxyStatus(index: number, siteIndex: number): SeedProxyStatus {
|
|
if (index % 9 === 0 && siteIndex === 0) return 'error'
|
|
if (index % 4 === 0) return 'pending'
|
|
return 'active'
|
|
}
|
|
|
|
async function syncTickets(instances: GeneratedInstanceRecord[]): Promise<void> {
|
|
await prisma.ticket.deleteMany({
|
|
where: {
|
|
subject: { startsWith: SEED_MARK }
|
|
}
|
|
})
|
|
|
|
const selected = instances.filter((_, index) => index % 5 === 0).slice(0, 12)
|
|
for (const [index, instance] of selected.entries()) {
|
|
const hostOwner = await prisma.host.findUniqueOrThrow({
|
|
where: { id: instance.hostId },
|
|
select: { userId: true }
|
|
})
|
|
const status = (['open', 'in_progress', 'resolved', 'closed'] as SeedTicketStatus[])[index % 4]
|
|
const createdAt = daysAgo(2 + index, 9)
|
|
await prisma.ticket.create({
|
|
data: {
|
|
userId: instance.userId,
|
|
hostId: instance.hostId,
|
|
instanceId: instance.id,
|
|
subject: `${SEED_MARK} ticket-${pad(index + 1, 2)} for ${instance.spec.name}`,
|
|
category: ['general', 'billing', 'technical', 'abuse'][index % 4],
|
|
priority: (['low', 'normal', 'high', 'urgent'] as SeedTicketPriority[])[index % 4],
|
|
status,
|
|
createdAt,
|
|
resolvedAt: status === 'resolved' || status === 'closed' ? daysAgo(1 + index, 12) : null,
|
|
closedAt: status === 'closed' ? daysAgo(index, 15) : null,
|
|
messages: {
|
|
create: [
|
|
{
|
|
senderId: instance.userId,
|
|
content: `${SEED_MARK} user asks about ${instance.spec.name}`,
|
|
isFromOwner: false,
|
|
createdAt
|
|
},
|
|
{
|
|
senderId: hostOwner.userId,
|
|
content: `${SEED_MARK} host owner replied for ${instance.spec.name}`,
|
|
isFromOwner: true,
|
|
createdAt: new Date(createdAt.getTime() + 60 * 60 * 1000)
|
|
},
|
|
...(index % 3 === 0
|
|
? [
|
|
{
|
|
senderId: instance.userId,
|
|
content: `${SEED_MARK} follow-up confirmation`,
|
|
isFromOwner: false,
|
|
createdAt: new Date(createdAt.getTime() + 2 * 60 * 60 * 1000)
|
|
}
|
|
]
|
|
: [])
|
|
]
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
async function syncBalances(
|
|
userIds: Map<string, number>,
|
|
instances: GeneratedInstanceRecord[]
|
|
): Promise<void> {
|
|
const seedUserIds = Array.from(userIds.values())
|
|
await prisma.balanceLog.deleteMany({
|
|
where: {
|
|
userId: { in: seedUserIds },
|
|
remark: { startsWith: SEED_MARK }
|
|
}
|
|
})
|
|
|
|
const spendByUser = new Map<number, number>()
|
|
for (const instance of instances) {
|
|
spendByUser.set(instance.userId, (spendByUser.get(instance.userId) || 0) + instance.plan.price)
|
|
}
|
|
|
|
const logs: SeedBalanceLogSpec[] = []
|
|
|
|
for (const [index, user] of allSeedUsers.entries()) {
|
|
const userId = userIds.get(user.username)!
|
|
const spend = spendByUser.get(userId) || 0
|
|
const baseRecharge = getBaseRechargeAmount(user, index, spend)
|
|
const giftAmount = getGiftAmount(user, index)
|
|
let balanceBefore = 0
|
|
|
|
logs.push({
|
|
userId,
|
|
type: user.role === 'admin' ? 'admin_adjust' : 'recharge',
|
|
amount: baseRecharge,
|
|
balanceBefore,
|
|
balanceAfter: balanceBefore + baseRecharge,
|
|
orderId: user.role === 'admin' ? null : getSeedOrderNo(index),
|
|
remark: `${SEED_MARK} initial funding`
|
|
})
|
|
balanceBefore += baseRecharge
|
|
|
|
logs.push({
|
|
userId,
|
|
type: 'gift',
|
|
amount: giftAmount,
|
|
balanceBefore,
|
|
balanceAfter: balanceBefore + giftAmount,
|
|
orderId: null,
|
|
remark: `${SEED_MARK} promo gift`
|
|
})
|
|
balanceBefore += giftAmount
|
|
|
|
if (spend > 0) {
|
|
logs.push({
|
|
userId,
|
|
type: 'consume',
|
|
amount: -spend,
|
|
balanceBefore,
|
|
balanceAfter: balanceBefore - spend,
|
|
orderId: null,
|
|
remark: `${SEED_MARK} instance purchases`
|
|
})
|
|
balanceBefore -= spend
|
|
}
|
|
|
|
await prisma.user.update({
|
|
where: { id: userId },
|
|
data: { balance: balanceBefore }
|
|
})
|
|
}
|
|
|
|
await prisma.balanceLog.createMany({ data: logs })
|
|
}
|
|
|
|
async function refreshHostAndQuotaUsage(
|
|
userIds: Map<string, number>,
|
|
hostIds: Map<string, number>,
|
|
instances: GeneratedInstanceRecord[]
|
|
): Promise<void> {
|
|
const hostStats = new Map<number, { cpu: number; memory: number; disk: number; ports: number }>()
|
|
for (const hostId of hostIds.values()) {
|
|
hostStats.set(hostId, { cpu: 0, memory: 0, disk: 0, ports: 0 })
|
|
}
|
|
|
|
for (const instance of instances) {
|
|
const stats = hostStats.get(instance.hostId)
|
|
if (!stats) continue
|
|
stats.cpu += instance.plan.cpu
|
|
stats.memory += instance.plan.memory
|
|
stats.disk += instance.plan.disk
|
|
}
|
|
|
|
const portCounts = await prisma.portMapping.groupBy({
|
|
by: ['hostId'],
|
|
where: {
|
|
hostId: { in: Array.from(hostIds.values()) }
|
|
},
|
|
_count: {
|
|
_all: true
|
|
}
|
|
})
|
|
|
|
for (const row of portCounts) {
|
|
const stats = hostStats.get(row.hostId)
|
|
if (stats) {
|
|
stats.ports = row._count._all
|
|
}
|
|
}
|
|
|
|
for (const [hostName, hostId] of hostIds.entries()) {
|
|
const stats = hostStats.get(hostId)!
|
|
await prisma.host.update({
|
|
where: { id: hostId },
|
|
data: {
|
|
cpuUsed: stats.cpu,
|
|
memoryUsed: stats.memory,
|
|
diskUsed: stats.disk,
|
|
natPortsUsedCount: stats.ports
|
|
}
|
|
})
|
|
}
|
|
|
|
const hostCountByOwner = new Map<number, number>()
|
|
const packageCountByOwner = new Map<number, number>()
|
|
ownerUsers.forEach(owner => {
|
|
const ownerId = userIds.get(owner.username)!
|
|
hostCountByOwner.set(ownerId, hostSpecs.filter(host => host.ownerUsername === owner.username).length)
|
|
packageCountByOwner.set(ownerId, packageSpecs.filter(pkg => pkg.ownerUsername === owner.username).length)
|
|
})
|
|
|
|
for (const user of allSeedUsers) {
|
|
const userId = userIds.get(user.username)!
|
|
await prisma.userQuota.update({
|
|
where: { userId },
|
|
data: {
|
|
hostUsed: hostCountByOwner.get(userId) || 0,
|
|
packageUsed: packageCountByOwner.get(userId) || 0
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
async function printSummary(): Promise<void> {
|
|
const [users, hosts, packages, plans, instances, ports, snapshots, backups, sites, tickets] = await Promise.all([
|
|
prisma.user.count({ where: { username: { startsWith: SEED_PREFIX } } }),
|
|
prisma.host.count({ where: { name: { startsWith: `${SEED_PREFIX}-host-` } } }),
|
|
prisma.package.count({ where: { name: { startsWith: `${SEED_PREFIX}-pkg-` } } }),
|
|
prisma.packagePlan.count({ where: { package: { name: { startsWith: `${SEED_PREFIX}-pkg-` } } } }),
|
|
prisma.instance.count({ where: { name: { startsWith: `${SEED_PREFIX}-inst-` } } }),
|
|
prisma.portMapping.count({ where: { instance: { name: { startsWith: `${SEED_PREFIX}-inst-` } } } }),
|
|
prisma.snapshot.count({ where: { instance: { name: { startsWith: `${SEED_PREFIX}-inst-` } } } }),
|
|
prisma.backup.count({ where: { instance: { name: { startsWith: `${SEED_PREFIX}-inst-` } } } }),
|
|
prisma.proxySite.count({ where: { instance: { name: { startsWith: `${SEED_PREFIX}-inst-` } } } }),
|
|
prisma.ticket.count({ where: { subject: { startsWith: SEED_MARK } } })
|
|
])
|
|
|
|
console.log(`${SEED_MARK} completed`)
|
|
console.log(`${SEED_MARK} users=${users}, hosts=${hosts}, packages=${packages}, plans=${plans}, instances=${instances}`)
|
|
console.log(`${SEED_MARK} portMappings=${ports}, snapshots=${snapshots}, backups=${backups}, proxySites=${sites}, tickets=${tickets}`)
|
|
console.log(`${SEED_MARK} shared password for generated users: ${SHARED_PASSWORD}`)
|
|
}
|
|
|
|
async function main(): Promise<void> {
|
|
await ensureLocalDevGuard()
|
|
const passwordHash = await buildPasswordHash(SHARED_PASSWORD)
|
|
const userIds = await syncUsers(passwordHash)
|
|
const hostIds = await syncHosts(userIds)
|
|
const packagesByKey = await syncPackages(userIds, hostIds)
|
|
const instances = await syncInstances(userIds, hostIds, packagesByKey)
|
|
await syncTickets(instances)
|
|
await syncBalances(userIds, instances)
|
|
await refreshHostAndQuotaUsage(userIds, hostIds, instances)
|
|
await printSummary()
|
|
}
|
|
|
|
void main()
|
|
.catch(error => {
|
|
console.error(`${SEED_MARK} failed:`, error)
|
|
process.exitCode = 1
|
|
})
|
|
.finally(async () => {
|
|
await prisma.$disconnect()
|
|
})
|