Skip to content

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

:bug: Preserve configuration snapshot isolation and save confirmation https://github.com/siyuan-note/siyuan/issues/20443

Daniel3ef2c223f23e
diff --git a/app/src/config/setting/sync.test.ts b/app/src/config/setting/sync.test.ts
index 8d5c4e75ae..b68dbda82f 100644
--- a/app/src/config/setting/sync.test.ts
+++ b/app/src/config/setting/sync.test.ts
@@ -292,7 +292,7 @@ for (const mobile of [false, true]) {
assert.equal(remounted.filter(tab => tab === "access").length, mobile ? 0 : 1);
failed = true;
next = {...next, api: {token: "unconfirmed-token"}};
- await exports.refreshSettingConfig("system");
+ await assert.rejects(exports.refreshSettingConfig("system"), /Could not refresh settings/);
assert.equal(config.api.token, "latest-token");
});
diff --git a/app/src/config/setting/sync.ts b/app/src/config/setting/sync.ts
index 33fb728d76..463175c6cd 100644
--- a/app/src/config/setting/sync.ts
+++ b/app/src/config/setting/sync.ts
@@ -48,7 +48,10 @@ export const refreshSettingConfig = (namespace = "*"): Promise<void> => {
const namespaces = pending;
pending = new Set();
const response = await fetchSyncPost("/api/system/getConf", {});
- if (response.code !== 0 || !window.siyuan.config) {
+ if (response.code !== 0) {
+ throw new Error(response.msg || "Could not refresh settings");
+ }
+ if (!window.siyuan.config) {
continue;
}
const next = systemConfig(response.data.conf);
@@ -112,9 +115,10 @@ export const refreshSettingConfig = (namespace = "*"): Promise<void> => {
remountTabs.forEach(tab => { void remountOpenSettingTab(tab); });
/// #endif
}
- })().catch(error => console.error("Could not refresh settings", error)).finally(() => {
+ })().finally(() => {
refreshing = undefined;
if (pending.size) return refreshSettingConfig();
});
+ void refreshing.catch(error => console.error("Could not refresh settings", error));
return refreshing;
};
diff --git a/app/src/config/util/configApi.test.ts b/app/src/config/util/configApi.test.ts
index 8bd118eba1..6e625265cf 100644
--- a/app/src/config/util/configApi.test.ts
+++ b/app/src/config/util/configApi.test.ts
@@ -5,7 +5,7 @@ import {runInNewContext} from "node:vm";
import {ModuleKind, transpileModule} from "typescript";
import {mergeRecordByDottedPath} from "./dotPath";
-const fixture = () => {
+const fixture = (failRefresh = false) => {
const memory = {editor: {fontSize: 16, markdown: {inlineMath: true}}, sync: {interval: 30}};
const requests: Array<{body: any; resolve: (response: any) => void}> = [];
const exports = {} as typeof import("./configApi");
@@ -19,6 +19,10 @@ const fixture = () => {
if (name === "../setting/pending") return {trackSettingSave: (operation: Promise<void>) => operation};
if (name === "../setting/sync") return {refreshSettingConfigAfter: async (namespace: keyof typeof memory, save: () => Promise<boolean>) => {
if (!await save()) return false;
+ if (failRefresh) {
+ failRefresh = false;
+ throw new Error("configuration refresh failed");
+ }
if (namespace === "editor") memory.editor.fontSize = 24;
return true;
}};
@@ -69,3 +73,21 @@ test("config.set allows independent namespaces and retries after a rejected save
f.requests[2].resolve({code: 0});
await retry;
});
+
+test("config.set rejects an unconfirmed refresh without its callback and continues the queue", async () => {
+ const f = fixture(true);
+ let applied = false;
+ const first = f.config.set("editor.fontSize", 20, () => { applied = true; });
+ const second = f.config.set("editor.fontSize", 24);
+ const rejected = assert.rejects(first, /configuration refresh failed/);
+ await settle();
+ f.requests[0].resolve({code: 0});
+ await rejected;
+ assert.equal(applied, false);
+ assert.equal(f.config.get("editor.fontSize"), 16);
+ await settle();
+ assert.equal(f.requests.length, 2);
+ f.requests[1].resolve({code: 0});
+ await second;
+ assert.equal(f.config.get("editor.fontSize"), 24);
+});
diff --git a/app/src/config/util/sectionRuntime.test.ts b/app/src/config/util/sectionRuntime.test.ts
index 13c2631b98..a517a32083 100644
--- a/app/src/config/util/sectionRuntime.test.ts
+++ b/app/src/config/util/sectionRuntime.test.ts
@@ -25,3 +25,21 @@ test("reactions compare coherent snapshots and finish asynchronous actions befor
await runtime.apply(current);
assert.deepEqual(events, ["font", "complete"]);
});
+
+test("dependent reactions wait for previous asynchronous actions in declaration order", async () => {
+ let current = 1;
+ let finish: () => void;
+ const events: string[] = [];
+ const runtime = createSectionRuntime({namespace: "editor", get: () => current, set: next => { current = next; },
+ reactions: [{name: "styles", changed: () => true, apply: async () => {
+ events.push("styles");
+ await new Promise<void>(resolve => { finish = resolve; });
+ events.push("styles loaded");
+ }}, {name: "measure", changed: () => true, apply: () => { events.push("measure"); }}],
+ });
+ const pending = runtime.apply(2);
+ assert.deepEqual(events, ["styles"]);
+ finish();
+ await pending;
+ assert.deepEqual(events, ["styles", "styles loaded", "measure"]);
+});
diff --git a/app/src/config/util/sectionRuntime.ts b/app/src/config/util/sectionRuntime.ts
index d3d8d1f2a6..2d6ca913b6 100644
--- a/app/src/config/util/sectionRuntime.ts
+++ b/app/src/config/util/sectionRuntime.ts
@@ -15,7 +15,19 @@ export const createSectionRuntime = <T>(options: {
const old = options.get();
const reactions = options.reactions.filter(reaction => reaction.changed(old, next));
const applied = options.set(next);
- const applyReactions = () => Promise.all(reactions.map(reaction => reaction.apply(old, next))).then(() => {});
+ const applyReactions = () => {
+ let pending: Promise<void>;
+ for (const reaction of reactions) {
+ const run = () => reaction.apply(old, next);
+ if (pending) {
+ pending = pending.then(run);
+ } else {
+ const applied = run();
+ if (applied) pending = applied;
+ }
+ }
+ return pending || Promise.resolve();
+ };
return applied ? applied.then(applyReactions) : applyReactions();
},
});
diff --git a/app/src/types/api/index.d.ts b/app/src/types/api/index.d.ts
index f8f1ffb5f4..cfdf707cc4 100644
--- a/app/src/types/api/index.d.ts
+++ b/app/src/types/api/index.d.ts
@@ -6576,7 +6576,9 @@ export interface APIPOSTRoutes {
};
/**
* 保留省略字段,成功后客户端重新读取配置;通知不包含密码或密钥。
- * export.blockRefMode 的废弃值 0、1、5 在保存前转换为 4,与启动时的转换规则一致。
+ * export.blockRefMode 的旧值 0、1、5 按旧设置接口的兼容语义转换为 4;启动迁移由配置版本控制。
+ * 同步地址沿用专用保存接口的校验,更换来源须保留完整资源检查,间隔使用规范化后的值调度。
+ * 存在字段诊断时在 data.issues 返回;error 阻止写入,warning 随已规范化的成功结果返回。
*/
"/api/setting/patch": {
request: PatchSettingRequestInput;
diff --git a/kernel/agent/agent.go b/kernel/agent/agent.go
index 3ac6aef971..68b2b3277b 100644
--- a/kernel/agent/agent.go
+++ b/kernel/agent/agent.go
@@ -494,6 +494,8 @@ func AgentChat(ctx context.Context, client *util.AIClient, protocol, model, imag
language string, references []Reference, editorCtx EditorContext, frontendCapabilities []FrontendCapability,
regenerate bool, confirmTimeout time.Duration, maxRetries int, reasoningEffort string,
requestTimeout, streamIdleTimeout time.Duration) <-chan AgentEvent {
+ confAIReadSnapshot := kernelModel.Conf.LoadAI()
+
ch := make(chan AgentEvent, 256)
go func() {
@@ -517,8 +519,8 @@ func AgentChat(ctx context.Context, client *util.AIClient, protocol, model, imag
return
}
- if kernelModel.Conf.AI.Load().MCP != nil {
- mcpclient.EnsureMCPConnected(kernelModel.Conf.AI.Load().MCP.Servers)
+ if confAIReadSnapshot.MCP != nil {
+ mcpclient.EnsureMCPConnected(confAIReadSnapshot.MCP.Servers)
}
select {
case <-ctx.Done():
@@ -713,12 +715,12 @@ func AgentChat(ctx context.Context, client *util.AIClient, protocol, model, imag
}
}()
- temperature := kernelModel.Conf.AI.Load().Agent.Temperature
+ temperature := confAIReadSnapshot.Agent.Temperature
if temperature < 0 || 2 < temperature {
temperature = 1.0
}
- maxCompletionTokens := max(kernelModel.Conf.AI.Load().Agent.MaxCompletionTokens, 0)
- maxRounds := kernelModel.Conf.AI.Load().Agent.MaxToolCallRounds
+ maxCompletionTokens := max(confAIReadSnapshot.Agent.MaxCompletionTokens, 0)
+ maxRounds := confAIReadSnapshot.Agent.MaxToolCallRounds
modelRound := 0
toolCallRounds := 0
overflowRetryPending := false
diff --git a/kernel/agent/capability.go b/kernel/agent/capability.go
index 644f01027c..f4466bf0dc 100644
--- a/kernel/agent/capability.go
+++ b/kernel/agent/capability.go
@@ -74,10 +74,12 @@ type capabilityAuthorizer interface {
type configCapabilityAuthorizer struct{}
func (configCapabilityAuthorizer) Allows(id string, _ capabilityAccessContext) bool {
- if kernelModel.Conf == nil || kernelModel.Conf.AI.Load() == nil || kernelModel.Conf.AI.Load().Agent == nil {
+ confAIReadSnapshot := kernelModel.Conf.LoadAI()
+
+ if kernelModel.Conf == nil || confAIReadSnapshot == nil || confAIReadSnapshot.Agent == nil {
return true
}
- return kernelModel.Conf.AI.Load().Agent.CapabilityPolicy.Allows(id)
+ return confAIReadSnapshot.Agent.CapabilityPolicy.Allows(id)
}
var currentCapabilityAuthorizer capabilityAuthorizer = configCapabilityAuthorizer{}
@@ -89,10 +91,12 @@ type capabilityApprover interface {
type configCapabilityApprover struct{}
func (configCapabilityApprover) Decision(id, action string, _ capabilityAccessContext) string {
- if kernelModel.Conf == nil || kernelModel.Conf.AI.Load() == nil || kernelModel.Conf.AI.Load().Agent == nil {
+ confAIReadSnapshot := kernelModel.Conf.LoadAI()
+
+ if kernelModel.Conf == nil || confAIReadSnapshot == nil || confAIReadSnapshot.Agent == nil {
return conf.ApprovalDecisionRisk
}
- return kernelModel.Conf.AI.Load().Agent.ApprovalPolicy.Decision(id, action)
+ return confAIReadSnapshot.Agent.ApprovalPolicy.Decision(id, action)
}
var currentCapabilityApprover capabilityApprover = configCapabilityApprover{}
@@ -170,16 +174,18 @@ func capabilityAllowed(id string, context capabilityAccessContext) bool {
}
func capabilityOwnerAvailable(source, runtime, ownerID string) bool {
+ confAIReadSnapshot := kernelModel.Conf.LoadAI()
+
if source != "mcp" && runtime != "mcp" {
return true
}
if ownerID == "" {
return true
}
- if kernelModel.Conf == nil || kernelModel.Conf.AI.Load() == nil || kernelModel.Conf.AI.Load().MCP == nil {
+ if kernelModel.Conf == nil || confAIReadSnapshot == nil || confAIReadSnapshot.MCP == nil {
return false
}
- for _, server := range kernelModel.Conf.AI.Load().MCP.Servers {
+ for _, server := range confAIReadSnapshot.MCP.Servers {
if server.ID == ownerID {
return server.Enabled
}
diff --git a/kernel/api/contract_sync_test.go b/kernel/api/contract_sync_test.go
index 7dc22572c5..644df8865b 100644
--- a/kernel/api/contract_sync_test.go
+++ b/kernel/api/contract_sync_test.go
@@ -343,8 +343,8 @@ func TestAPIContractSyncProviderExportContents(t *testing.T) {
func TestAPIContractSyncWebDAVImportAddressValidation(t *testing.T) {
syncTestConfiguration(t)
previous := &conf.WebDAV{Endpoint: "https://dav.example", Username: "user", Password: "secret"}
- model.Conf.Sync.WebDAV = previous
- model.Conf.Sync.Enabled = true
+ model.Conf.Sync.Load().WebDAV = previous
+ model.Conf.Sync.Load().Enabled = true
engine := gin.New()
const path = "/api/sync/importSyncProviderWebDAV"
engine.POST(path, importSyncProviderWebDAV)
@@ -372,7 +372,7 @@ func TestAPIContractSyncWebDAVImportAddressValidation(t *testing.T) {
if err = json.Unmarshal(recorder.Body.Bytes(), &response); err != nil || response.Code != -1 {
t.Fatalf("invalid imported address %q was accepted: %s (%v)", endpoint, recorder.Body.String(), err)
}
- if model.Conf.Sync.WebDAV != previous || !model.Conf.Sync.Enabled {
+ if model.Conf.Sync.Load().WebDAV != previous || !model.Conf.Sync.Load().Enabled {
t.Fatal("rejected import replaced the existing configuration")
}
}
diff --git a/kernel/apicontract/contracts.go b/kernel/apicontract/contracts.go
index 6788196863..1df748ac16 100644
--- a/kernel/apicontract/contracts.go
+++ b/kernel/apicontract/contracts.go
@@ -1092,7 +1092,9 @@ var SetFlashcard = define[SetFlashcardRequest, *SettingFlashcard]("setFlashcard"
var SetEditor = define[SetEditorRequest, *SettingEditor]("setEditor", "/api/setting/setEditor", AuthenticatedAccess|AdminAccess|WritableAccess, JSONBody, ResponseOptions{Setting: SettingWrite{Namespace: "editor"}}, "POST")
// PatchSetting 保留省略字段,成功后客户端重新读取配置;通知不包含密码或密钥。
-// export.blockRefMode 的废弃值 0、1、5 在保存前转换为 4,与启动时的转换规则一致。
+// export.blockRefMode 的旧值 0、1、5 按旧设置接口的兼容语义转换为 4;启动迁移由配置版本控制。
+// 同步地址沿用专用保存接口的校验,更换来源须保留完整资源检查,间隔使用规范化后的值调度。
+// 存在字段诊断时在 data.issues 返回;error 阻止写入,warning 随已规范化的成功结果返回。
var PatchSetting = define[PatchSettingRequest, *SettingPatchData]("patchSetting", "/api/setting/patch", AuthenticatedAccess|AdminAccess|WritableAccess, JSONBody, ResponseOptions{DataOnError: true, Setting: SettingWrite{Namespace: "*", Mode: SettingSelfManaged}}, "POST")
// SetExport 整体替换导出配置,将 blockRefMode 的废弃值 0、1、5 转换为 4 后同步保存并回显。
diff --git a/kernel/mcp/server.go b/kernel/mcp/server.go
index 5d581ece14..751e69fd87 100644
--- a/kernel/mcp/server.go
+++ b/kernel/mcp/server.go
@@ -140,13 +140,15 @@ func RefreshToolExposure() {
}
func externalMCPToolAllowed(tool *tools.Tool) bool {
+ confAIReadSnapshot := model.Conf.LoadAI()
+
if tool == nil || tool.AgentOnly || tool.Source == "mcp" || tool.Runtime == "mcp" {
return false
}
- if model.Conf == nil || model.Conf.AI.Load() == nil || model.Conf.AI.Load().MCP == nil {
+ if model.Conf == nil || confAIReadSnapshot == nil || confAIReadSnapshot.MCP == nil {
return true
}
- return model.Conf.AI.Load().MCP.ExposurePolicy.Allows(tools.CapabilityIDForTool(tool))
+ return confAIReadSnapshot.MCP.ExposurePolicy.Allows(tools.CapabilityIDForTool(tool))
}
func newServer() *mcpsdk.Server {
diff --git a/kernel/mcp/tools/bazaar.go b/kernel/mcp/tools/bazaar.go
index 22412139b4..88e070f58d 100644
--- a/kernel/mcp/tools/bazaar.go
+++ b/kernel/mcp/tools/bazaar.go
@@ -76,6 +76,8 @@ func init() {
}
func bazaarHandler(ctx context.Context, args map[string]any) (CallToolResult, error) {
+ confBazaarReadSnapshot := model.Conf.LoadBazaar()
+
// 直接调用处理函数时也保留校验,避免无效参数进入集市实现。
tool, validator := LookupToolWithValidator("bazaar")
if err := validator.ValidateInput(args); err != nil {
@@ -114,7 +116,7 @@ func bazaarHandler(ctx context.Context, args map[string]any) (CallToolResult, er
if err := ctx.Err(); err != nil {
return blockToolError(err.Error())
}
- if model.Conf == nil || model.Conf.Bazaar.Load() == nil {
+ if model.Conf == nil || confBazaarReadSnapshot == nil {
return blockToolError("Bazaar configuration is unavailable")
}
// 请求入口负责管理员鉴权;执行前再次检查只读模式与集市开关。
@@ -125,10 +127,10 @@ func bazaarHandler(ctx context.Context, args map[string]any) (CallToolResult, er
if isPluginProjectAction(action) {
return bazaarPluginProjectAction(ctx, action, args)
}
- if action != "installed" && !model.Conf.Bazaar.Load().Trust {
+ if action != "installed" && !confBazaarReadSnapshot.Trust {
return blockToolError("Bazaar is not trusted; enable Bazaar access in SiYuan settings first")
}
- if effects.LocalWrite && pkgType == "plugins" && model.Conf.Bazaar.Load().PetalDisabled {
+ if effects.LocalWrite && pkgType == "plugins" && confBazaarReadSnapshot.PetalDisabled {
return blockToolError("plugins are globally disabled")
}
var summaries []bazaarPackageSummary
@@ -251,7 +253,7 @@ func bazaarHandler(ctx context.Context, args map[string]any) (CallToolResult, er
if err != nil {
return bazaarProjectError(err, nil)
}
- if model.Conf.Bazaar.Load().PetalDisabled {
+ if confBazaarReadSnapshot.PetalDisabled {
// 插件全局禁用时先识别归档,其他类型仍可正常安装。
localType, _, _, cleanup, err := bazaar.ExtractLocalPackage(archive)
if cleanup != nil {
diff --git a/kernel/mcp/tools/http_request.go b/kernel/mcp/tools/http_request.go
index a3e6df651a..8adf967db5 100644
--- a/kernel/mcp/tools/http_request.go
+++ b/kernel/mcp/tools/http_request.go
@@ -59,6 +59,8 @@ func init() {
}
func httpRequestHandler(args map[string]any) (CallToolResult, error) {
+ confVariablesReadSnapshot := model.Conf.LoadVariables()
+
action, _ := args["action"].(string)
rawURL, _ := args["url"].(string)
@@ -74,13 +76,13 @@ func httpRequestHandler(args map[string]any) (CallToolResult, error) {
// 智能体/MCP 客户端控制,插值密钥会让明文被发送到任意公网主机。
// headers/body 中的密钥插值按目标主机限定(见 ResolveSecretsVarsForHost),
// 只有目标主机在密钥的允许主机列表内才插值,密钥明文只进入出站请求,不进入 LLM 上下文。
- rawURL = model.Conf.Variables.Load().Resolve(rawURL)
+ rawURL = confVariablesReadSnapshot.Resolve(rawURL)
host := ""
if u, err := url.Parse(rawURL); err == nil {
host = u.Hostname()
}
resolve := func(s string) string {
- return conf.ResolveSecretsVarsForHost(model.Conf.Secrets.Load(), model.Conf.Variables.Load(), host, s)
+ return conf.ResolveSecretsVarsForHost(model.Conf.Secrets.Load(), confVariablesReadSnapshot, host, s)
}
for k, v := range headers {
headers[k] = resolve(v)
diff --git a/kernel/model/ai.go b/kernel/model/ai.go
index 85fed0ca73..aeb6b737e6 100644
--- a/kernel/model/ai.go
+++ b/kernel/model/ai.go
@@ -33,17 +33,21 @@ import (
)
func EnabledUserSkills() []string {
- if Conf == nil || Conf.AI.Load() == nil || Conf.AI.Load().Agent == nil || Conf.AI.Load().Agent.Skills == nil {
+ confAIReadSnapshot := Conf.LoadAI()
+
+ if Conf == nil || confAIReadSnapshot == nil || confAIReadSnapshot.Agent == nil || confAIReadSnapshot.Agent.Skills == nil {
return nil
}
- return append([]string(nil), Conf.AI.Load().Agent.Skills.UserEnabled...)
+ return append([]string(nil), confAIReadSnapshot.Agent.Skills.UserEnabled...)
}
func DisabledBuiltinSkills() []string {
- if Conf == nil || Conf.AI.Load() == nil || Conf.AI.Load().Agent == nil || Conf.AI.Load().Agent.Skills == nil {
+ confAIReadSnapshot := Conf.LoadAI()
+
+ if Conf == nil || confAIReadSnapshot == nil || confAIReadSnapshot.Agent == nil || confAIReadSnapshot.Agent.Skills == nil {
return nil
}
- return append([]string(nil), Conf.AI.Load().Agent.Skills.BuiltinDisabled...)
+ return append([]string(nil), confAIReadSnapshot.Agent.Skills.BuiltinDisabled...)
}
func ChatGPT(msg string) (ret string) {
diff --git a/kernel/model/appearance.go b/kernel/model/appearance.go
index a157216c3b..8e675d1167 100644
--- a/kernel/model/appearance.go
+++ b/kernel/model/appearance.go
@@ -348,22 +348,24 @@ func isCurrentUseTheme(themePath string) string {
}
func currentThemeDir() string {
+ confAppearanceReadSnapshot := Conf.LoadAppearance()
+
if nil == Conf {
return ""
}
Conf.m.RLock()
defer Conf.m.RUnlock()
- if nil == Conf.Appearance.Load() {
+ if nil == confAppearanceReadSnapshot {
return ""
}
var themeName string
- switch Conf.Appearance.Load().Mode {
+ switch confAppearanceReadSnapshot.Mode {
case 0:
- themeName = Conf.Appearance.Load().ThemeLight
+ themeName = confAppearanceReadSnapshot.ThemeLight
case 1:
- themeName = Conf.Appearance.Load().ThemeDark
+ themeName = confAppearanceReadSnapshot.ThemeDark
default:
return ""
}
diff --git a/kernel/model/assets.go b/kernel/model/assets.go
index 667a11bfd0..044b519590 100644
--- a/kernel/model/assets.go
+++ b/kernel/model/assets.go
@@ -516,10 +516,12 @@ func PrepareAgentMessageImage(assetPath string) (PreparedDocumentImage, error) {
// GenerateImage 使用全局图片生成配置创建图片字节,可供文档资源、编辑器和其他图片入口复用。
func GenerateImage(ctx context.Context, request GenerateImageRequest) (GenerateImageResult, error) {
- if Conf == nil || Conf.AI.Load() == nil {
+ confAIReadSnapshot := Conf.LoadAI()
+
+ if Conf == nil || confAIReadSnapshot == nil {
return GenerateImageResult{}, errors.New("AI configuration is unavailable")
}
- provider, generationModel := Conf.AI.Load().GetImageGenerationModel()
+ provider, generationModel := confAIReadSnapshot.GetImageGenerationModel()
if err := validateImageModel(provider, generationModel); err != nil {
return GenerateImageResult{}, err
}
@@ -527,14 +529,14 @@ func GenerateImage(ctx context.Context, request GenerateImageRequest) (GenerateI
if prompt == "" {
return GenerateImageResult{}, errors.New("prompt is required for image generation")
}
- size := multimodalValueOrDefault(request.Size, Conf.AI.Load().ImageGeneration.Size)
- quality := multimodalValueOrDefault(request.Quality, Conf.AI.Load().ImageGeneration.Quality)
- outputFormat := strings.ToLower(multimodalValueOrDefault(request.OutputFormat, Conf.AI.Load().ImageGeneration.OutputFormat))
+ size := multimodalValueOrDefault(request.Size, confAIReadSnapshot.ImageGeneration.Size)
+ quality := multimodalValueOrDefault(request.Quality, confAIReadSnapshot.ImageGeneration.Quality)
+ outputFormat := strings.ToLower(multimodalValueOrDefault(request.OutputFormat, confAIReadSnapshot.ImageGeneration.OutputFormat))
if outputFormat != "png" && outputFormat != "jpeg" && outputFormat != "webp" {
return GenerateImageResult{}, errors.New("unsupported image output format")
}
generated, err := util.NewOpenAIImageAdapter(
- provider.APIKey, provider.BaseURL, generationModel.Name, Conf.AI.Load().ImageGeneration.RequestTimeout, ResolveAIProviderHeaders(provider),
+ provider.APIKey, provider.BaseURL, generationModel.Name, confAIReadSnapshot.ImageGeneration.RequestTimeout, ResolveAIProviderHeaders(provider),
).Generate(ctx, util.GenerateImageRequest{
Prompt: prompt, Size: size, Quality: quality, OutputFormat: outputFormat,
})
diff --git a/kernel/model/conf_patch.go b/kernel/model/conf_patch.go
index 99402b9bfd..6f9dbfb5a5 100644
--- a/kernel/model/conf_patch.go
+++ b/kernel/model/conf_patch.go
@@ -45,11 +45,18 @@ func MergeConfJSON(base, patch []byte) ([]byte, error) {
func (spec *SectionSpec[C]) patch(patch []byte) ([]Issue, error) {
spec.WriteLock.Lock()
defer spec.WriteLock.Unlock()
- next, err := mergeConfSection(spec.Load(), patch)
- if err != nil {
- return nil, err
+ for {
+ old := spec.Load()
+ next, err := mergeConfSection(old, patch)
+ if err != nil {
+ return nil, err
+ }
+ issues, err := applySectionLockedAt(spec, next, old, true)
+ if errors.Is(err, errConfSectionChanged) {
+ continue
+ }
+ return issues, err
}
- return applySectionLocked(spec, next)
}
func mergeConfSection[C any](current C, patch []byte) (next C, err error) {
@@ -77,35 +84,37 @@ func ApplyConfPatch(namespace string, patch []byte) ([]Issue, error) {
func ApplySyncSettingPatch(patch []byte) ([]Issue, error) {
release := lockAssetSourceChange()
defer release()
- spec := newSectionSpec("sync", &Conf.Sync, conf.NormalizeSync)
- spec.WriteLock.Lock()
- defer spec.WriteLock.Unlock()
+ spec := syncSectionSpec()
old := spec.Load()
next, err := mergeConfSection(old, patch)
if err != nil {
return nil, err
}
+ var requested map[string]json.RawMessage
+ if err = json.Unmarshal(patch, &requested); err != nil {
+ return nil, err
+ }
if next.Provider != old.Provider {
return nil, errors.New("use setSyncProvider to change the sync provider")
}
if util.ContainerDocker == util.Container {
next.Perception = false
}
- if !reflect.DeepEqual(old.S3, next.S3) {
+ if _, present := requested["s3"]; present || !reflect.DeepEqual(old.S3, next.S3) {
if err = validateSyncS3(next.S3); err != nil {
return nil, err
}
}
- if !reflect.DeepEqual(old.WebDAV, next.WebDAV) {
- if next.WebDAV == nil {
- return nil, errors.New("invalid WebDAV configuration")
+ if _, present := requested["webdav"]; present || !reflect.DeepEqual(old.WebDAV, next.WebDAV) {
+ if err = validateSyncWebDAV(next.WebDAV); err != nil {
+ return nil, err
}
if strings.Contains(strings.ToLower(next.WebDAV.Endpoint), "dav.jianguoyun.com") {
return nil, errors.New(Conf.Language(194))
}
}
- if !reflect.DeepEqual(old.Local, next.Local) {
- if err = validateSyncLocal(next.Local); err != nil {
+ if _, present := requested["local"]; present || !reflect.DeepEqual(old.Local, next.Local) {
+ if err = validateSyncLocalPath(next.Local); err != nil {
return nil, err
}
}
@@ -125,6 +134,10 @@ func ApplySyncSettingPatch(patch []byte) ([]Issue, error) {
return nil, err
}
}
+ next = conf.NormalizeSync(next)
+ if old.LAN != nil && old.LAN.Enabled && !next.LAN.Enabled {
+ next.Stat = removeLANSyncTrafficStat(next.Stat)
+ }
sourceChanged := old.CloudName != next.CloudName ||
(old.Provider == conf.ProviderS3 && (next.S3.Endpoint != old.S3.Endpoint || next.S3.Bucket != old.S3.Bucket)) ||
(old.Provider == conf.ProviderWebDAV && (next.WebDAV.Endpoint != old.WebDAV.Endpoint || next.WebDAV.Username != old.WebDAV.Username)) ||
@@ -134,10 +147,26 @@ func ApplySyncSettingPatch(patch []byte) ([]Issue, error) {
return nil, err
}
}
+ // 来源检查可能更新同步运行状态,完成后再取得段写锁并以最新快照重新合并。
+ spec.WriteLock.Lock()
+ defer spec.WriteLock.Unlock()
+ old = spec.Load()
+ next, err = mergeConfSection(old, patch)
+ if err != nil {
+ return nil, err
+ }
+ if util.ContainerDocker == util.Container {
+ next.Perception = false
+ }
+ next = conf.NormalizeSync(next)
+ if old.LAN != nil && old.LAN.Enabled && !next.LAN.Enabled {
+ next.Stat = removeLANSyncTrafficStat(next.Stat)
+ }
issues, err := applySectionLocked(spec, next)
if err != nil {
return issues, err
}
+ next = spec.Load()
refreshLANSyncManager()
if old.Interval != next.Interval {
planSyncAfter(time.Duration(next.Interval) * time.Second)
@@ -152,9 +181,9 @@ func ApplySyncSettingPatch(patch []byte) ([]Issue, error) {
return issues, nil
}
-func validateSyncLocal(local *conf.Local) error {
- if local == nil {
- return errors.New("invalid local sync configuration")
+func validateSyncLocalPath(local *conf.Local) error {
+ if err := validateSyncLocal(local); err != nil {
+ return err
}
absPath, err := filepath.Abs(util.NormalizeLocalPath(local.Endpoint))
if err != nil {
diff --git a/kernel/model/conf_regression_test.go b/kernel/model/conf_regression_test.go
index 6170abb0a1..6e912b163e 100644
--- a/kernel/model/conf_regression_test.go
+++ b/kernel/model/conf_regression_test.go
@@ -181,3 +181,70 @@ func TestConfDirectApplyClonesNestedInputs(t *testing.T) {
t.Fatal("published snapshot still shares nested input data")
}
}
+
+func TestConfOnboardingPreservesPublishedSnapshots(t *testing.T) {
+ prepareConfConsistencyTest(t)
+ normalizeAppConf(Conf)
+ if err := os.MkdirAll(util.DataDir, 0700); err != nil {
+ t.Fatal(err)
+ }
+ completed := &conf.Onboarding{State: conf.OnboardingCompleted, Dismissed: true}
+ Conf.Onboarding.Store(completed)
+ TriggerOnboardingIfEmpty()
+ pending := Conf.Onboarding.Load()
+ if completed.State != conf.OnboardingCompleted || !completed.Dismissed ||
+ pending == completed || pending.State != conf.OnboardingPending || !pending.NewUser {
+ t.Fatal("triggering onboarding changed a published snapshot")
+ }
+ DismissOnboarding()
+ if pending.Dismissed || !Conf.Onboarding.Load().Dismissed {
+ t.Fatal("dismissing onboarding changed a held snapshot")
+ }
+ missing := &conf.Onboarding{State: conf.OnboardingCompleted, NewUser: true, NotebookID: "missing", DocumentID: "missing"}
+ Conf.Onboarding.Store(missing)
+ util.ReadOnly = true
+ if _, _, err := EnsureOnboarding(); err == nil {
+ t.Fatal("read-only workspace created onboarding data")
+ }
+ if missing.State != conf.OnboardingCompleted || missing.NotebookID != "missing" ||
+ Conf.Onboarding.Load() == missing || Conf.Onboarding.Load().State != conf.OnboardingPending {
+ t.Fatal("reconciling onboarding changed a published snapshot")
+ }
+}
+
+func TestConfDeltaUpdatePreservesAnInterleavedInternalPublication(t *testing.T) {
+ prepareConfConsistencyTest(t)
+ normalizeAppConf(Conf)
+ util.ReadOnly = true
+ interleaved := false
+ UpdateSystemConf(func(value *conf.System) {
+ if !interleaved {
+ interleaved = true
+ Conf.m.Lock()
+ replaceConfSectionLocked(&Conf.System, func(current *conf.System) bool {
+ current.Name = "updated host"
+ return true
+ })
+ Conf.m.Unlock()
+ }
+ value.SettingsWindow = true
+ })
+ current := Conf.System.Load()
+ if !current.SettingsWindow || current.Name != "updated host" {
+ t.Fatal("delta update overwrote an interleaved internal publication")
+ }
+}
+
+func TestConfAppearancePreferencesDoNotInitializeResources(t *testing.T) {
+ prepareConfConsistencyTest(t)
+ normalizeAppConf(Conf)
+ util.ReadOnly = true
+ previous := util.AppearancePath
+ util.AppearancePath = ""
+ t.Cleanup(func() { util.AppearancePath = previous })
+ held := Conf.Appearance.Load()
+ UpdateAppearanceConf(func(value *conf.Appearance) { value.ThemeJS = !held.ThemeJS })
+ if Conf.Appearance.Load().ThemeJS == held.ThemeJS {
+ t.Fatal("appearance preference did not publish its snapshot")
+ }
+}
diff --git a/kernel/model/conf_section.go b/kernel/model/conf_section.go
index e7d8c33ccc..a33a519574 100644
--- a/kernel/model/conf_section.go
+++ b/kernel/model/conf_section.go
@@ -18,6 +18,7 @@ package model
import (
"encoding/json"
+ "errors"
"github.com/siyuan-note/logging"
"github.com/siyuan-note/siyuan/kernel/conf"
@@ -58,19 +59,23 @@ func updateConfSection[T any](field *ConfSection[T], normalize func(*T) *T, muta
}
spec.WriteLock.Lock()
defer spec.WriteLock.Unlock()
- next := cloneConfSection(field.Load())
- if next == nil {
- next = normalize(nil)
- }
- if !mutate(next) {
- return field.Load()
- }
- if _, err := applySectionLocked(spec, next); err != nil {
- logging.LogWarnf("update conf section [%s] failed: %s", spec.Namespace, err)
+ for {
+ old := field.Load()
+ next := cloneConfSection(old)
+ if next == nil {
+ next = normalize(nil)
+ }
+ if !mutate(next) {
+ return field.Load()
+ }
+ if _, err := applySectionLockedAt(spec, next, old, true); err != nil {
+ if errors.Is(err, errConfSectionChanged) {
+ continue
+ }
+ logging.LogWarnf("update conf section [%s] failed: %s", spec.Namespace, err)
+ }
return field.Load()
}
- next = field.Load()
- return next
}
func always[T any](mutate func(*T)) func(*T) bool {
diff --git a/kernel/model/conf_spec.go b/kernel/model/conf_spec.go
index 1c07fb7629..f7ea96ca44 100644
--- a/kernel/model/conf_spec.go
+++ b/kernel/model/conf_spec.go
@@ -2,6 +2,7 @@ package model
import (
"encoding/json"
+ "errors"
"fmt"
"reflect"
"sync"
@@ -74,7 +75,14 @@ func Apply[C any](spec *SectionSpec[C], next C) ([]Issue, error) {
}
func applySectionLocked[C any](spec *SectionSpec[C], next C) ([]Issue, error) {
- old := spec.Load()
+ var expected C
+ return applySectionLockedAt(spec, next, expected, false)
+}
+
+var errConfSectionChanged = errors.New("configuration section changed before commit")
+
+// applySectionLockedAt 在提交前核对增量更新的来源快照,避免覆盖资源刷新或事务路径的并发发布。
+func applySectionLockedAt[C any](spec *SectionSpec[C], next, expected C, checkSource bool) ([]Issue, error) {
data, err := json.Marshal(next)
if err != nil {
return nil, err
@@ -99,6 +107,11 @@ func applySectionLocked[C any](spec *SectionSpec[C], next C) ([]Issue, error) {
current = Conf
}
current.m.Lock()
+ old := spec.Load()
+ if checkSource && !reflect.DeepEqual(old, expected) {
+ current.m.Unlock()
+ return nil, errConfSectionChanged
+ }
spec.Store(next)
applyConfRuntime(current)
if !util.ReadOnly {
diff --git a/kernel/model/conf_specs.go b/kernel/model/conf_specs.go
index 0a1e3d3a96..657d2d122d 100644
--- a/kernel/model/conf_specs.go
+++ b/kernel/model/conf_specs.go
@@ -1,10 +1,12 @@
package model
import (
+ "reflect"
+ "sync/atomic"
+
"github.com/siyuan-note/siyuan/kernel/conf"
"github.com/siyuan-note/siyuan/kernel/task"
"github.com/siyuan-note/siyuan/kernel/util"
- "sync/atomic"
)
func confSectionSpecs() map[string]registeredSection {
@@ -18,7 +20,7 @@ func confSectionSpecs() map[string]registeredSection {
"uiLayout": newSectionSpec("uiLayout", &Conf.UILayout, conf.NormalizeUILayout),
"system": newSectionSpec("system", &Conf.System, conf.NormalizeSystem, systemReactions()...),
"keymap": newSectionSpec("keymap", &Conf.Keymap, conf.NormalizeKeymap),
- "sync": newSectionSpec("sync", &Conf.Sync, conf.NormalizeSync),
+ "sync": syncSectionSpec(),
"search": newSectionSpec("search", &Conf.Search, conf.NormalizeSearch, searchReactions()...),
"flashcard": flashcardSectionSpec(),
"ai": newSectionSpec("ai", &Conf.AI, conf.NormalizeAI),
@@ -35,6 +37,18 @@ func confSectionSpecs() map[string]registeredSection {
}
}
+// syncSectionSpec 在连接信息改变或同步关闭时清除当前来源的索引读取提示。
+func syncSectionSpec() *SectionSpec[*conf.Sync] {
+ return newSectionSpec("sync", &Conf.Sync, conf.NormalizeSync, Reaction[*conf.Sync]{
+ Name: "cloud-index-notice", Changed: func(old, next *conf.Sync) bool {
+ return !next.Enabled || old.Provider != next.Provider || old.CloudName != next.CloudName ||
+ (old.Provider == conf.ProviderS3 && !reflect.DeepEqual(old.S3, next.S3)) ||
+ (old.Provider == conf.ProviderWebDAV && !reflect.DeepEqual(old.WebDAV, next.WebDAV)) ||
+ (old.Provider == conf.ProviderLocal && !reflect.DeepEqual(old.Local, next.Local))
+ }, Apply: func(old, next *conf.Sync) { syncIndexListNotice.reset(util.PushClearMsg) },
+ })
+}
+
var BazaarPetalStateRevision atomic.Uint64
func bazaarReactions() []Reaction[*conf.Bazaar] {
@@ -63,6 +77,9 @@ func appearanceSectionSpec() *SectionSpec[*conf.Appearance] {
}, Apply: func(old, next *conf.Appearance) {
InitAppearance()
WatchThemes()
+ }}, Reaction[*conf.Appearance]{Name: "appearance-notify", Changed: func(old, next *conf.Appearance) bool {
+ return true
+ }, Apply: func(old, next *conf.Appearance) {
util.BroadcastByType("main", "setAppearance", 0, "", Conf.Appearance.Load())
}})
spec.Store = func(value *conf.Appearance) {
diff --git a/kernel/model/conf_sync_review_test.go b/kernel/model/conf_sync_review_test.go
new file mode 100644
index 0000000000..b1dffc16ae
--- /dev/null
+++ b/kernel/model/conf_sync_review_test.go
@@ -0,0 +1,82 @@
+package model
+
+import (
+ "bytes"
+ "encoding/json"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/siyuan-note/siyuan/kernel/conf"
+ "github.com/siyuan-note/siyuan/kernel/util"
+)
+
+func TestConfSyncPatchValidatesRawAddressesAndPreservesRejectedState(t *testing.T) {
+ prepareConfConsistencyTest(t)
+ normalizeAppConf(Conf)
+ util.ReadOnly = true
+ for _, patch := range []string{
+ `{"webdav":{"endpoint":""}}`, `{"webdav":{"endpoint":"ftp://dav.example"}}`,
+ `{"webdav":{"endpoint":"https://"}}`, `{"local":{"endpoint":" \t "}}`,
+ `{"local":{"endpoint":"` + strings.ReplaceAll(util.DataDir, `\`, `/`) + `"}}`,
+ } {
+ held, revision := Conf.Sync.Load(), ConfNamespaceRevision("sync")
+ if _, err := ApplySyncSettingPatch([]byte(patch)); err == nil {
+ t.Fatalf("invalid address was accepted: %s", patch)
+ }
+ if Conf.Sync.Load() != held || ConfNamespaceRevision("sync") != revision {
+ t.Fatal("rejected patch replaced its snapshot or sent a notification")
+ }
+ }
+ if _, err := ApplySyncSettingPatch([]byte(`{"webdav":{"endpoint":"dav.example","username":"","password":""}}`)); err != nil {
+ t.Fatal(err)
+ }
+ if Conf.Sync.Load().WebDAV.Endpoint != util.NormalizeEndpoint("dav.example") {
+ t.Fatal("anonymous WebDAV address was not normalized")
+ }
+}
+
+func TestConfSyncPatchSchedulesTheNormalizedInterval(t *testing.T) {
+ prepareConfConsistencyTest(t)
+ normalizeAppConf(Conf)
+ util.ReadOnly = true
+ UpdateSyncConf(func(value *conf.Sync) { value.Interval = 60 })
+ syncPlanTimeLock.Lock()
+ previous := syncPlanTime
+ syncPlanTimeLock.Unlock()
+ t.Cleanup(func() {
+ syncPlanTimeLock.Lock()
+ syncPlanTime = previous
+ syncPlanTimeLock.Unlock()
+ })
+ if _, err := ApplySyncSettingPatch([]byte(`{"interval":1}`)); err != nil {
+ t.Fatal(err)
+ }
+ syncPlanTimeLock.Lock()
+ delay := time.Until(syncPlanTime)
+ syncPlanTimeLock.Unlock()
+ if Conf.Sync.Load().Interval != 30 || delay < 28*time.Second || delay > 31*time.Second {
+ t.Fatalf("sync timer disagrees with stored interval: %d, %s", Conf.Sync.Load().Interval, delay)
+ }
+}
+
+func TestConfSyncProviderSettersKeepHeldInputsImmutable(t *testing.T) {
+ prepareConfConsistencyTest(t)
+ normalizeAppConf(Conf)
+ util.ReadOnly = true
+ input := cloneConfSection(Conf.Sync.Load())
+ input.S3 = &conf.S3{Endpoint: "s3.example", AccessKey: " key ", SecretKey: " secret ", Bucket: " bucket ", Region: " region "}
+ input.WebDAV = &conf.WebDAV{Endpoint: "dav.example", Username: " user ", Password: " password "}
+ input.Local = &conf.Local{Endpoint: t.TempDir()}
+ Conf.Sync.Store(input)
+ before, _ := json.Marshal(input)
+ for _, err := range []error{SetSyncProviderS3(input.S3), SetSyncProviderWebDAV(input.WebDAV), SetSyncProviderLocal(input.Local)} {
+ if err != nil {
+ t.Fatal(err)
+ }
+ }
+ after, _ := json.Marshal(input)
+ if !bytes.Equal(before, after) {
+ t.Fatal("provider setters mutated their held input snapshot")
+ }
+}
diff --git a/kernel/model/file.go b/kernel/model/file.go
index 1daae045b5..4915ec191f 100644
--- a/kernel/model/file.go
+++ b/kernel/model/file.go
@@ -1426,14 +1426,16 @@ func applyRequestedDocCreateTemplate(arg map[string]any, markdown, docID string)
// ResolveDocCreateSaveLocation 按笔记本配置和全局配置解析新建文档的存放位置。
func ResolveDocCreateSaveLocation(currentBoxID string) (boxID, pathTemplate string) {
- pathTemplate = Conf.FileTree.Load().DocCreateSavePath
+ confFileTreeReadSnapshot := Conf.LoadFileTree()
+
+ pathTemplate = confFileTreeReadSnapshot.DocCreateSavePath
if box := Conf.Box(currentBoxID); nil != box {
boxConf := box.GetConf()
boxID = boxConf.DocCreateSaveBox
pathTemplate = boxConf.DocCreateSavePath
}
if "" == boxID && "" == pathTemplate {
- boxID = Conf.FileTree.Load().DocCreateSaveBox
+ boxID = confFileTreeReadSnapshot.DocCreateSaveBox
}
if "" != boxID && nil == Conf.Box(boxID) {
boxID = currentBoxID
@@ -1442,7 +1444,7 @@ func ResolveDocCreateSaveLocation(currentBoxID string) (boxID, pathTemplate stri
boxID = currentBoxID
}
if "" == pathTemplate {
- pathTemplate = Conf.FileTree.Load().DocCreateSavePath
+ pathTemplate = confFileTreeReadSnapshot.DocCreateSavePath
}
return
}
diff --git a/kernel/model/import.go b/kernel/model/import.go
index c118168e4c..661ab0d5c0 100644
--- a/kernel/model/import.go
+++ b/kernel/model/import.go
@@ -399,6 +399,8 @@ func checkEncryptedImportDeck(unzipRootPath string, trees map[string]*parse.Tree
func importSY0(zipPath, boxID, toPath string, createNotebook, autoDetect bool, sharedBlockIDs map[string]string,
precreatedBox bool) (createdBoxID string, err error) {
+ confFlashcardReadSnapshot := Conf.LoadFlashcard()
+
util.PushEndlessProgress(Conf.Language(73))
defer util.ClearPushProgress(100)
@@ -878,7 +880,7 @@ func importSY0(zipPath, boxID, toPath string, createNotebook, autoDetect bool, s
// 普通笔记本将关联的闪卡数据合并到默认卡包 data/storage/riff/20230218211946-2kw8jgx 中
storageRiffDir := filepath.Join(storage, "riff")
if gulu.File.IsExist(storageRiffDir) {
- deckToImport, loadErr := riff.LoadDeck(storageRiffDir, builtinDeckID, Conf.Flashcard.Load().RequestRetention, Conf.Flashcard.Load().MaximumInterval, Conf.Flashcard.Load().Weights)
+ deckToImport, loadErr := riff.LoadDeck(storageRiffDir, builtinDeckID, confFlashcardReadSnapshot.RequestRetention, confFlashcardReadSnapshot.MaximumInterval, confFlashcardReadSnapshot.Weights)
if nil != loadErr {
logging.LogErrorf("load deck [%s] failed: %s", name, loadErr)
} else {
diff --git a/kernel/model/lan_sync.go b/kernel/model/lan_sync.go
index 444cc09fc2..e3534ca36d 100644
--- a/kernel/model/lan_sync.go
+++ b/kernel/model/lan_sync.go
@@ -62,24 +62,30 @@ func refreshLANSyncManager() {
}
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 == Conf.Sync.Load() || nil == Conf.Sync.Load().LAN || !Conf.Sync.Load().LAN.Enabled || !Conf.Sync.Load().Enabled ||
- 1 > len(Conf.Repo.Load().Key) || util.ContainerDocker == util.Container {
+ 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(Conf.Repo.Load().Key),
+ repoKeyHash: sha256.Sum256(confRepoReadSnapshot.Key),
scope: lanSyncScope(),
- deviceName: Conf.System.Load().Name,
- deviceOS: Conf.System.Load().OS,
+ deviceName: confSystemReadSnapshot.Name,
+ deviceOS: confSystemReadSnapshot.OS,
appVersion: util.Ver,
- maxConcurrentReqs: Conf.Sync.Load().LAN.MaxConcurrentReqs,
+ maxConcurrentReqs: confSyncReadSnapshot.LAN.MaxConcurrentReqs,
nativeDiscovery: nativeDiscovery,
}
lanSyncManagerMu.RLock()
@@ -98,14 +104,14 @@ func refreshLANSyncManagerWithForce(force bool) {
manager, err := lansync.Start(lansync.Config{
RepoPath: util.RepoDir,
IdentityPath: filepath.Join(util.ConfDir, "lan-sync-identity.json"),
- RepoKey: append([]byte(nil), Conf.Repo.Load().Key...),
+ RepoKey: append([]byte(nil), confRepoReadSnapshot.Key...),
Scope: config.scope,
- DeviceName: Conf.System.Load().Name,
- DeviceOS: Conf.System.Load().OS,
+ DeviceName: confSystemReadSnapshot.Name,
+ DeviceOS: confSystemReadSnapshot.OS,
AppVersion: util.Ver,
IPs: ips,
IPsProvider: collectLANSyncIPs,
- MaxConcurrentReqs: Conf.Sync.Load().LAN.MaxConcurrentReqs,
+ MaxConcurrentReqs: confSyncReadSnapshot.LAN.MaxConcurrentReqs,
NativeDiscovery: nativeDiscovery,
OnCommitHint: handleLANSyncCommitHint,
})
diff --git a/kernel/model/onboarding.go b/kernel/model/onboarding.go
index 267c2694d7..ac37fc366c 100644
--- a/kernel/model/onboarding.go
+++ b/kernel/model/onboarding.go
@@ -85,10 +85,10 @@ func EnsureOnboarding() (ret *conf.Onboarding, notebookCreated bool, err error)
defer onboardingLock.Unlock()
if nil == Conf.Onboarding.Load() {
- Conf.Onboarding.Store(&conf.Onboarding{State: conf.OnboardingCompleted})
- Conf.Save()
+ UpdateOnboardingConf(func(value *conf.Onboarding) {})
}
- onboarding := Conf.Onboarding.Load()
+ onboarding := cloneOnboarding(Conf.Onboarding.Load())
+ save := func() { UpdateOnboardingConf(func(value *conf.Onboarding) { *value = *onboarding }) }
if !onboarding.NewUser || onboarding.Dismissed {
return cloneOnboarding(onboarding), false, nil
}
@@ -100,7 +100,7 @@ func EnsureOnboarding() (ret *conf.Onboarding, notebookCreated bool, err error)
documentExists := onboarding.NotebookID != "" && onboarding.DocumentID != "" && filelock.IsExist(filepath.Join(
util.DataDir, onboarding.NotebookID, onboarding.DocumentID+".sy"))
if reconcileOnboarding(onboarding, boxes, documentExists) {
- Conf.Save()
+ save()
}
if !onboarding.NewUser || onboarding.State == conf.OnboardingCompleted {
return cloneOnboarding(onboarding), false, nil
@@ -114,11 +114,11 @@ func EnsureOnboarding() (ret *conf.Onboarding, notebookCreated bool, err error)
if len(boxes) == 1 && boxes[0].Name == Conf.Language(342) {
onboarding.NotebookID = boxes[0].ID
onboarding.State = conf.OnboardingNotebookCreated
- Conf.Save()
+ save()
} else {
onboarding.State = conf.OnboardingCompleted
onboarding.NewUser = false
- Conf.Save()
+ save()
return cloneOnboarding(onboarding), false, nil
}
}
@@ -129,7 +129,7 @@ func EnsureOnboarding() (ret *conf.Onboarding, notebookCreated bool, err error)
return cloneOnboarding(onboarding), false, err
}
onboarding.State = conf.OnboardingNotebookCreated
- Conf.Save()
+ save()
notebookCreated = true
}
}
@@ -139,7 +139,7 @@ func EnsureOnboarding() (ret *conf.Onboarding, notebookCreated bool, err error)
}
if onboarding.DocumentID == "" {
onboarding.DocumentID = ast.NewNodeID()
- Conf.Save()
+ save()
}
docPath := "/" + onboarding.DocumentID + ".sy"
@@ -150,7 +150,7 @@ func EnsureOnboarding() (ret *conf.Onboarding, notebookCreated bool, err error)
}
}
onboarding.State = conf.OnboardingCompleted
- Conf.Save()
+ save()
return cloneOnboarding(onboarding), notebookCreated, nil
}
@@ -160,18 +160,20 @@ func TriggerOnboardingIfEmpty() {
defer onboardingLock.Unlock()
if nil == Conf.Onboarding.Load() {
- Conf.Onboarding.Store(&conf.Onboarding{State: conf.OnboardingCompleted})
+ UpdateOnboardingConf(func(value *conf.Onboarding) {})
}
boxes, err := ListNotebooks()
if err != nil {
logging.LogErrorf("list notebooks before triggering onboarding failed: %s", err)
return
}
- publishEnabled := Conf.Publish.Load() != nil && Conf.Publish.Load().Enable
- if !prepareOnboardingForEmptyWorkspace(Conf.Onboarding.Load(), util.ReadOnly || publishEnabled, len(boxes)) {
+ publish := Conf.Publish.Load()
+ publishEnabled := publish != nil && publish.Enable
+ onboarding := cloneOnboarding(Conf.Onboarding.Load())
+ if !prepareOnboardingForEmptyWorkspace(onboarding, util.ReadOnly || publishEnabled, len(boxes)) {
return
}
- Conf.Save()
+ UpdateOnboardingConf(func(value *conf.Onboarding) { *value = *onboarding })
evt := util.NewCmdResult("onboarding", 0, util.PushModeBroadcast)
evt.Data = cloneOnboarding(Conf.Onboarding.Load())
util.PushEvent(evt)
@@ -181,9 +183,6 @@ func DismissOnboarding() *conf.Onboarding {
onboardingLock.Lock()
defer onboardingLock.Unlock()
- if nil == Conf.Onboarding.Load() {
- Conf.Onboarding.Store(&conf.Onboarding{State: conf.OnboardingCompleted})
- }
UpdateOnboardingConf(func(s *conf.Onboarding) { s.Dismissed = true })
return cloneOnboarding(Conf.Onboarding.Load())
}
diff --git a/kernel/model/repository.go b/kernel/model/repository.go
index 9b2e61f7be..2904510ad0 100644
--- a/kernel/model/repository.go
+++ b/kernel/model/repository.go
@@ -81,6 +81,8 @@ var (
)
func autoPurgeRepo(cron bool) {
+ confRepoReadSnapshot := Conf.LoadRepo()
+
assetDownloadSourceMu.RLock()
defer assetDownloadSourceMu.RUnlock()
if cron && !autoPurgeRepoAfterFirstSync {
@@ -95,7 +97,7 @@ func autoPurgeRepo(cron bool) {
lastAutoPurgeRepo = time.Now()
}()
- if 1 > len(Conf.Repo.Load().Key) {
+ if 1 > len(confRepoReadSnapshot.Key) {
return
}
@@ -122,7 +124,7 @@ func autoPurgeRepo(cron bool) {
tooOld := false
for _, index := range indexes {
- if now.UnixMilli()-index.Created <= int64(Conf.Repo.Load().IndexRetentionDays)*24*60*60*1000 {
+ if now.UnixMilli()-index.Created <= int64(confRepoReadSnapshot.IndexRetentionDays)*24*60*60*1000 {
date = time.UnixMilli(index.Created).Format("2006-01-02")
if _, ok := dateGroupedIndexes[date]; !ok {
dateGroupedIndexes[date] = []*entity.Index{}
@@ -146,7 +148,7 @@ func autoPurgeRepo(cron bool) {
// 过滤出每日需要保留的索引
var retentionIndexIDs []string
for date, indexes := range dateGroupedIndexes {
- if len(indexes) <= Conf.Repo.Load().RetentionIndexesDaily || todayDate == date {
+ if len(indexes) <= confRepoReadSnapshot.RetentionIndexesDaily || todayDate == date {
for _, index := range indexes {
retentionIndexIDs = append(retentionIndexIDs, index.ID)
}
@@ -156,9 +158,9 @@ func autoPurgeRepo(cron bool) {
keepIndexes := hashset.New()
keepIndexes.Add(indexes[0]) // 每天最后一个固定保留
// 随机保留指定数量的索引
- for i := 0; i < Conf.Repo.Load().RetentionIndexesDaily*7; i++ {
+ for i := 0; i < confRepoReadSnapshot.RetentionIndexesDaily*7; i++ {
keepIndexes.Add(indexes[mathRand.Intn(len(indexes)-1)])
- if keepIndexes.Size() >= Conf.Repo.Load().RetentionIndexesDaily {
+ if keepIndexes.Size() >= confRepoReadSnapshot.RetentionIndexesDaily {
break
}
}
@@ -2938,7 +2940,9 @@ func cleanupSyncedBoxResiduals(removedBoxIDs map[string]bool) {
}
func appendLANSyncTrafficStat(message string, trafficStat *dejavu.TrafficStat) string {
- if nil == Conf.Sync.Load() || nil == Conf.Sync.Load().LAN || !Conf.Sync.Load().LAN.Enabled {
+ confSyncReadSnapshot := Conf.LoadSync()
+
+ if nil == confSyncReadSnapshot || nil == confSyncReadSnapshot.LAN || !confSyncReadSnapshot.LAN.Enabled {
return message
}
traffic := humanize.BytesCustomCeil(uint64(trafficStat.PeerDownloadBytes), 2)
@@ -3358,59 +3362,59 @@ func subscribeRepoEvents() {
}
func buildCloudConf() (ret *cloud.Conf, err error) {
- if conf.ProviderS3 != Conf.Sync.Load().Provider && !cloud.IsValidCloudDirName(Conf.Sync.Load().CloudName) {
+ sync := Conf.Sync.Load()
+ if conf.ProviderS3 != sync.Provider && !cloud.IsValidCloudDirName(sync.CloudName) {
logging.LogWarnf("invalid cloud repo name, rename it to [main]")
- UpdateSyncConf(func(s *conf.Sync) { s.CloudName = "main" })
+ sync = UpdateSyncConf(func(s *conf.Sync) { s.CloudName = "main" })
}
userId, token, availableSize := "0", "", int64(1024*1024*1024*1024*2)
- if nil != Conf.User && conf.ProviderSiYuan == Conf.Sync.Load().Provider {
- u := Conf.GetUser()
+ if u := Conf.GetUser(); u != nil && conf.ProviderSiYuan == sync.Provider {
userId = u.UserId
token = u.UserToken
availableSize = u.GetCloudRepoAvailableSize()
}
ret = &cloud.Conf{
- Dir: Conf.Sync.Load().CloudName,
+ Dir: sync.CloudName,
UserID: userId,
Token: token,
AvailableSize: availableSize,
Server: util.GetCloudServer(),
}
- switch Conf.Sync.Load().Provider {
+ switch sync.Provider {
case conf.ProviderSiYuan:
ret.Endpoint = util.GetCloudSyncServer()
case conf.ProviderS3:
ret.S3 = &cloud.ConfS3{
- Endpoint: Conf.Sync.Load().S3.Endpoint,
- AccessKey: Conf.Sync.Load().S3.AccessKey,
- SecretKey: Conf.Sync.Load().S3.SecretKey,
- Bucket: Conf.Sync.Load().S3.Bucket,
- Region: Conf.Sync.Load().S3.Region,
- PathStyle: Conf.Sync.Load().S3.PathStyle,
- SkipTlsVerify: Conf.Sync.Load().S3.SkipTlsVerify,
- Timeout: Conf.Sync.Load().S3.Timeout,
- ConcurrentReqs: Conf.Sync.Load().S3.ConcurrentReqs,
+ Endpoint: sync.S3.Endpoint,
+ AccessKey: sync.S3.AccessKey,
+ SecretKey: sync.S3.SecretKey,
+ Bucket: sync.S3.Bucket,
+ Region: sync.S3.Region,
+ PathStyle: sync.S3.PathStyle,
+ SkipTlsVerify: sync.S3.SkipTlsVerify,
+ Timeout: sync.S3.Timeout,
+ ConcurrentReqs: sync.S3.ConcurrentReqs,
}
case conf.ProviderWebDAV:
ret.WebDAV = &cloud.ConfWebDAV{
- Endpoint: Conf.Sync.Load().WebDAV.Endpoint,
- Username: Conf.Sync.Load().WebDAV.Username,
- Password: Conf.Sync.Load().WebDAV.Password,
- SkipTlsVerify: Conf.Sync.Load().WebDAV.SkipTlsVerify,
- Timeout: Conf.Sync.Load().WebDAV.Timeout,
- ConcurrentReqs: Conf.Sync.Load().WebDAV.ConcurrentReqs,
+ Endpoint: sync.WebDAV.Endpoint,
+ Username: sync.WebDAV.Username,
+ Password: sync.WebDAV.Password,
+ SkipTlsVerify: sync.WebDAV.SkipTlsVerify,
+ Timeout: sync.WebDAV.Timeout,
+ ConcurrentReqs: sync.WebDAV.ConcurrentReqs,
}
case conf.ProviderLocal:
ret.Local = &cloud.ConfLocal{
- Endpoint: Conf.Sync.Load().Local.Endpoint,
- Timeout: Conf.Sync.Load().Local.Timeout,
- ConcurrentReqs: Conf.Sync.Load().Local.ConcurrentReqs,
+ Endpoint: sync.Local.Endpoint,
+ Timeout: sync.Local.Timeout,
+ ConcurrentReqs: sync.Local.ConcurrentReqs,
}
default:
- err = fmt.Errorf("invalid provider [%d]", Conf.Sync.Load().Provider)
+ err = fmt.Errorf("invalid provider [%d]", sync.Provider)
return
}
return
diff --git a/kernel/model/sort_conf.go b/kernel/model/sort_conf.go
index 567b43960c..35d7a2db91 100644
--- a/kernel/model/sort_conf.go
+++ b/kernel/model/sort_conf.go
@@ -72,8 +72,10 @@ func salvageSortConfMap(data []byte) map[string]int {
}
func sortConfFromSnapshots(relPath string) (map[string]int, string, error) {
+ confRepoReadSnapshot := Conf.LoadRepo()
+
// 未配置快照密钥或没有本地索引时不访问云端,直接使用原文件中的可用条目。
- if Conf.Repo.Load() == nil || len(Conf.Repo.Load().Key) == 0 {
+ if confRepoReadSnapshot == nil || len(confRepoReadSnapshot.Key) == 0 {
return nil, "", nil
}
if _, err := os.Stat(filepath.Join(util.RepoDir, "indexes")); err != nil {
diff --git a/kernel/model/sync.go b/kernel/model/sync.go
index d0eded64e2..cbd72a7c0a 100644
--- a/kernel/model/sync.go
+++ b/kernel/model/sync.go
@@ -381,22 +381,24 @@ func completeSyncPerception(cloudPublished bool, err error) {
}
func checkSync(boot, exit, byHand bool) bool {
- if 2 == Conf.Sync.Load().Mode && !boot && !exit && !byHand { // 手动模式下只有启动和退出进行同步
+ confSyncReadSnapshot := Conf.LoadSync()
+
+ if 2 == confSyncReadSnapshot.Mode && !boot && !exit && !byHand { // 手动模式下只有启动和退出进行同步
return false
}
- if 3 == Conf.Sync.Load().Mode && !byHand { // 完全手动模式下只有手动进行同步
+ if 3 == confSyncReadSnapshot.Mode && !byHand { // 完全手动模式下只有手动进行同步
return false
}
- if !Conf.Sync.Load().Enabled {
+ if !confSyncReadSnapshot.Enabled {
if byHand {
util.PushMsg(Conf.Language(124), 5000)
}
return false
}
- if conf.ProviderS3 != Conf.Sync.Load().Provider && !cloud.IsValidCloudDirName(Conf.Sync.Load().CloudName) {
+ if conf.ProviderS3 != confSyncReadSnapshot.Provider && !cloud.IsValidCloudDirName(confSyncReadSnapshot.CloudName) {
if byHand {
util.PushMsg(Conf.Language(123), 5000)
}
@@ -406,7 +408,7 @@ func checkSync(boot, exit, byHand bool) bool {
return false
}
- switch Conf.Sync.Load().Provider {
+ switch confSyncReadSnapshot.Provider {
case conf.ProviderSiYuan:
if !IsSubscriber() {
UpdateSyncConf(func(s *conf.Sync) { s.Enabled = false })
@@ -576,7 +578,6 @@ func SetCloudSyncDir(name string) error {
}
UpdateSyncConf(func(s *conf.Sync) { s.CloudName = name })
- syncIndexListNotice.reset(util.PushClearMsg)
refreshLANSyncManager()
return nil
}
@@ -587,9 +588,6 @@ func SetSyncGenerateConflictDoc(b bool) {
func SetSyncEnable(b bool) {
UpdateSyncConf(func(s *conf.Sync) { s.Enabled = b })
- if !b {
- syncIndexListNotice.reset(util.PushClearMsg)
- }
refreshLANSyncManager()
}
@@ -644,7 +642,6 @@ func SetSyncProvider(provider int, completeAssets bool) (err error) {
}
}
UpdateSyncConf(func(s *conf.Sync) { s.Provider = provider })
- syncIndexListNotice.reset(util.PushClearMsg)
refreshLANSyncManager()
return
}
@@ -655,6 +652,7 @@ func SetSyncProviderS3(s3 *conf.S3) (err error) {
if err = validateSyncS3(s3); err != nil {
return
}
+ s3 = cloneConfSection(s3)
s3.Endpoint = strings.TrimSpace(s3.Endpoint)
s3.Endpoint = util.NormalizeEndpoint(s3.Endpoint)
s3.AccessKey = strings.TrimSpace(s3.AccessKey)
@@ -671,9 +669,6 @@ func SetSyncProviderS3(s3 *conf.S3) (err error) {
}
UpdateSyncConf(func(value *conf.Sync) { value.S3 = cloneConfSection(s3) })
- if Conf.Sync.Load().Provider == conf.ProviderS3 {
- syncIndexListNotice.reset(util.PushClearMsg)
- }
refreshLANSyncManager()
return
}
@@ -728,6 +723,7 @@ func SetSyncProviderWebDAV(webdav *conf.WebDAV) (err error) {
if err = validateSyncWebDAV(webdav); err != nil {
return
}
+ webdav = cloneConfSection(webdav)
webdav.Endpoint = strings.TrimSpace(webdav.Endpoint)
webdav.Endpoint = util.NormalizeEndpoint(webdav.Endpoint)
@@ -749,9 +745,6 @@ func SetSyncProviderWebDAV(webdav *conf.WebDAV) (err error) {
}
UpdateSyncConf(func(s *conf.Sync) { s.WebDAV = webdav })
- if Conf.Sync.Load().Provider == conf.ProviderWebDAV {
- syncIndexListNotice.reset(util.PushClearMsg)
- }
refreshLANSyncManager()
return
}
@@ -759,39 +752,13 @@ func SetSyncProviderWebDAV(webdav *conf.WebDAV) (err error) {
func SetSyncProviderLocal(local *conf.Local) (err error) {
release := lockAssetSourceChange()
defer release()
- if err = validateSyncLocal(local); err != nil {
+ if err = validateSyncLocalPath(local); err != nil {
return
}
+ local = cloneConfSection(local)
local.Endpoint = strings.TrimSpace(local.Endpoint)
local.Endpoint = util.NormalizeLocalPath(local.Endpoint)
- absPath, err := filepath.Abs(local.Endpoint)
- if nil != err {
- msg := fmt.Sprintf("get endpoint [%s] abs path failed: %s", local.Endpoint, err)
- logging.LogError(msg)
- err = fmt.Errorf(Conf.Language(77), msg)
- return
- }
- if !gulu.File.IsExist(absPath) {
- msg := fmt.Sprintf("endpoint [%s] not exist", local.Endpoint)
- logging.LogError(msg)
- err = fmt.Errorf(Conf.Language(77), msg)
- return
- }
- if util.IsAbsPathInWorkspace(absPath) || filepath.Clean(absPath) == filepath.Clean(util.WorkspaceDir) {
- msg := fmt.Sprintf("endpoint [%s] is in workspace", local.Endpoint)
- logging.LogError(msg)
- err = fmt.Errorf(Conf.Language(77), msg)
- return
- }
-
- if gulu.File.IsSubPath(absPath, util.WorkspaceDir) {
- msg := fmt.Sprintf("endpoint [%s] is parent of workspace", local.Endpoint)
- logging.LogError(msg)
- err = fmt.Errorf(Conf.Language(77), msg)
- return
- }
-
local.Timeout = util.NormalizeTimeout(local.Timeout)
local.ConcurrentReqs = util.NormalizeConcurrentReqs(local.ConcurrentReqs, conf.ProviderLocal)
if Conf.Sync.Load().Provider == conf.ProviderLocal && (Conf.Sync.Load().Local == nil ||
@@ -802,9 +769,6 @@ func SetSyncProviderLocal(local *conf.Local) (err error) {
}
UpdateSyncConf(func(s *conf.Sync) { s.Local = local })
- if Conf.Sync.Load().Provider == conf.ProviderLocal {
- syncIndexListNotice.reset(util.PushClearMsg)
- }
refreshLANSyncManager()
return
}
@@ -1189,9 +1153,11 @@ func closeSyncWebSocket() {
}
func connectSyncWebSocket() {
+ confSyncReadSnapshot := Conf.LoadSync()
+
defer logging.Recover()
- if !Conf.Sync.Load().Enabled || !IsSubscriber() || conf.ProviderSiYuan != Conf.Sync.Load().Provider {
+ if !confSyncReadSnapshot.Enabled || !IsSubscriber() || conf.ProviderSiYuan != confSyncReadSnapshot.Provider {
return
}
diff --git a/kernel/model/template.go b/kernel/model/template.go
index c3753baf40..463145599a 100644
--- a/kernel/model/template.go
+++ b/kernel/model/template.go
@@ -139,6 +139,8 @@ func getTemplateReadmePaths(templateDir string) map[string]struct{} {
}
func SearchTemplate(keyword string) (ret []*TemplateSearchResult) {
+ confSearchReadSnapshot := Conf.LoadSearch()
+
ret = []*TemplateSearchResult{}
templates := filepath.Join(util.DataDir, "templates")
@@ -215,7 +217,7 @@ func SearchTemplate(keyword string) (ret []*TemplateSearchResult) {
content = strings.TrimPrefix(path, templates)
content = strings.TrimSuffix(content, ".md")
content = filepath.ToSlash(content)
- _, content = search.MarkText(content, strings.Join(keywords, search.TermSep), 32, Conf.Search.Load().CaseSensitive)
+ _, content = search.MarkText(content, strings.Join(keywords, search.TermSep), 32, confSearchReadSnapshot.CaseSensitive)
relativePath, relErr := filepath.Rel(templates, path)
if nil != relErr {
return nil
@@ -245,7 +247,7 @@ func SearchTemplate(keyword string) (ret []*TemplateSearchResult) {
}
if hit {
content = filepath.ToSlash(content)
- _, content = search.MarkText(content, strings.Join(keywords, search.TermSep), 32, Conf.Search.Load().CaseSensitive)
+ _, content = search.MarkText(content, strings.Join(keywords, search.TermSep), 32, confSearchReadSnapshot.CaseSensitive)
b := &TemplateSearchResult{Path: filepath.Join(templates, group.Name()), RelativePath: group.Name(), Content: content}
results = append(results, &result{item: b, score: score})
}
diff --git a/kernel/model/virutalref.go b/kernel/model/virutalref.go
index d67a48d332..06fcc98055 100644
--- a/kernel/model/virutalref.go
+++ b/kernel/model/virutalref.go
@@ -128,6 +128,8 @@ func CacheVirtualBlockRefJob() {
}
func ResetVirtualBlockRefCache() {
+ confSearchReadSnapshot := Conf.LoadSearch()
+
virtualBlockRefCache.Clear()
if nil == Conf {
return
@@ -138,10 +140,10 @@ func ResetVirtualBlockRefCache() {
searchIgnoreLines := getSearchIgnoreLines()
refSearchIgnoreLines := getRefSearchIgnoreLines()
- keywords := sql.QueryVirtualRefKeywords(Conf.Search.Load().VirtualRefName, Conf.Search.Load().VirtualRefAlias, Conf.Search.Load().VirtualRefAnchor, Conf.Search.Load().VirtualRefDoc, searchIgnoreLines, refSearchIgnoreLines)
+ keywords := sql.QueryVirtualRefKeywords(confSearchReadSnapshot.VirtualRefName, confSearchReadSnapshot.VirtualRefAlias, confSearchReadSnapshot.VirtualRefAnchor, confSearchReadSnapshot.VirtualRefDoc, searchIgnoreLines, refSearchIgnoreLines)
putVirtualRefCache("virtual_ref", keywords, 0)
for _, boxID := range treenode.GetOpenedEncryptedBoxIDs() {
- boxKeywords := sql.QueryVirtualRefKeywords(Conf.Search.Load().VirtualRefName, Conf.Search.Load().VirtualRefAlias, Conf.Search.Load().VirtualRefAnchor, Conf.Search.Load().VirtualRefDoc, searchIgnoreLines, refSearchIgnoreLines, boxID)
+ boxKeywords := sql.QueryVirtualRefKeywords(confSearchReadSnapshot.VirtualRefName, confSearchReadSnapshot.VirtualRefAlias, confSearchReadSnapshot.VirtualRefAnchor, confSearchReadSnapshot.VirtualRefDoc, searchIgnoreLines, refSearchIgnoreLines, boxID)
putVirtualRefCache(boxID+"\x00virtual_ref", boxKeywords, 0)
}
}