mirror of
https://github.com/v2rayA/v2rayA.git
synced 2026-11-20 23:02:25 +03:00
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.
191 lines
4.7 KiB
Go
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()
|
|
}
|