Files
Zakk d537477a1c fix(service): the findings of a cold read of the upgrade and crash-recovery changes
A SQLite file that an earlier release's migration left empty next to an
intact bolt.db was taken as authoritative; a file without the system
settings a completed migration writes is discarded and the migration
runs again. A database migrated by that earlier release holds its
groups and outbound settings in the two tables the runtime never read;
opening it copies them into the keys it reads, for outbounds that have
none yet.

A start whose host-state recovery failed refused to run, and a start
that rolled back after its own stop tore the host state down a second
time; recovery is logged and retried at the next start, and a rollback
that stopped its process only clears the marker. A system-proxy
snapshot pending from an earlier run blocked every later system-proxy
start; it is reused as the original instead (Linux and macOS here; the
Windows side follows with its per-profile snapshot).

An empty /etc/resolv.conf was backed up as an empty file, which the
restore rejects as truncated; it is written as a marker and restored as
empty. db.Close resets the once so a reopen works.
2026-09-20 09:17:58 +10:00

191 lines
4.7 KiB
Go

package db
import (
"database/sql"
"errors"
"fmt"
"os"
"path/filepath"
"sync"
"github.com/v2rayA/v2rayA/conf"
"github.com/v2rayA/v2rayA/pkg/util/log"
)
var (
onceDB sync.Once
sqlDB *sql.DB
dbPath string
readOnly bool
IsNewDB bool // true if the database was just created (no pre-existing file)
)
// ErrNeedMigration is returned when an old BoltDB database is detected,
// indicating that migration to SQLite is required before normal operation.
var ErrNeedMigration = errors.New("bolt.db exists, migration required")
func sqliteDSN(path string) string {
if sqliteDriverName == "sqlite" {
return path + "?_pragma=busy_timeout(5000)&_pragma=foreign_keys(1)"
}
return path + "?_busy_timeout=5000&_foreign_keys=1"
}
func validateSQLiteDriver() error {
if sqliteDriverName == "" {
return errors.New("mips/loong64 build requires CGO_ENABLED=1 to enable sqlite driver")
}
return nil
}
// SetReadOnly sets the database to read-only mode.
// In read-only mode, a temporary copy of the database is created.
func SetReadOnly() {
readOnly = true
}
// initDB opens or creates the SQLite database with WAL mode
func initDB() {
confPath := conf.GetEnvironmentConfig().Config
dbPath = filepath.Join(confPath, "v2raya.db")
if readOnly {
// For read-only mode, create a temporary copy
f, err := os.CreateTemp(os.TempDir(), "v2raya_tmp_sqlite_*.db")
if err != nil {
panic(err)
}
newPath := f.Name()
f.Close()
// Copy existing database if it exists
if _, err := os.Stat(dbPath); err == nil {
input, err := os.ReadFile(dbPath)
if err != nil {
panic(err)
}
if err := os.WriteFile(newPath, input, 0600); err != nil {
panic(err)
}
}
dbPath = newPath
}
var err error
if err = validateSQLiteDriver(); err != nil {
log.Fatal("SQLite driver is unavailable: %v", err)
}
sqlDB, err = sql.Open(sqliteDriverName, sqliteDSN(dbPath))
if err != nil {
log.Fatal("sql.Open: %v", err)
}
// Configure PRAGMAs for WAL mode and performance
pragmas := []string{
"PRAGMA journal_mode=WAL",
"PRAGMA synchronous=NORMAL",
"PRAGMA cache_size=-8000",
}
for _, p := range pragmas {
if _, err := sqlDB.Exec(p); err != nil {
log.Fatal("Failed to set PRAGMA %s: %v", p, err)
}
}
// Initialize schema
if err := InitSchema(sqlDB); err != nil {
log.Fatal("InitSchema: %v", err)
}
// Apply incremental schema migrations for existing databases
if err := MigrateSchema(sqlDB); err != nil {
log.Fatal("MigrateSchema: %v", err)
}
}
// GetDB returns the singleton SQLite database connection
func GetDB() *sql.DB {
onceDB.Do(initDB)
return sqlDB
}
// DBPath returns the path to the SQLite database file
func DBPath() string {
onceDB.Do(initDB)
return dbPath
}
// Open initializes the database connection.
// It first checks if an old BoltDB database (bolt.db) exists.
// If bolt.db exists, it returns ErrNeedMigration to signal that
// migration is required before SQLite can be used.
// Otherwise, it creates/opens the SQLite database and initializes the schema.
func Open() error {
confPath := conf.GetEnvironmentConfig().Config
boltPath := filepath.Join(confPath, "bolt.db")
sqlitePath := filepath.Join(confPath, "v2raya.db")
// Check if old BoltDB database exists
if _, err := os.Stat(boltPath); err == nil {
// bolt.db exists — migration is required
// Do NOT create or initialize SQLite at this point
return ErrNeedMigration
}
// bolt.db does not exist, proceed with normal SQLite initialization
// Check if SQLite already exists before creating it
if _, err := os.Stat(sqlitePath); os.IsNotExist(err) {
// Database file does not exist — this is a fresh install
IsNewDB = true
// Create an empty file so sql.Open does not fail
f, err := os.Create(sqlitePath)
if err != nil {
return fmt.Errorf("failed to create SQLite database file: %w", err)
}
f.Close()
} else {
// Database file already exists — this is a restart
IsNewDB = false
}
GetDB()
return nil
}
// Close closes the SQLite database connection
func Close() error {
if sqlDB == nil {
return nil
}
err := sqlDB.Close()
// a later GetDB opens afresh instead of handing out the closed handle
sqlDB = nil
onceDB = sync.Once{}
return err
}
// ReadModifyWrite executes a function within a read-write transaction.
// If the function returns an error, the transaction is rolled back.
// Otherwise, the transaction is committed.
func ReadModifyWrite(fn func(tx *sql.Tx) error) error {
db := GetDB()
tx, err := db.Begin()
if err != nil {
return fmt.Errorf("failed to begin transaction: %w", err)
}
defer func() {
if p := recover(); p != nil {
_ = tx.Rollback()
panic(p)
}
}()
if err := fn(tx); err != nil {
_ = tx.Rollback()
return err
}
return tx.Commit()
}