140 lines
3.5 KiB
Go
140 lines
3.5 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/go-sql-driver/mysql"
|
|
|
|
"lingniu/vehicle-data-platform/apps/api/internal/businessscope"
|
|
)
|
|
|
|
func main() {
|
|
if err := run(); err != nil {
|
|
log.Printf("OneOS scope sync failed: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func run() error {
|
|
sourceDSN, err := normalizedDSN("ONEOS_MYSQL_DSN", os.Getenv("ONEOS_MYSQL_DSN"), true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
targetDSN, err := normalizedDSN("MYSQL_DSN", os.Getenv("MYSQL_DSN"), false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
timeout := time.Duration(envInt("ONEOS_SCOPE_SYNC_TIMEOUT_SEC", 60)) * time.Second
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
defer cancel()
|
|
source, err := openDB(ctx, sourceDSN, 2)
|
|
if err != nil {
|
|
return fmt.Errorf("open OneOS read-only database: %w", err)
|
|
}
|
|
defer source.Close()
|
|
target, err := openDB(ctx, targetDSN, 4)
|
|
if err != nil {
|
|
return fmt.Errorf("open vehicle platform database: %w", err)
|
|
}
|
|
defer target.Close()
|
|
candidates, err := businessscope.ReadCandidates(ctx, source)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
snapshot, err := businessscope.BuildSnapshot(candidates, time.Now())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
maxRejected := envInt("ONEOS_SCOPE_MAX_REJECTED", 100)
|
|
maxRejectedRatio, err := envFloat("ONEOS_SCOPE_MAX_REJECT_RATIO", 0.10)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := businessscope.ValidateSnapshot(snapshot, maxRejected, maxRejectedRatio); err != nil {
|
|
return err
|
|
}
|
|
result, err := businessscope.Publish(ctx, target, snapshot)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
log.Printf("OneOS scope sync complete changed=%t candidates=%d accepted=%d rejected=%d version=%s",
|
|
result.Changed, snapshot.Candidates, len(snapshot.Items), len(snapshot.Rejections), snapshot.SourceVersion)
|
|
return nil
|
|
}
|
|
|
|
func normalizedDSN(name, raw string, requireOneOSDatabase bool) (string, error) {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return "", fmt.Errorf("%s is required", name)
|
|
}
|
|
config, err := mysql.ParseDSN(raw)
|
|
if err != nil {
|
|
return "", fmt.Errorf("parse %s: %w", name, err)
|
|
}
|
|
if requireOneOSDatabase && config.DBName != "ln_asset_management" {
|
|
return "", fmt.Errorf("%s must select ln_asset_management", name)
|
|
}
|
|
location, err := time.LoadLocation("Asia/Shanghai")
|
|
if err != nil {
|
|
return "", fmt.Errorf("load Asia/Shanghai timezone: %w", err)
|
|
}
|
|
config.ParseTime = true
|
|
config.Loc = location
|
|
if config.Timeout <= 0 {
|
|
config.Timeout = 10 * time.Second
|
|
}
|
|
if config.ReadTimeout <= 0 {
|
|
config.ReadTimeout = 30 * time.Second
|
|
}
|
|
if config.WriteTimeout <= 0 {
|
|
config.WriteTimeout = 10 * time.Second
|
|
}
|
|
return config.FormatDSN(), nil
|
|
}
|
|
|
|
func openDB(ctx context.Context, dsn string, maxConnections int) (*sql.DB, error) {
|
|
db, err := sql.Open("mysql", dsn)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
db.SetMaxOpenConns(maxConnections)
|
|
db.SetMaxIdleConns(1)
|
|
db.SetConnMaxLifetime(5 * time.Minute)
|
|
if err := db.PingContext(ctx); err != nil {
|
|
_ = db.Close()
|
|
return nil, err
|
|
}
|
|
return db, nil
|
|
}
|
|
|
|
func envInt(key string, fallback int) int {
|
|
value := strings.TrimSpace(os.Getenv(key))
|
|
if value == "" {
|
|
return fallback
|
|
}
|
|
parsed, err := strconv.Atoi(value)
|
|
if err != nil {
|
|
return fallback
|
|
}
|
|
return parsed
|
|
}
|
|
|
|
func envFloat(key string, fallback float64) (float64, error) {
|
|
value := strings.TrimSpace(os.Getenv(key))
|
|
if value == "" {
|
|
return fallback, nil
|
|
}
|
|
parsed, err := strconv.ParseFloat(value, 64)
|
|
if err != nil || parsed < 0 || parsed > 1 {
|
|
return 0, fmt.Errorf("%s must be a number between 0 and 1", key)
|
|
}
|
|
return parsed, nil
|
|
}
|