An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
// 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,
}
}