mirror of
https://github.com/black-ant/Ant-Browser.git
synced 2026-07-14 18:48:55 +08:00
287 lines
8.3 KiB
Go
287 lines
8.3 KiB
Go
package backend
|
||
|
||
import (
|
||
"ant-chrome/backend/internal/apppath"
|
||
"ant-chrome/backend/internal/browser"
|
||
"ant-chrome/backend/internal/config"
|
||
"ant-chrome/backend/internal/logger"
|
||
"fmt"
|
||
"net"
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/google/uuid"
|
||
)
|
||
|
||
// ============================================================================
|
||
// 工具函数
|
||
// ============================================================================
|
||
|
||
// resolveAppPath 将相对路径解析为绝对路径（基于 appRoot）。
|
||
// 如果传入的已经是绝对路径则直接返回。
|
||
func (a *App) resolveAppPath(p string) string {
|
||
return apppath.Resolve(a.appRoot, p)
|
||
}
|
||
|
||
func generateUUID() string {
|
||
return uuid.NewString()
|
||
}
|
||
|
||
func nextAvailablePort() (int, error) {
|
||
// 二次验证策略：分配端口后立即再次绑定确认未被抢占，最多重试 10 次
|
||
for i := 0; i < 10; i++ {
|
||
l, err := net.Listen("tcp", "127.0.0.1:0")
|
||
if err != nil {
|
||
continue
|
||
}
|
||
port := l.Addr().(*net.TCPAddr).Port
|
||
l.Close()
|
||
// 短暂等待 OS 释放端口
|
||
time.Sleep(5 * time.Millisecond)
|
||
// 二次验证端口未被其他进程抢占
|
||
v, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", port))
|
||
if err != nil {
|
||
continue
|
||
}
|
||
v.Close()
|
||
return port, nil
|
||
}
|
||
return 0, fmt.Errorf("无法分配可用端口")
|
||
}
|
||
|
||
// ============================================================================
|
||
// 内核初始化
|
||
// ============================================================================
|
||
|
||
func (a *App) ensureDefaultCores() {
|
||
log := logger.New("Browser")
|
||
|
||
// 扫描 chrome/ 目录，无论配置是否已有内核都执行一次，确保新增子目录被发现
|
||
detected := a.scanChromeDir(a.browserCoreRoot())
|
||
|
||
if len(a.config.Browser.Cores) == 0 {
|
||
// 配置为空：直接用扫描结果，或兜底写一个占位
|
||
if len(detected) > 0 {
|
||
a.config.Browser.Cores = detected
|
||
} else {
|
||
a.config.Browser.Cores = []browser.Core{}
|
||
}
|
||
if err := a.config.Save(a.resolveAppPath("config.yaml")); err != nil {
|
||
log.Error("内核配置初始化失败", logger.F("error", err))
|
||
return
|
||
}
|
||
log.Info("内核配置初始化完成", logger.F("count", len(a.config.Browser.Cores)))
|
||
return
|
||
}
|
||
|
||
// 配置已有内核：将扫描到的新目录追加进去（不覆盖已有的）
|
||
changed := false
|
||
for _, newCore := range detected {
|
||
exists := false
|
||
for _, existing := range a.config.Browser.Cores {
|
||
if existing.CorePath == newCore.CorePath {
|
||
exists = true
|
||
break
|
||
}
|
||
}
|
||
if !exists {
|
||
a.config.Browser.Cores = append(a.config.Browser.Cores, newCore)
|
||
log.Info("发现新内核，已注册", logger.F("path", newCore.CorePath))
|
||
changed = true
|
||
}
|
||
}
|
||
if changed {
|
||
if err := a.config.Save(a.resolveAppPath("config.yaml")); err != nil {
|
||
log.Error("新内核注册保存失败", logger.F("error", err))
|
||
}
|
||
}
|
||
}
|
||
|
||
func (a *App) autoDetectCores() {
|
||
log := logger.New("Browser")
|
||
cores := a.scanAndRegisterCores()
|
||
// SQLite 模式下以内核表为准，避免与 config.yaml 历史条目不一致。
|
||
if a.browserMgr != nil {
|
||
cores = a.browserMgr.ListCores()
|
||
}
|
||
for _, core := range cores {
|
||
if a.browserMgr == nil {
|
||
break
|
||
}
|
||
result := a.browserMgr.ValidateCorePath(core.CorePath)
|
||
if result.Valid {
|
||
log.Debug("内核路径有效", logger.F("core_id", core.CoreId), logger.F("path", core.CorePath))
|
||
} else {
|
||
log.Warn("内核路径无效", logger.F("core_id", core.CoreId), logger.F("path", core.CorePath), logger.F("message", result.Message))
|
||
}
|
||
}
|
||
}
|
||
|
||
func (a *App) browserCoreRoot() string {
|
||
if a != nil && a.config != nil {
|
||
if root := strings.TrimSpace(a.config.Browser.CoreRoot); root != "" {
|
||
return root
|
||
}
|
||
}
|
||
return "chrome"
|
||
}
|
||
|
||
func (a *App) scanAndRegisterCores() []browser.Core {
|
||
log := logger.New("Browser")
|
||
detected := a.scanChromeDir(a.browserCoreRoot())
|
||
if len(detected) == 0 || a.browserMgr == nil {
|
||
return detected
|
||
}
|
||
|
||
existing := a.browserMgr.ListCores()
|
||
knownPaths := make(map[string]struct{}, len(existing))
|
||
hasDefault := false
|
||
for _, core := range existing {
|
||
knownPaths[normalizeCorePathForCompare(core.CorePath)] = struct{}{}
|
||
if core.IsDefault {
|
||
hasDefault = true
|
||
}
|
||
}
|
||
|
||
for _, core := range detected {
|
||
if _, ok := knownPaths[normalizeCorePathForCompare(core.CorePath)]; ok {
|
||
continue
|
||
}
|
||
core.IsDefault = !hasDefault
|
||
if err := a.browserMgr.SaveCore(browser.CoreInput{
|
||
CoreId: core.CoreId,
|
||
CoreName: core.CoreName,
|
||
CorePath: core.CorePath,
|
||
IsDefault: core.IsDefault,
|
||
}); err != nil {
|
||
log.Warn("自动注册内核失败", logger.F("core_id", core.CoreId), logger.F("path", core.CorePath), logger.F("error", err.Error()))
|
||
continue
|
||
}
|
||
log.Info("发现新内核，已注册", logger.F("core_id", core.CoreId), logger.F("path", core.CorePath))
|
||
knownPaths[normalizeCorePathForCompare(core.CorePath)] = struct{}{}
|
||
hasDefault = hasDefault || core.IsDefault
|
||
}
|
||
return a.browserMgr.ListCores()
|
||
}
|
||
|
||
func normalizeCorePathForCompare(path string) string {
|
||
path = strings.TrimSpace(path)
|
||
if path == "" {
|
||
return ""
|
||
}
|
||
return filepath.ToSlash(filepath.Clean(path))
|
||
}
|
||
|
||
// scanChromeDir 扫描指定目录，将包含浏览器可执行文件的子文件夹识别为内核。
|
||
// 如果目录本身包含可执行文件（旧版单内核结构），则直接返回该目录作为内核。
|
||
func (a *App) scanChromeDir(chromeRoot string) []browser.Core {
|
||
log := logger.New("Browser")
|
||
|
||
baseDir := a.resolveAppPath(chromeRoot)
|
||
|
||
if _, err := os.Stat(baseDir); os.IsNotExist(err) {
|
||
return nil
|
||
}
|
||
|
||
// 如果根目录本身就有浏览器可执行文件，视为单内核结构
|
||
if _, _, ok := browser.FindCoreExecutableShallow(baseDir); ok {
|
||
return []browser.Core{
|
||
{
|
||
CoreId: "default",
|
||
CoreName: "默认内核",
|
||
CorePath: chromeRoot,
|
||
IsDefault: true,
|
||
},
|
||
}
|
||
}
|
||
|
||
// 扫描子文件夹
|
||
entries, err := os.ReadDir(baseDir)
|
||
if err != nil {
|
||
log.Warn("扫描 chrome 目录失败", logger.F("path", baseDir), logger.F("error", err.Error()))
|
||
return nil
|
||
}
|
||
|
||
var cores []browser.Core
|
||
for _, entry := range entries {
|
||
if !entry.IsDir() {
|
||
continue
|
||
}
|
||
subPath := filepath.Join(chromeRoot, entry.Name())
|
||
absCoreDir := filepath.Join(baseDir, entry.Name())
|
||
if _, _, ok := browser.FindCoreExecutable(absCoreDir); !ok {
|
||
continue // 没有浏览器可执行文件，跳过
|
||
}
|
||
isDefault := len(cores) == 0
|
||
cores = append(cores, browser.Core{
|
||
CoreId: fmt.Sprintf("core-%s", entry.Name()),
|
||
CoreName: fmt.Sprintf("Chrome %s", entry.Name()),
|
||
CorePath: subPath,
|
||
IsDefault: isDefault,
|
||
})
|
||
log.Debug("发现内核", logger.F("name", entry.Name()), logger.F("path", subPath))
|
||
}
|
||
return cores
|
||
}
|
||
|
||
// ============================================================================
|
||
// 代理数据加载
|
||
// ============================================================================
|
||
|
||
// loadProxies 启动时加载代理数据。
|
||
// 优先从 ProxyDAO（SQLite）读取；若 DAO 未注入则降级到 proxies.yaml，最后降级到 config.yaml。
|
||
func (a *App) loadProxies() {
|
||
log := logger.New("Browser")
|
||
|
||
builtins := []browser.Proxy{
|
||
{ProxyId: "__direct__", ProxyName: "直连（不走代理）", ProxyConfig: "direct://"},
|
||
}
|
||
|
||
ensureBuiltins := func(list []browser.Proxy) []browser.Proxy {
|
||
for _, b := range builtins {
|
||
found := false
|
||
for _, p := range list {
|
||
if p.ProxyId == b.ProxyId {
|
||
found = true
|
||
break
|
||
}
|
||
}
|
||
if !found {
|
||
list = append([]browser.Proxy{b}, list...)
|
||
}
|
||
}
|
||
return list
|
||
}
|
||
|
||
// 优先从 SQLite 读取
|
||
if a.browserMgr.ProxyDAO != nil {
|
||
list, err := a.browserMgr.ProxyDAO.List()
|
||
if err != nil {
|
||
log.Error("从数据库读取代理失败", logger.F("error", err.Error()))
|
||
} else if len(list) > 0 {
|
||
a.config.Browser.Proxies = list
|
||
log.Info("代理数据从数据库加载完成", logger.F("count", len(list)))
|
||
return
|
||
}
|
||
}
|
||
|
||
// 降级：从 proxies.yaml 加载
|
||
loaded, err := config.LoadProxies(a.resolveAppPath("proxies.yaml"))
|
||
if err != nil {
|
||
log.Warn("读取 proxies.yaml 失败", logger.F("error", err.Error()))
|
||
}
|
||
if loaded != nil {
|
||
proxies := ensureBuiltins(loaded)
|
||
a.config.Browser.Proxies = proxies
|
||
log.Info("代理数据从 proxies.yaml 加载完成", logger.F("count", len(proxies)))
|
||
return
|
||
}
|
||
|
||
// 最终降级：使用 config.yaml 中的数据
|
||
proxies := ensureBuiltins(a.config.Browser.Proxies)
|
||
a.config.Browser.Proxies = proxies
|
||
log.Info("代理数据使用 config.yaml 默认值", logger.F("count", len(proxies)))
|
||
}
|