Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

10.1 KB
Raw Blame
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later

package model

import (
	"crypto/sha256"
	"encoding/binary"
	"fmt"
	"net"
	"path/filepath"
	"strings"
	"sync"
	"time"

	"github.com/siyuan-note/dejavu"
	"github.com/siyuan-note/dejavu/lansync"
	"github.com/siyuan-note/logging"
	"github.com/siyuan-note/siyuan/kernel/conf"
	"github.com/siyuan-note/siyuan/kernel/util"
)

var (
	lanSyncLifecycleMu  sync.Mutex
	lanSyncRetryTimer   *time.Timer
	lanSyncShuttingDown bool

	lanSyncManagerMu sync.RWMutex
	lanSyncManager   *lansync.Manager
	lanSyncConfig    *lanSyncRuntimeConfig

	lanSyncHintMu       sync.Mutex
	lastLANSyncHintID   string
	lastLANSyncSchedule time.Time
)

type lanSyncRuntimeConfig struct {
	repoKeyHash       [sha256.Size]byte
	scope             string
	deviceName        string
	deviceOS          string
	appVersion        string
	maxConcurrentReqs int
	nativeDiscovery   bool
}

func refreshLANSyncManager() {
	refreshLANSyncManagerWithForce(false)
}

func refreshLANSyncManagerWithForce(force bool) {
	confRepoReadSnapshot := Conf.LoadRepo()

	confSyncReadSnapshot := Conf.LoadSync()

	confSystemReadSnapshot := Conf.LoadSystem()

	lanSyncLifecycleMu.Lock()
	defer lanSyncLifecycleMu.Unlock()
	if lanSyncShuttingDown {
		return
	}
	if nil == Conf || nil == confSyncReadSnapshot || nil == confSyncReadSnapshot.LAN || !confSyncReadSnapshot.LAN.Enabled || !confSyncReadSnapshot.Enabled ||
		1 > len(confRepoReadSnapshot.Key) || util.ContainerDocker == util.Container {
		stopLANSyncManagerLocked()
		return
	}
	nativeDiscovery := util.ContainerIOS == util.Container || util.ContainerHarmony == util.Container
	config := &lanSyncRuntimeConfig{
		repoKeyHash:       sha256.Sum256(confRepoReadSnapshot.Key),
		scope:             lanSyncScope(),
		deviceName:        confSystemReadSnapshot.Name,
		deviceOS:          confSystemReadSnapshot.OS,
		appVersion:        util.Ver,
		maxConcurrentReqs: confSyncReadSnapshot.LAN.MaxConcurrentReqs,
		nativeDiscovery:   nativeDiscovery,
	}
	lanSyncManagerMu.RLock()
	manager := lanSyncManager
	lanSyncManagerMu.RUnlock()
	if !force && nil != manager && nil != lanSyncConfig && *config == *lanSyncConfig {
		return
	}
	stopLANSyncManagerLocked()
	ips := collectLANSyncIPs()
	if 1 > len(ips) && !nativeDiscovery {
		logging.LogWarnf("LAN sync service not started because no private network address is available")
		scheduleLANSyncRetryLocked()
		return
	}
	manager, err := lansync.Start(lansync.Config{
		RepoPath:          util.RepoDir,
		IdentityPath:      filepath.Join(util.ConfDir, "lan-sync-identity.json"),
		RepoKey:           append([]byte(nil), confRepoReadSnapshot.Key...),
		Scope:             config.scope,
		DeviceName:        confSystemReadSnapshot.Name,
		DeviceOS:          confSystemReadSnapshot.OS,
		AppVersion:        util.Ver,
		IPs:               ips,
		IPsProvider:       collectLANSyncIPs,
		MaxConcurrentReqs: confSyncReadSnapshot.LAN.MaxConcurrentReqs,
		NativeDiscovery:   nativeDiscovery,
		OnCommitHint:      handleLANSyncCommitHint,
	})
	if nil != err {
		logging.LogWarnf("start LAN sync service failed: %s", err)
		scheduleLANSyncRetryLocked()
		return
	}
	lanSyncManagerMu.Lock()
	lanSyncManager = manager
	lanSyncConfig = config
	lanSyncManagerMu.Unlock()
}

func lanSyncScope() string {
	confSyncSnapshot := Conf.LoadSync()

	cloudName := confSyncSnapshot.CloudName
	if conf.ProviderS3 == confSyncSnapshot.Provider {
		// S3 只使用存储桶定位仓库,v1 作用域中的目录槽位固定为存储桶名。
		cloudName = ""
		if nil != confSyncSnapshot.S3 {
			cloudName = confSyncSnapshot.S3.Bucket
		}
	}
	base := fmt.Sprintf("v1:%d:%s", confSyncSnapshot.Provider, cloudName)
	switch confSyncSnapshot.Provider {
	case conf.ProviderSiYuan:
		userID := ""
		if user := Conf.GetUser(); nil != user {
			userID = user.UserId
		}
		return fmt.Sprintf("%s:%d:%s", base, util.CurrentCloudRegion, userID)
	case conf.ProviderS3:
		if nil != confSyncSnapshot.S3 {
			return fmt.Sprintf("%s:%s:%s:%s", base, confSyncSnapshot.S3.Endpoint, confSyncSnapshot.S3.Bucket, confSyncSnapshot.S3.Region)
		}
	case conf.ProviderWebDAV:
		if nil != confSyncSnapshot.WebDAV {
			return fmt.Sprintf("%s:%s", base, confSyncSnapshot.WebDAV.Endpoint)
		}
	case conf.ProviderLocal:
		if nil != confSyncSnapshot.Local {
			return fmt.Sprintf("%s:%s", base, confSyncSnapshot.Local.Endpoint)
		}
	}
	return base
}

func GetLANSyncDiscoveryInfo() *lansync.DiscoveryInfo {
	lanSyncManagerMu.RLock()
	manager := lanSyncManager
	lanSyncManagerMu.RUnlock()
	if nil == manager {
		return nil
	}
	return manager.DiscoveryInfo()
}

func LANSyncActive() bool {
	lanSyncManagerMu.RLock()
	defer lanSyncManagerMu.RUnlock()
	return nil != lanSyncManager
}

func AddLANSyncPeer(instance, address string, port int, txt map[string]string) bool {
	lanSyncManagerMu.RLock()
	manager := lanSyncManager
	lanSyncManagerMu.RUnlock()
	return nil != manager && manager.AddDiscoveredPeer(instance, address, port, txt)
}

func RemoveLANSyncPeer(instance string) bool {
	lanSyncManagerMu.RLock()
	manager := lanSyncManager
	lanSyncManagerMu.RUnlock()
	return nil != manager && manager.RemoveDiscoveredPeer(instance)
}

func stopLANSyncManager() {
	lanSyncLifecycleMu.Lock()
	defer lanSyncLifecycleMu.Unlock()
	lanSyncShuttingDown = true
	stopLANSyncManagerLocked()
}

func suspendLANSyncManager() {
	lanSyncLifecycleMu.Lock()
	defer lanSyncLifecycleMu.Unlock()
	stopLANSyncManagerLocked()
}

func stopLANSyncManagerLocked() {
	if nil != lanSyncRetryTimer {
		lanSyncRetryTimer.Stop()
		lanSyncRetryTimer = nil
	}
	lanSyncManagerMu.Lock()
	manager := lanSyncManager
	lanSyncManager = nil
	lanSyncConfig = nil
	lanSyncManagerMu.Unlock()
	if nil != manager {
		manager.Stop()
	}
}

func scheduleLANSyncRetryLocked() {
	lanSyncRetryTimer = time.AfterFunc(30*time.Second, refreshLANSyncManager)
}

func collectLANSyncIPs() (ret []net.IP) {
	added := map[string]bool{}
	for _, address := range append(util.GetPrivateIPv4s(), util.GetLocalIPs()...) {
		ipAddress := address
		if index := strings.LastIndex(ipAddress, "%"); 0 < index {
			ipAddress = ipAddress[:index]
		}
		ip := net.ParseIP(ipAddress)
		if nil == ip || added[ip.String()] || !(ip.IsPrivate() || ip.IsLinkLocalUnicast()) {
			continue
		}
		added[ip.String()] = true
		ret = append(ret, ip)
	}
	return
}

// RefreshLANSyncNetwork 在原生容器报告网络地址变化后刷新局域网同步服务。
func RefreshLANSyncNetwork() {
	if nil == Conf {
		return
	}
	if util.ContainerHarmony == util.Container {
		refreshLANSyncManagerWithForce(true)
		return
	}
	lanSyncManagerMu.RLock()
	active := nil != lanSyncManager
	lanSyncManagerMu.RUnlock()
	if !active {
		refreshLANSyncManager()
	}
}

func newSyncRepository() (ret *dejavu.Repo, err error) {
	assetDownloadSourceMu.RLock()
	defer assetDownloadSourceMu.RUnlock()
	return newSyncRepositoryWithAssetSourceLocked()
}

// newSyncRepositoryWithAssetSourceLocked 在来源锁保护下创建带局域网分块来源的仓库。
func newSyncRepositoryWithAssetSourceLocked() (ret *dejavu.Repo, err error) {
	ret, err = newCloudRepositoryWithAssetSourceLocked()
	if nil != err {
		return
	}
	lanSyncManagerMu.RLock()
	manager := lanSyncManager
	lanSyncManagerMu.RUnlock()
	if nil != manager {
		ret.SetChunkSource(manager)
	}
	return
}

func notifyLANSyncCommit(repo *dejavu.Repo) {
	lanSyncManagerMu.RLock()
	manager := lanSyncManager
	lanSyncManagerMu.RUnlock()
	if nil == manager {
		return
	}
	latest, err := repo.Latest()
	if nil != err || "" == latest.ID {
		return
	}
	manager.NotifyCloudCommit(latest.ID)
}

func handleLANSyncCommitHint(latestID string) {
	if nil == Conf.Sync.Load() || nil == Conf.Sync.Load().LAN || !Conf.Sync.Load().LAN.Enabled || !Conf.Sync.Load().Enabled || 1 != Conf.Sync.Load().Mode {
		return
	}
	lanSyncHintMu.Lock()
	if latestID == lastLANSyncHintID && time.Since(lastLANSyncSchedule) < time.Minute {
		lanSyncHintMu.Unlock()
		return
	}
	lastLANSyncHintID = latestID
	lastLANSyncSchedule = time.Now()
	lanSyncHintMu.Unlock()
	hash := sha256.Sum256([]byte(Conf.System.Load().ID + ":" + latestID))
	delay := time.Second + time.Duration(binary.BigEndian.Uint32(hash[:4])%5000)*time.Millisecond
	time.AfterFunc(delay, func() {
		confSyncSnapshot := Conf.LoadSync()

		if nil != confSyncSnapshot && nil != confSyncSnapshot.LAN && confSyncSnapshot.LAN.Enabled && confSyncSnapshot.Enabled && 1 == confSyncSnapshot.Mode {
			syncDataFromLAN(latestID)
		}
	})
}

func syncDataFromLAN(latestID string) {
	defer logging.Recover()
	if !checkSync(false, false, false) {
		return
	}
	scope := lanSyncScope()
	syncDataFromRemote(scope, latestID)
}

func SetSyncLAN(enabled bool, maxConcurrentReqs int) {
	UpdateSyncConf(func(sync *conf.Sync) {
		if nil == sync.LAN {
			sync.LAN = &conf.LANSync{}
		}
		if 1 > maxConcurrentReqs {
			// 未指定并发数时沿用当前值,越界值由同步配置规范化处理
			maxConcurrentReqs = sync.LAN.MaxConcurrentReqs
		}
		sync.LAN.Enabled = enabled
		sync.LAN.MaxConcurrentReqs = maxConcurrentReqs
		if !enabled {
			sync.Stat = removeLANSyncTrafficStat(sync.Stat)
		}
	})
	refreshLANSyncManager()
}

type SyncLANStatus struct {
	Enabled           bool `json:"enabled"`
	Active            bool `json:"active"`
	DiscoveredPeers   int  `json:"discoveredPeers"`
	ConnectedPeers    int  `json:"connectedPeers"`
	MaxConcurrentReqs int  `json:"maxConcurrentReqs"`
}

func GetSyncLANStatus() SyncLANStatus {
	confSyncSnapshot := Conf.LoadSync()

	lanSyncManagerMu.RLock()
	manager := lanSyncManager
	lanSyncManagerMu.RUnlock()
	discoveredCount := 0
	connectedCount := 0
	if nil != manager {
		connectedCount = manager.ConnectedPeerCount()
		// 已认证设备必然已经被发现,避免两次状态采样之间完成认证时出现数量倒序。
		discoveredCount = max(manager.DiscoveredPeerCount(), connectedCount)
	}
	enabled := false
	maxConcurrentReqs := 16
	if nil != confSyncSnapshot && nil != confSyncSnapshot.LAN {
		enabled = confSyncSnapshot.LAN.Enabled
		maxConcurrentReqs = confSyncSnapshot.LAN.MaxConcurrentReqs
	}
	return SyncLANStatus{
		Enabled:           enabled,
		Active:            nil != manager,
		DiscoveredPeers:   discoveredCount,
		ConnectedPeers:    connectedCount,
		MaxConcurrentReqs: maxConcurrentReqs,
	}
}