HY2XS_flamy/apps/dao/sqlite.go

package dao

import (
	"encoding/base64"
	"errors"
	"fmt"
	"github.com/glebarez/sqlite"
	"github.com/sirupsen/logrus"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	"gorm.io/gorm/schema"
	"hy2xs-admin/credential"
	"hy2xs-admin/model/constant"
	"hy2xs-admin/model/entity"
	"hy2xs-admin/util"
	"log"
	"os"
	"strings"
	"time"
)

var sqliteDB *gorm.DB

func InitSqliteDB() error {
	return InitSqliteDBAt(constant.SqliteDBPath)
}

// InitSqliteDBAt открывает базу по указанному пути.
//
// Путь параметризован, а не зашит: без этого единственным способом проверить
// поведение слоя данных (транзакционность импорта пиров, в первую очередь)
// было бы обращение к реальной /var/lib/hy2xs-admin/hy2xs-admin.db.
func InitSqliteDBAt(path string) error {
	var err error
	sqliteDB, err = gorm.Open(sqlite.Open(path), &gorm.Config{
		TranslateError: true,
		Logger: logger.New(
			log.New(os.Stdout, "\r\n", log.LstdFlags),
			logger.Config{
				SlowThreshold:             time.Second,
				LogLevel:                  logger.Silent,
				IgnoreRecordNotFoundError: true,
				ParameterizedQueries:      true,
				Colorful:                  false,
			},
		),
		NamingStrategy: schema.NamingStrategy{
			SingularTable: true,
		},
	})
	if err != nil {
		logrus.Errorf("sqlite open err: %v", err)
		return errors.New("sqlite open err")
	}
	return nil
}

// InitSql поднимает базу админки.
//
// Порт сюда больше не передаётся: раньше InitSql записывал в config тот самый
// порт, который получил аргументом из ExecStart, а startup тут же читал его
// обратно. База не была источником этого факта ни на одном шаге.
func InitSql() error {
	return InitSqlAt(constant.SqliteDBPath)
}

// InitSqlAt поднимает базу по указанному пути.
//
// Путь параметризован по той же причине, что и у InitSqliteDBAt: жизненный
// цикл пира установщика — единственное, что доказывает необратимость отзыва
// доступа, и проверить его можно только прогнав ПОЛНУЮ последовательность
// запуска (миграции → seeder → повторный запуск) дважды на одной базе.
// Отдельная проверка ensureSecureBootstrapPeer в отрыве от InitSql доказывала
// бы поведение функции, а не поведение сервиса при перезапуске.
func InitSqlAt(path string) error {
	if err := InitSqliteDBAt(path); err != nil {
		return err
	}
	if err := runMigrations(); err != nil {
		return err
	}
	if err := ensureSecureBootstrapAdmin(); err != nil {
		return err
	}
	if err := ensureSecureBootstrapPeer(); err != nil {
		return err
	}
	if _, err := getOrCreateJwtSecret(); err != nil {
		return err
	}
	if err := ensureTrafficStatsSecret(); err != nil {
		return err
	}

	return nil
}

func envBoolAsInt(name string, fallback int) int {
	raw := strings.TrimSpace(strings.ToLower(os.Getenv(name)))
	if raw == "" {
		return fallback
	}
	if raw == "true" || raw == "1" {
		return 1
	}
	if raw == "false" || raw == "0" {
		return 0
	}
	return fallback
}

// ensureSecureBootstrapAdmin создаёт первую учётную запись администратора.
//
// Пароль приходит ТОЛЬКО из HY2XS_ADMIN_INITIAL_PASSWORD, и его отсутствие —
// отказ старта, а не повод придумать пароль самостоятельно.
//
// Что было. При пустом env админка генерировала пароль сама и печатала его
// двумя logrus.Warnf — то есть открытым текстом в /var/log/hy2xs/hy2xs-admin.log.
// Этот же файл отдаётся оператору кнопкой выгрузки журнала и попадает в
// diagnostics-бандл, который люди пересылают в переписке. Получался постоянный
// канал утечки учётных данных администратора.
//
// Второе, менее очевидное: сгенерированный здесь пароль не знает НИКТО, кроме
// журнала. Оркестратор пишет свой в /etc/hy2xs/bootstrap-admin.secret и в
// hy2xs.env, и именно он считается контрактом установки. Значит, попадание
// сюда означает не «нужно что-то придумать», а повреждённый контракт запуска —
// и правильная реакция на него громкая, а не молчаливая.
func ensureSecureBootstrapAdmin() error {
	adminUser := strings.TrimSpace(os.Getenv("HY2XS_ADMIN_USER"))
	if adminUser == "" {
		adminUser = "hy2xsadmin"
	}
	if _, err := GetAdminUser("username = ?", adminUser); err == nil {
		return nil
	}

	// Пароль читается КАК ЕСТЬ.
	//
	// Здесь стоял strings.TrimSpace, и он противоречил контракту продукта:
	// пробел по краям объявлен частью пароля и не снимается ни на форме входа,
	// ни при смене пароля, ни в оркестраторе. То есть bootstrap-путь
	// гарантированно создавал учётную запись НЕ с тем паролем, который оператор
	// записал в hy2xs.env, а войти в неё он пытался бы исходным значением.
	adminPassword := os.Getenv("HY2XS_ADMIN_INITIAL_PASSWORD")
	if adminPassword == "" {
		return errors.New(
			"HY2XS_ADMIN_INITIAL_PASSWORD не задан, а учётной записи администратора в базе нет.\n" +
				"Это признак повреждённого контракта запуска: пароль первого администратора\n" +
				"задаёт install-оркестратор через /etc/hy2xs/hy2xs.env, а копию кладёт в\n" +
				"/etc/hy2xs/bootstrap-admin.secret. Придумывать его самостоятельно админка не\n" +
				"будет: такой пароль не знал бы никто, кроме журнала.\n" +
				"Проверьте EnvironmentFile в юните hy2xs-admin и запустите\n" +
				"`hy2xs-orchestrator repair --allow-partial-state`.",
		)
	}

	// Контракт проверяется ЗДЕСЬ, а не только при хешировании.
	//
	// Отказ bcrypt на непригодном пароле выглядел бы как «bcrypt: password
	// length exceeds 72 bytes» в journal — сообщение, по которому оператор не
	// поймёт ни что чинить, ни где. Причина же чинится одной строкой в
	// hy2xs.env, и назвать её обязан тот, кто знает про этот файл.
	if !credential.IsValidAdminPassword(adminPassword) {
		return fmt.Errorf(
			"HY2XS_ADMIN_INITIAL_PASSWORD не удовлетворяет контракту панели: "+
				"от %d до %d символов, не более %d байт в UTF-8, без управляющих символов и U+FEFF.\n"+
				"Набор символов не ограничен, пробелы по краям являются частью пароля.\n"+
				"Учётная запись администратора с таким значением создана НЕ будет: "+
				"установка завершилась бы успешно, а войти в панель было бы нельзя.\n"+
				"Исправьте значение в /etc/hy2xs/hy2xs.env и запустите\n"+
				"`hy2xs-orchestrator repair --allow-partial-state`.",
			credential.AdminPasswordMinLength,
			credential.AdminPasswordMaxLength,
			credential.AdminPasswordMaxBytes,
		)
	}

	forcePasswordChange := envBoolAsInt("HY2XS_FORCE_PASSWORD_CHANGE", 1)
	status := int64(1)
	tokenVersion := int64(1)
	passwordChangedAt := time.Now().UnixMilli()
	hash, hashErr := util.HashPassword(adminPassword)
	if hashErr != nil {
		return hashErr
	}

	username := adminUser
	account := entity.AdminUser{
		Username:            &username,
		PasswordHash:        &hash,
		Status:              &status,
		TokenVersion:        &tokenVersion,
		PasswordChangedAt:   &passwordChangedAt,
		ForcePasswordChange: func() *int64 { v := int64(forcePasswordChange); return &v }(),
	}
	if _, saveErr := SaveAdminUser(account); saveErr != nil {
		return saveErr
	}
	return nil
}

// BootstrapPeerName — имя и authId пира, который создаёт установка.
//
// Объявлено здесь, а не литералом в четырёх местах: то же значение проверяет
// service.ReservedBootstrapPeerName, и расхождение между ними означало бы, что
// guard защищает не тот пир, который создал seeder.
const BootstrapPeerName = "bootstrap-admin-peer"

// bootstrapPeerSeededValue — значение маркера constant.BootstrapPeerSeeded.
const bootstrapPeerSeededValue = "true"

// ensureSecureBootstrapPeer создаёт пир установщика РОВНО ОДИН РАЗ за жизнь
// базы.
//
// Секрет приходит ТОЛЬКО из HY2XS_ADMIN_CON_PASS: он лежит ещё и в
// /etc/hy2xs/bootstrap-admin.secret, откуда его читает smoke оркестратора для
// проверки machine-auth. Сгенерированный здесь секрет разошёлся бы с файлом, и
// первая же проверка подключения после установки провалилась бы — на
// корректном во всём остальном сервере.
//
// Что было и почему это была дыра в отзыве доступа.
//
// Признаком «создавать или нет» служило наличие строки в таблице пиров. Панель
// при этом разрешает удалить bootstrap-admin-peer, и это осознанное решение:
// после установки он остаётся обычным действующим доступом, а запрет удаления
// означал бы вечный неотзываемый вход. Но HY2XS_ADMIN_CON_PASS продолжает жить
// в /etc/hy2xs/hy2xs.env, который читает systemd-юнит, поэтому:
//
//	оператор удаляет bootstrap-admin-peer   → доступ действительно исчезает
//	systemctl restart hy2xs-admin / reboot  → InitSql → ensureSecureBootstrapPeer
//	                                        → строки нет → создать заново
//	                                        → ТОТ ЖЕ секрет снова действует
//
// То есть отзыв учётных данных не переживал перезапуск, и восстановление
// происходило молча: в журнале ничего, в списке пиров запись просто снова есть.
// Отзыв, который не переживает restart, отзывом не является.
//
// Теперь решение принимается по отдельной отметке в таблице `config`. Она
// отвечает на вопрос «пир КОГДА-ЛИБО создавался», а не «существует сейчас»,
// поэтому удаление становится окончательным. Отметка и сам пир пишутся одной
// транзакцией: иначе падение между двумя операциями вернуло бы прежнее
// поведение на следующем старте.
//
// Порядок проверок сохранён: сначала выясняем, нужно ли вообще создавать пир, и
// только потом требуем env. Перезапуск установленного сервиса без переменной
// обязан работать штатно.
func ensureSecureBootstrapPeer() error {
	seeded, err := bootstrapPeerSeeded()
	if err != nil {
		return err
	}
	if seeded {
		return nil
	}

	// Пир есть, а отметки нет. На чистой установке это недостижимо: имя
	// зарезервировано во всех путях записи панели, поэтому единственный
	// создатель такой строки — этот же seeder. Ветка закрывает базу, созданную
	// сборкой до появления отметки, и делает функцию идемпотентной, не
	// возвращая при этом прежнюю семантику: она срабатывает только при
	// отсутствующем маркере.
	switch _, err := GetPeer("name = ?", BootstrapPeerName); {
	case err == nil:
		return UpsertConfigValue(constant.BootstrapPeerSeeded, bootstrapPeerSeededValue)
	case !errors.Is(err, ErrPeerNotFound):
		// База не ответила. «Неизвестно» не даёт права создавать учётные данные.
		return err
	}

	bootstrapSecret := strings.TrimSpace(os.Getenv("HY2XS_ADMIN_CON_PASS"))
	if bootstrapSecret == "" {
		return errors.New(
			"HY2XS_ADMIN_CON_PASS не задан, а пир установщика bootstrap-admin-peer ещё ни разу не создавался.\n" +
				"Секрет этого пира задаёт install-оркестратор и кладёт копию в\n" +
				"/etc/hy2xs/bootstrap-admin.secret, откуда его читает проверка machine-auth.\n" +
				"Секрет, придуманный админкой, разошёлся бы с этим файлом, и проверка\n" +
				"подключения после установки провалилась бы.\n" +
				"Проверьте EnvironmentFile в юните hy2xs-admin и запустите\n" +
				"`hy2xs-orchestrator repair --allow-partial-state`.",
		)
	}

	secretDigest, err := buildPeerSecretDigest(bootstrapSecret)
	if err != nil {
		return err
	}

	// Чужой пир с тем же секретом. Создавать нельзя — UNIQUE(secret_digest), —
	// но и молчать нельзя: секрет установщика уже выдан кому-то ещё.
	switch _, err := GetPeer("secret_digest = ?", secretDigest); {
	case err == nil:
		return errors.New(
			"секрет из HY2XS_ADMIN_CON_PASS уже принадлежит другому пиру.\n" +
				"Пир установщика не создан: два пира не могут делить один секрет.\n" +
				"Переименуйте или удалите этот пир, либо смените HY2XS_ADMIN_CON_PASS\n" +
				"через `hy2xs-orchestrator reconfigure`.",
		)
	case !errors.Is(err, ErrPeerNotFound):
		return err
	}

	secretEncrypted, err := encryptBootstrapPeerSecret(bootstrapSecret)
	if err != nil {
		return err
	}

	name := BootstrapPeerName
	authID := BootstrapPeerName
	remark := "bootstrap peer seeded from HY2XS_ADMIN_CON_PASS"
	quota := int64(-1)
	download := int64(0)
	upload := int64(0)
	expires := int64(0)
	maxDevices := int64(3)
	disabled := int64(0)
	bannedUntil := int64(0)
	lastConnection := int64(0)

	peer := entity.Peer{
		Name:             &name,
		Remark:           &remark,
		AuthId:           &authID,
		SecretDigest:     &secretDigest,
		SecretEncrypted:  &secretEncrypted,
		QuotaBytes:       &quota,
		DownloadBytes:    &download,
		UploadBytes:      &upload,
		ExpiresAt:        &expires,
		MaxDevices:       &maxDevices,
		Disabled:         &disabled,
		BannedUntil:      &bannedUntil,
		LastConnectionAt: &lastConnection,
	}
	return seedBootstrapPeerOnce(peer)
}

// bootstrapPeerSeeded читает отметку о том, что пир установщика уже создавался.
//
// Отсутствие строки — это «ещё не создавался», а не отказ: миграция 000
// заводит ключ пустым, но база могла быть создана и до его появления. Любая
// ДРУГАЯ ошибка — отказ хранилища, и трактовать её как «не создавался» нельзя:
// именно так и появлялся бы пир заново при недоступной базе.
func bootstrapPeerSeeded() (bool, error) {
	cfg, err := GetConfig("key = ?", constant.BootstrapPeerSeeded)
	if err != nil {
		if errors.Is(err, ErrConfigNotFound) {
			return false, nil
		}
		return false, err
	}
	if cfg.Value == nil {
		return false, nil
	}
	return strings.TrimSpace(*cfg.Value) == bootstrapPeerSeededValue, nil
}

// seedBootstrapPeerOnce пишет пир и отметку о его создании неделимо.
//
// Раздельная запись вернула бы исходный дефект в новой форме: упади процесс
// между SavePeer и записью отметки, следующий старт снова увидел бы
// «не создавался» и — после удаления пира оператором — создал бы его заново.
func seedBootstrapPeerOnce(peer entity.Peer) error {
	if sqliteDB == nil {
		return errors.New("sqlite is not initialized")
	}
	return sqliteDB.Transaction(func(tx *gorm.DB) error {
		if _, err := (peerTx{db: tx}).SavePeer(peer); err != nil {
			return err
		}
		return upsertConfigValueOn(tx, constant.BootstrapPeerSeeded, bootstrapPeerSeededValue)
	})
}

func buildPeerSecretDigest(rawSecret string) (string, error) {
	secretKey, err := GetOrCreatePeerSecretDigestKey()
	if err != nil {
		return "", err
	}
	return util.HmacSHA256Hex(rawSecret, secretKey), nil
}

// GetOrCreatePeerSecretEncryptionKey возвращает master-key шифрования секретов
// пиров, при необходимости создавая его.
//
// Экспортирована, чтобы у ключа была ровно одна реализация. Раньше идентичная
// копия жила в service/peer_secret.go: две функции с одинаковым именем в разных
// пакетах, обе создающие один и тот же материал шифрования. Расхождение между
// ними означало бы, что секреты пиров шифруются одним ключом, а
// расшифровываются другим, и обнаружилось бы это на живых пирах.
func GetOrCreatePeerSecretEncryptionKey() ([]byte, error) {
	raw, err := GetOrCreateConfigSecret(constant.PeerSecretEncryptionKey, 32)
	if err != nil {
		return nil, err
	}
	decoded, decErr := util.DecodeBase64Key(raw, 32)
	if decErr == nil {
		return decoded, nil
	}

	// Ключ, записанный не в base64: приводим к стабильному представлению один
	// раз, сохранив исходные байты, — иначе уже зашифрованные секреты пиров
	// перестали бы расшифровываться.
	plain := []byte(strings.TrimSpace(raw))
	if len(plain) < 32 {
		return nil, errors.New("invalid peer secret encryption key")
	}
	plain = plain[:32]
	if err := UpsertConfigValue(constant.PeerSecretEncryptionKey, base64.StdEncoding.EncodeToString(plain)); err != nil {
		return nil, err
	}
	return plain, nil
}

func encryptBootstrapPeerSecret(rawSecret string) (string, error) {
	key, err := GetOrCreatePeerSecretEncryptionKey()
	if err != nil {
		return "", err
	}
	return util.EncryptAESGCM(rawSecret, key)
}

// GetOrCreateConfigSecret читает секрет из таблицы `config`, создавая его при
// первом обращении. Единственная реализация этой операции в продукте.
func GetOrCreateConfigSecret(key string, size int) (string, error) {
	cfg, err := GetConfig("key = ?", key)
	if err == nil && cfg.Value != nil && strings.TrimSpace(*cfg.Value) != "" {
		return strings.TrimSpace(*cfg.Value), nil
	}
	value, genErr := util.RandomString(size)
	if genErr != nil {
		return "", genErr
	}
	if err := UpsertConfigValue(key, value); err != nil {
		return "", err
	}
	return value, nil
}

// RunMigrations приводит схему базы к текущему поколению.
//
// Экспортирована, чтобы схему можно было поднять отдельно от InitSql: тестам
// слоя данных нужна таблица, но не нужны bootstrap-администратор, bootstrap-пир
// и генерация JWT-секрета.
func RunMigrations() error {
	return runMigrations()
}

func runMigrations() error {
	if tx := sqliteDB.Exec(`CREATE TABLE IF NOT EXISTS schema_migrations (
		version TEXT PRIMARY KEY,
		applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
	)`); tx.Error != nil {
		logrus.Errorf("sqlite migration init err: %v", tx.Error)
		return errors.New("sqlite migration init err")
	}

	type migration struct {
		version string
		apply   func() error
	}

	// Миграций 002_migrate_legacy_accounts и 003_archive_legacy_account здесь
	// больше нет.
	//
	// Они переносили таблицу `account` предыдущего поколения в admin_user/peer
	// и переименовывали её в бэкап. Это compatibility-слой продукта, который
	// HY2XS v1 принципиально не поддерживает: установка возможна только на
	// чистый хост, база 0.x не мигрируется ни при каком сценарии, а clean-host
	// контракт отказывает ещё до создания базы. Живого пути, по которому такая
	// таблица могла бы оказаться в hy2xs-admin.db, не существует.
	//
	// Номера оставшихся миграций сохранены: перенумерация заставила бы их
	// примениться повторно на уже установленных машинах.
	migrations := []migration{
		{version: "000_base_config", apply: migrateBaseConfig},
		{version: "001_admin_peer_split", apply: migrateAdminPeerSplit},
		{version: "004_traffic_samples_and_aggregates", apply: migrateTrafficTables},
		{version: "005_metric_sample", apply: migrateMetricSampleTable},
		{version: "006_drop_dead_config_keys", apply: migrateDropDeadConfigKeys},
	}

	for _, m := range migrations {
		if isApplied, err := migrationApplied(m.version); err != nil {
			return err
		} else if isApplied {
			continue
		}
		if err := m.apply(); err != nil {
			return err
		}
		if tx := sqliteDB.Exec("INSERT INTO schema_migrations(version) VALUES(?)", m.version); tx.Error != nil {
			logrus.Errorf("sqlite migration mark err: %v", tx.Error)
			return errors.New("sqlite migration mark err")
		}
	}

	return nil
}

func seedBaseConfig() error {
	// Сетевых настроек панели здесь нет: ими владеет оркестратор.
	//
	// HYSTERIA2_ENABLE, HYSTERIA2_CONFIG, HYSTERIA2_TRAFFIC_TIME и
	// HYSTERIA2_CONFIG_REMARK удалены: ни один из них не имел потребителя в
	// рантайме, см. model/constant/config.go. Строки этих ключей на уже
	// установленных машинах убирает миграция 006_drop_dead_config_keys.
	//
	// Оставшееся — четыре внутренних секрета и единственная настройка, которой
	// действительно владеет панель.
	//
	// BOOTSTRAP_PEER_SEEDED заводится пустым: пустое значение означает «пир
	// установщика ещё ни разу не создавался», и это верное состояние для
	// чистой базы. Отметку выставляет ensureSecureBootstrapPeer той же
	// транзакцией, которой создаёт пир.
	defaults := map[string]string{
		constant.JwtSecret:                   "",
		constant.ResetTrafficCron:            "0 0 * * *",
		constant.Hysteria2TrafficStatsSecret: "",
		constant.PeerSecretKey:               "",
		constant.PeerSecretEncryptionKey:     "",
		constant.BootstrapPeerSeeded:         "",
	}
	for k, v := range defaults {
		if tx := sqliteDB.Exec("INSERT OR IGNORE INTO config(key, value, remark) VALUES(?, ?, ?)", k, v, k); tx.Error != nil {
			logrus.Errorf("sqlite seed config err: %v", tx.Error)
			return errors.New("sqlite seed config err")
		}
	}
	return nil
}

func migrateBaseConfig() error {
	stmts := []string{
		`CREATE TABLE IF NOT EXISTS config (
			id INTEGER PRIMARY KEY AUTOINCREMENT,
			key TEXT NOT NULL UNIQUE DEFAULT '',
			value TEXT NOT NULL DEFAULT '',
			remark TEXT NOT NULL DEFAULT '',
			create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
			update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
		)`,
		`CREATE INDEX IF NOT EXISTS config_key_index ON config (key)`,
	}
	for _, stmt := range stmts {
		if tx := sqliteDB.Exec(stmt); tx.Error != nil {
			logrus.Errorf("sqlite migration exec err: %v", tx.Error)
			return errors.New("sqlite migration exec err")
		}
	}
	return seedBaseConfig()
}

// migrateDropDeadConfigKeys убирает из таблицы `config` ключи, у которых не
// осталось ни одного потребителя.
//
// Миграция нужна не ради места в базе, а ради того же инварианта, что и
// allowlist: строка в таблице секретов, которую никто не читает и не пишет,
// рано или поздно кем-нибудь прочитается. Ключи перечислены здесь строковыми
// литералами намеренно — соответствующих констант в коде уже нет, и появиться
// они не должны.
//
// Миграция безопасна на чистой установке (удалять нечего) и идемпотентна:
// применяется один раз и отмечается в schema_migrations. Номера предыдущих
// миграций не тронуты — они уже записаны на установленных машинах.
func migrateDropDeadConfigKeys() error {
	deadKeys := []string{
		"HYSTERIA2_ENABLE",
		"HYSTERIA2_CONFIG",
		"HYSTERIA2_TRAFFIC_TIME",
		"HYSTERIA2_CONFIG_REMARK",
	}
	for _, key := range deadKeys {
		if tx := sqliteDB.Exec("DELETE FROM config WHERE key = ?", key); tx.Error != nil {
			logrus.Errorf("sqlite migration exec err: %v", tx.Error)
			return errors.New("sqlite migration exec err")
		}
	}
	return nil
}

func migrationApplied(version string) (bool, error) {
	var count int64
	if tx := sqliteDB.Raw("SELECT COUNT(1) FROM schema_migrations WHERE version = ?", version).Scan(&count); tx.Error != nil {
		logrus.Errorf("sqlite migration query err: %v", tx.Error)
		return false, errors.New("sqlite migration query err")
	}
	return count > 0, nil
}

func migrateAdminPeerSplit() error {
	stmts := []string{
		`CREATE TABLE IF NOT EXISTS admin_user (
			id INTEGER PRIMARY KEY AUTOINCREMENT,
			username TEXT NOT NULL UNIQUE DEFAULT '',
			password_hash TEXT NOT NULL DEFAULT '',
			status INTEGER NOT NULL DEFAULT 1,
			force_password_change INTEGER NOT NULL DEFAULT 0,
			last_login_at INTEGER NOT NULL DEFAULT 0,
			password_changed_at INTEGER NOT NULL DEFAULT 0,
			token_version INTEGER NOT NULL DEFAULT 1,
			create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
			update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
		)`,
		`CREATE INDEX IF NOT EXISTS admin_user_username_index ON admin_user (username)`,
		`CREATE TABLE IF NOT EXISTS peer (
			id INTEGER PRIMARY KEY AUTOINCREMENT,
			name TEXT NOT NULL UNIQUE DEFAULT '',
			remark TEXT NOT NULL DEFAULT '',
			auth_id TEXT NOT NULL UNIQUE DEFAULT '',
			secret_digest TEXT NOT NULL UNIQUE DEFAULT '',
			secret_ciphertext TEXT NOT NULL DEFAULT '',
			quota_bytes INTEGER NOT NULL DEFAULT 0,
			download_bytes INTEGER NOT NULL DEFAULT 0,
			upload_bytes INTEGER NOT NULL DEFAULT 0,
			expires_at INTEGER NOT NULL DEFAULT 0,
			max_devices INTEGER NOT NULL DEFAULT 3,
			disabled INTEGER NOT NULL DEFAULT 0,
			banned_until INTEGER NOT NULL DEFAULT 0,
			last_connection_at INTEGER NOT NULL DEFAULT 0,
			create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
			update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
		)`,
		`CREATE INDEX IF NOT EXISTS peer_name_index ON peer (name)`,
		`CREATE INDEX IF NOT EXISTS peer_auth_id_index ON peer (auth_id)`,
		`CREATE INDEX IF NOT EXISTS peer_secret_digest_index ON peer (secret_digest)`,
	}
	for _, stmt := range stmts {
		if tx := sqliteDB.Exec(stmt); tx.Error != nil {
			logrus.Errorf("sqlite migration exec err: %v", tx.Error)
			return errors.New("sqlite migration exec err")
		}
	}
	return nil
}

func getOrCreateJwtSecret() (string, error) {
	if existing, err := GetConfig("key = ?", constant.JwtSecret); err == nil {
		if existing.Value != nil && strings.TrimSpace(*existing.Value) != "" {
			return strings.TrimSpace(*existing.Value), nil
		}
	}
	secret, secErr := util.RandomString(64)
	if secErr != nil {
		return "", secErr
	}
	if err := UpsertConfigValue(constant.JwtSecret, secret); err != nil {
		return "", err
	}
	return secret, nil
}

// GetOrCreatePeerSecretDigestKey — HMAC-ключ, которым считается secret_digest
// пира. Экспортирована по той же причине, что и ключ шифрования: копия этой же
// логики жила в service/peer_secret.go под именем GetPeerSecretKey.
func GetOrCreatePeerSecretDigestKey() (string, error) {
	return GetOrCreateConfigSecret(constant.PeerSecretKey, 48)
}

func migrateTrafficTables() error {
	stmts := []string{
		`CREATE TABLE IF NOT EXISTS traffic_sample (
			id INTEGER PRIMARY KEY AUTOINCREMENT,
			peer_id INTEGER NOT NULL,
			auth_id TEXT NOT NULL,
			rx_bytes INTEGER NOT NULL DEFAULT 0,
			tx_bytes INTEGER NOT NULL DEFAULT 0,
			sampled_at INTEGER NOT NULL,
			create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
			update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
		)`,
		`CREATE INDEX IF NOT EXISTS idx_traffic_sample_time ON traffic_sample(sampled_at)`,
		`CREATE INDEX IF NOT EXISTS idx_traffic_sample_peer_time ON traffic_sample(peer_id, sampled_at)`,

		`CREATE TABLE IF NOT EXISTS traffic_aggregate_hourly (
			peer_id INTEGER NOT NULL,
			hour_start INTEGER NOT NULL,
			rx_bytes INTEGER NOT NULL DEFAULT 0,
			tx_bytes INTEGER NOT NULL DEFAULT 0,
			create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
			update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
			PRIMARY KEY(peer_id, hour_start)
		)`,
		`CREATE INDEX IF NOT EXISTS idx_traffic_hourly_hour_start ON traffic_aggregate_hourly(hour_start)`,

		`CREATE TABLE IF NOT EXISTS traffic_aggregate_daily (
			peer_id INTEGER NOT NULL,
			day_start INTEGER NOT NULL,
			rx_bytes INTEGER NOT NULL DEFAULT 0,
			tx_bytes INTEGER NOT NULL DEFAULT 0,
			create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
			update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
			PRIMARY KEY(peer_id, day_start)
		)`,
		`CREATE INDEX IF NOT EXISTS idx_traffic_daily_day_start ON traffic_aggregate_daily(day_start)`,
	}
	for _, stmt := range stmts {
		if tx := sqliteDB.Exec(stmt); tx.Error != nil {
			logrus.Errorf("sqlite migration exec err: %v", tx.Error)
			return errors.New("sqlite migration exec err")
		}
	}
	return nil
}

func migrateMetricSampleTable() error {
	stmts := []string{
		`CREATE TABLE IF NOT EXISTS metric_sample (
			id INTEGER PRIMARY KEY AUTOINCREMENT,
			sampled_at INTEGER NOT NULL,
			cpu_percent REAL NOT NULL DEFAULT 0,
			load1 REAL NOT NULL DEFAULT 0,
			mem_used_bytes INTEGER NOT NULL DEFAULT 0,
			mem_total_bytes INTEGER NOT NULL DEFAULT 0,
			mem_percent REAL NOT NULL DEFAULT 0,
			disk_path TEXT NOT NULL DEFAULT '/',
			disk_used_bytes INTEGER NOT NULL DEFAULT 0,
			disk_total_bytes INTEGER NOT NULL DEFAULT 0,
			disk_percent REAL NOT NULL DEFAULT 0,
			hysteria_running INTEGER NOT NULL DEFAULT 0,
			online_peers INTEGER NOT NULL DEFAULT 0,
			online_devices INTEGER NOT NULL DEFAULT 0,
			create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
			update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
		)`,
		`CREATE INDEX IF NOT EXISTS idx_metric_sample_time ON metric_sample(sampled_at)`,
	}
	for _, stmt := range stmts {
		if tx := sqliteDB.Exec(stmt); tx.Error != nil {
			logrus.Errorf("sqlite migration exec err: %v", tx.Error)
			return errors.New("sqlite migration exec err")
		}
	}
	return nil
}

func tableExists(tableName string) bool {
	var count int64
	if tx := sqliteDB.Raw("SELECT COUNT(1) FROM sqlite_master WHERE type='table' AND name=?", tableName).Scan(&count); tx.Error != nil {
		return false
	}
	return count > 0
}

// ensureTrafficStatsSecret синхронизирует machine token с окружением и НЕ
// придумывает его сам.
//
// Владелец значения — оркестратор. Он же кладёт этот секрет в
// /etc/hysteria/config.yaml, откуда Hysteria берёт его для обращения к
// /internal/hysteria/auth, и в /etc/hy2xs/hy2xs.env, откуда его читает
// systemd-юнит админки. Токен — межкомпонентный контракт, а не внутреннее
// состояние панели.
//
// Что было. При пустом env и пустой базе админка генерировала случайный токен
// сама. Записать его в /etc/hysteria/config.yaml она не может — файл
// принадлежит оркестратору и для пользователя hy2xs-admin доступен только на
// чтение (это проверяет smoke). Результат:
//
//	admin стартовал успешно
//	Hysteria продолжала слать старый токен
//	machine auth переставал совпадать
//
// То есть повреждённый контракт запуска не диагностировался, а маскировался
// «починкой» неправильным способом: сервис объявлял себя здоровым, а
// авторизация клиентов молча ломалась.
//
// Тот же принцип, что уже применён к HY2XS_ADMIN_INITIAL_PASSWORD и
// HY2XS_ADMIN_CON_PASS: значение, которого не знает никто, кроме сгенерировавшего
// его процесса, бесполезно, и правильная реакция на его отсутствие громкая.
//
// Три допустимых состояния:
//
//	env задан                      → синхронизировать базу с ним (env главнее);
//	env пуст, в базе токен есть    → рабочее состояние, ничего не делаем;
//	env пуст, в базе пусто         → отказ старта.
//
// Вторая ветка нужна для ручного `systemctl start` без EnvironmentFile: она не
// изобретает контракт, а использует уже согласованный.
func ensureTrafficStatsSecret() error {
	envSecret := strings.TrimSpace(os.Getenv("HY2XS_HYSTERIA_TRAFFIC_STATS_SECRET"))
	if envSecret != "" {
		return UpsertConfigValue(constant.Hysteria2TrafficStatsSecret, envSecret)
	}

	existing, err := GetConfig("key = ?", constant.Hysteria2TrafficStatsSecret)
	if err != nil && !errors.Is(err, ErrConfigNotFound) {
		return err
	}
	if err == nil && existing.Value != nil && strings.TrimSpace(*existing.Value) != "" {
		return nil
	}

	return errors.New(
		"HY2XS_HYSTERIA_TRAFFIC_STATS_SECRET не задан, и в базе этого токена тоже нет.\n" +
			"Это межкомпонентный контракт, а не настройка панели: тем же значением\n" +
			"Hysteria обращается к /internal/hysteria/auth, и владеет им\n" +
			"install-оркестратор через /etc/hysteria/config.yaml и /etc/hy2xs/hy2xs.env.\n" +
			"Сгенерированный админкой токен не попал бы в конфиг Hysteria: этот файл\n" +
			"доступен ей только на чтение, — и machine auth перестал бы совпадать.\n" +
			"Проверьте EnvironmentFile в юните hy2xs-admin и запустите\n" +
			"`hy2xs-orchestrator repair --allow-partial-state`.",
	)
}

func CloseSqliteDB() error {
	if sqliteDB != nil {
		db, err := sqliteDB.DB()
		if err != nil {
			logrus.Errorf("sqlite err: %v", err)
			return errors.New("sqlite err")
		}
		if err = db.Close(); err != nil {
			logrus.Errorf("sqlite close err: %v", err)
			return errors.New("sqlite close err")
		}
	}
	return nil
}

func IsSqliteReady() bool {
	if sqliteDB == nil {
		return false
	}
	db, err := sqliteDB.DB()
	if err != nil {
		return false
	}
	if err := db.Ping(); err != nil {
		return false
	}
	return true
}

func Paginate(pageNum *int64, pageSize *int64) func(db *gorm.DB) *gorm.DB {
	var num int64 = 1
	var size int64 = 10
	if pageNum != nil && *pageNum > 0 {
		num = *pageNum
	}
	if pageSize != nil && *pageSize > 0 {
		size = *pageSize
	}
	return func(db *gorm.DB) *gorm.DB {
		return db.Offset(int((num - 1) * size)).Limit(int(size))
	}
}