Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix(im): resolve resource URLs through bound storage backends (#4578)

lyingbuge6fd3fd3e2d4
diff --git a/internal/application/repository/resource.go b/internal/application/repository/resource.go
index 8a895c3bf..d3c0ad56f 100644
--- a/internal/application/repository/resource.go
+++ b/internal/application/repository/resource.go
@@ -31,6 +31,19 @@ func (r *resourceRepository) GetByID(ctx context.Context, id string) (*types.Sto
return &resource, err
}
+func (r *resourceRepository) BindStorageBackend(
+ ctx context.Context, id, backendID string,
+) (*types.StoredResource, error) {
+ err := r.db.WithContext(ctx).Model(&types.StoredResource{}).
+ Where("id = ? AND state = ? AND (storage_backend_id = '' OR storage_backend_id IS NULL)",
+ id, types.ResourceStateActive).
+ Update("storage_backend_id", backendID).Error
+ if err != nil {
+ return nil, err
+ }
+ return r.GetByID(ctx, id)
+}
+
func (r *resourceRepository) GetByHandle(ctx context.Context, handle string) (*types.StoredResource, error) {
var resource types.StoredResource
err := r.db.WithContext(ctx).
diff --git a/internal/application/service/file/resource_catalog.go b/internal/application/service/file/resource_catalog.go
index dfaa0970d..ced19f8d6 100644
--- a/internal/application/service/file/resource_catalog.go
+++ b/internal/application/service/file/resource_catalog.go
@@ -24,6 +24,20 @@ type resourceCatalogFileService struct {
inner interfaces.FileService
catalog interfaces.ResourceCatalog
externalURL string
+ global bool
+}
+
+// NewGlobalResourceCatalogFileService pins writes to the process-wide driver's
+// concrete instance, independently of workspace defaults and legacy aliases.
+func NewGlobalResourceCatalogFileService(
+ inner interfaces.FileService,
+ catalog interfaces.ResourceCatalog,
+) interfaces.FileService {
+ svc := NewResourceCatalogFileService(inner, catalog)
+ if wrapped, ok := svc.(*resourceCatalogFileService); ok {
+ wrapped.global = true
+ }
+ return svc
}
// NewResourceCatalogFileService decorates a physical FileService with stable
@@ -70,7 +84,16 @@ func (s *resourceCatalogFileService) register(
contentHash string,
) (string, error) {
kind, mimeType := resourceKind(name)
- ref, err := s.catalog.Register(ctx, tenantID, physical, interfaces.ResourceRegistration{
+ register := s.catalog.Register
+ if s.global {
+ registrar, ok := s.catalog.(interfaces.GlobalResourceRegistrar)
+ if !ok {
+ _ = s.inner.DeleteFile(ctx, physical)
+ return "", fmt.Errorf("global storage registration is unavailable")
+ }
+ register = registrar.RegisterGlobal
+ }
+ ref, err := register(ctx, tenantID, physical, interfaces.ResourceRegistration{
Kind: kind,
MimeType: mimeType,
OriginalName: filepath.Base(name),
diff --git a/internal/application/service/resource.go b/internal/application/service/resource.go
index 9f2a563f4..a32197aef 100644
--- a/internal/application/service/resource.go
+++ b/internal/application/service/resource.go
@@ -21,7 +21,9 @@ import (
const defaultResourceGrantTTL = 2 * time.Hour
type resourceCatalog struct {
- repo interfaces.ResourceRepository
+ repo interfaces.ResourceRepository
+ storage interfaces.StorageBackendRepository
+ globalStorage *types.StorageBackend
}
// NewResourceCatalog creates the stable resource-reference domain service.
@@ -61,6 +63,11 @@ func (s *resourceCatalog) Register(
return "", err
}
if existing != nil {
+ if existing.StorageBackendID == "" && meta.StorageBackendID != "" {
+ if _, err := s.repo.BindStorageBackend(ctx, existing.ID, meta.StorageBackendID); err != nil {
+ return "", err
+ }
+ }
return types.BuildResourcePath(existing.Handle), nil
}
@@ -69,6 +76,9 @@ func (s *resourceCatalog) Register(
if scoped {
providerPath = inner
}
+ if backendID == "" {
+ backendID = meta.StorageBackendID
+ }
provider := types.ParseProviderScheme(providerPath)
if provider == "" {
return "", fmt.Errorf("resource physical path has unsupported provider scheme")
@@ -103,6 +113,11 @@ func (s *resourceCatalog) Register(
}
existing, lookupErr := s.repo.GetByTenantLocation(ctx, tenantID, locationHash)
if lookupErr == nil && existing != nil {
+ if existing.StorageBackendID == "" && backendID != "" {
+ if _, err := s.repo.BindStorageBackend(ctx, existing.ID, backendID); err != nil {
+ return "", err
+ }
+ }
return types.BuildResourcePath(existing.Handle), nil
}
}
diff --git a/internal/application/service/resource_storage.go b/internal/application/service/resource_storage.go
new file mode 100644
index 000000000..1a06641bd
--- /dev/null
+++ b/internal/application/service/resource_storage.go
@@ -0,0 +1,191 @@
+package service
+
+import (
+ "context"
+ "fmt"
+ "net/url"
+ "strings"
+
+ "github.com/Tencent/WeKnora/internal/types"
+ "github.com/Tencent/WeKnora/internal/types/interfaces"
+ "github.com/google/uuid"
+)
+
+// NewResourceCatalogWithStorage snapshots the same environment as initRawFileService.
+// A later workspace-default change must not change the destination of global writes.
+func NewResourceCatalogWithStorage(
+ repo interfaces.ResourceRepository,
+ storage interfaces.StorageBackendRepository,
+) interfaces.ResourceCatalog {
+ global := types.StorageBackendFromEnvironment(0)
+ if global != nil {
+ global.LegacyAlias = false
+ switch global.Provider {
+ case "local", "minio":
+ // The process-wide drivers do not use the workspace path-prefix settings.
+ global.Config.PathPrefix = ""
+ case "s3", "oss", "obs":
+ if global.Config.PathPrefix == "" {
+ global.Config.PathPrefix = "weknora/"
+ }
+ }
+ if global.Provider == "s3" {
+ global.Config.ForcePathStyle = false // initRawFileService uses NewS3FileService.
+ }
+ }
+ return &resourceCatalog{repo: repo, storage: storage, globalStorage: global}
+}
+
+func (s *resourceCatalog) globalBackendSnapshot(tenantID uint64) *types.StorageBackend {
+ backend := *s.globalStorage
+ backend.TenantID = tenantID
+ // Credentials can rotate, but changing location creates a separate instance.
+ // This is deliberately not a legacy alias: startup refreshes those in place.
+ identity := fmt.Sprintf("global-storage:%d:%s:%t:%t:%s:%s", tenantID,
+ backend.Config.LocationKey(backend.Provider), backend.Config.UseSSL, backend.Config.ForcePathStyle,
+ backend.Config.TempBucketName, backend.Config.TempRegion)
+ backend.ID = uuid.NewSHA1(uuid.NameSpaceOID, []byte(identity)).String()
+ backend.Name = fmt.Sprintf("System %s files (%s)", strings.ToUpper(backend.Provider), backend.ID[:8])
+ return &backend
+}
+
+func (s *resourceCatalog) globalBackend(ctx context.Context, tenantID uint64) (*types.StorageBackend, error) {
+ if s.storage == nil || s.globalStorage == nil {
+ return nil, fmt.Errorf("global storage instance is unavailable")
+ }
+ backend := s.globalBackendSnapshot(tenantID)
+ existing, err := s.storage.GetByID(ctx, tenantID, backend.ID)
+ if err != nil {
+ return nil, err
+ }
+ if existing == nil {
+ if err := s.storage.Create(ctx, backend); err != nil {
+ // Concurrent first writes converge on the same instance.
+ existing, lookupErr := s.storage.GetByID(ctx, tenantID, backend.ID)
+ if lookupErr != nil || existing == nil || existing.Status != types.StorageBackendStatusActive {
+ return nil, err
+ }
+ return existing, nil
+ }
+ return backend, nil
+ }
+ if existing.Status != types.StorageBackendStatusActive {
+ return nil, fmt.Errorf("global storage instance is disabled")
+ }
+ if existing.Config != backend.Config {
+ existing.Config = backend.Config
+ if err := s.storage.Update(ctx, existing); err != nil {
+ return nil, err
+ }
+ }
+ return existing, nil
+}
+
+func (s *resourceCatalog) RegisterGlobal(
+ ctx context.Context, tenantID uint64, physicalPath string, meta interfaces.ResourceRegistration,
+) (string, error) {
+ backend, err := s.globalBackend(ctx, tenantID)
+ if err != nil {
+ return "", err
+ }
+ if !resourceMatchesBackend(physicalPath, backend) {
+ return "", fmt.Errorf("resource does not match the global storage instance")
+ }
+ meta.StorageBackendID = backend.ID
+ return s.Register(ctx, tenantID, physicalPath, meta)
+}
+
+// ResolveStorageBinding backfills old unscoped resources conservatively. A
+// provider alone never justifies using the workspace default or a legacy alias.
+func (s *resourceCatalog) ResolveStorageBinding(
+ ctx context.Context, reference string,
+) (*types.StoredResource, error) {
+ resource, err := s.Resolve(ctx, reference)
+ if err != nil {
+ return resource, err
+ }
+ if resource.StorageBackendID != "" {
+ // Refresh rotated credentials only for the exact current global location.
+ // Missing/disabled explicit instances are never recreated during reads.
+ if s.globalStorage != nil && s.globalBackendSnapshot(resource.TenantID).ID == resource.StorageBackendID {
+ backend, err := s.storage.GetByID(ctx, resource.TenantID, resource.StorageBackendID)
+ if err != nil || backend == nil || backend.Status != types.StorageBackendStatusActive {
+ return nil, fmt.Errorf("bound global storage instance is unavailable")
+ }
+ if _, err := s.globalBackend(ctx, resource.TenantID); err != nil {
+ return nil, err
+ }
+ }
+ return resource, nil
+ }
+ if backendID, _, ok := types.ParseStorageBackendPath(resource.PhysicalPath); ok {
+ return s.repo.BindStorageBackend(ctx, resource.ID, backendID)
+ }
+ if s.storage == nil {
+ return nil, fmt.Errorf("resource has no storage instance")
+ }
+ var global *types.StorageBackend
+ if s.globalStorage != nil && resourceMatchesBackend(resource.PhysicalPath, s.globalStorage) {
+ global, err = s.globalBackend(ctx, resource.TenantID)
+ if err != nil {
+ return nil, err
+ }
+ }
+ backends, err := s.storage.List(ctx, resource.TenantID)
+ if err != nil {
+ return nil, err
+ }
+ var selected *types.StorageBackend
+ for _, backend := range backends {
+ if !resourceMatchesBackend(resource.PhysicalPath, backend) {
+ continue
+ }
+ // Include disabled instances in ambiguity checks; they are not a reason
+ // to silently select a different endpoint for an old path.
+ if selected != nil && resourceBackendLocation(selected) != resourceBackendLocation(backend) {
+ return nil, fmt.Errorf("resource storage instance is ambiguous")
+ }
+ if selected == nil || backend.ID < selected.ID {
+ selected = backend
+ }
+ }
+ if selected == nil || selected.Status != types.StorageBackendStatusActive {
+ return nil, fmt.Errorf("resource storage instance is unavailable")
+ }
+ if global != nil {
+ // Prefer the immutable-location snapshot over startup's mutable env alias.
+ selected = global
+ }
+ return s.repo.BindStorageBackend(ctx, resource.ID, selected.ID)
+}
+
+func resourceMatchesBackend(physical string, backend *types.StorageBackend) bool {
+ u, err := url.Parse(physical)
+ if err != nil || u.Scheme != backend.Provider || u.RawQuery != "" || u.Fragment != "" {
+ return false
+ }
+ if backend.Provider == "local" {
+ // local:// paths omit the root/prefix, so different local roots are ambiguous.
+ return true
+ }
+ if u.Host != backend.Config.BucketName &&
+ (u.Host == "" || u.Host != backend.Config.TempBucketName) {
+ return false
+ }
+ if backend.Provider == "cos" {
+ region, _, _ := strings.Cut(strings.TrimPrefix(u.Path, "/"), "/")
+ return region == backend.Config.Region ||
+ (u.Host == backend.Config.TempBucketName && region == backend.Config.TempRegion)
+ }
+ return true
+}
+
+func resourceBackendLocation(backend *types.StorageBackend) string {
+ c := backend.Config
+ if backend.Provider != "local" {
+ // Object paths already include the key prefix; it does not affect reads.
+ c.PathPrefix = ""
+ }
+ return fmt.Sprintf("%s|%t|%t|%s|%s", c.LocationKey(backend.Provider),
+ c.UseSSL, c.ForcePathStyle, c.TempBucketName, c.TempRegion)
+}
diff --git a/internal/application/service/resource_storage_test.go b/internal/application/service/resource_storage_test.go
new file mode 100644
index 000000000..166d42b05
--- /dev/null
+++ b/internal/application/service/resource_storage_test.go
@@ -0,0 +1,134 @@
+package service
+
+import (
+ "context"
+ "testing"
+
+ "github.com/Tencent/WeKnora/internal/application/repository"
+ filesvc "github.com/Tencent/WeKnora/internal/application/service/file"
+ "github.com/Tencent/WeKnora/internal/types"
+ "github.com/Tencent/WeKnora/internal/types/interfaces"
+ "github.com/stretchr/testify/require"
+)
+
+func TestGlobalResourceBindingSurvivesCredentialAndLocationChanges(t *testing.T) {
+ for name, value := range map[string]string{
+ "STORAGE_TYPE": "oss", "OSS_ENDPOINT": "https://oss.example", "OSS_REGION": "region",
+ "OSS_BUCKET_NAME": "first-bucket", "OSS_ACCESS_KEY": "first-key", "OSS_SECRET_KEY": "secret",
+ "OSS_PATH_PREFIX": "", "OSS_TEMP_BUCKET_NAME": "", "OSS_TEMP_REGION": "",
+ } {
+ t.Setenv(name, value)
+ }
+ _, db := newResourceCatalogForTest(t)
+ require.NoError(t, db.AutoMigrate(&types.StorageBackend{}))
+ resources := repository.NewResourceRepository(db)
+ storage := repository.NewStorageBackendRepository(db)
+ newCatalog := func() *resourceCatalog {
+ return NewResourceCatalogWithStorage(resources, storage).(*resourceCatalog)
+ }
+ ctx := context.Background()
+ catalog := newCatalog()
+ first, err := catalog.RegisterGlobal(ctx, 7,
+ "oss://first-bucket/7/exports/a.png", interfaces.ResourceRegistration{})
+ require.NoError(t, err)
+ resource, err := catalog.ResolveStorageBinding(ctx, first)
+ require.NoError(t, err)
+ firstID := resource.StorageBackendID
+ require.NotEmpty(t, firstID)
+
+ t.Setenv("OSS_ACCESS_KEY", "rotated-key")
+ catalog = newCatalog()
+ resource, err = catalog.ResolveStorageBinding(ctx, first)
+ require.NoError(t, err)
+ require.Equal(t, firstID, resource.StorageBackendID)
+ backend, err := storage.GetByID(ctx, 7, firstID)
+ require.NoError(t, err)
+ require.Equal(t, "rotated-key", backend.Config.AccessKeyID)
+ require.False(t, backend.LegacyAlias)
+ require.Equal(t, types.StorageBackendSourceEnv, backend.Source)
+
+ t.Setenv("OSS_BUCKET_NAME", "second-bucket")
+ catalog = newCatalog()
+ second, err := catalog.RegisterGlobal(ctx, 7,
+ "oss://second-bucket/7/exports/b.png", interfaces.ResourceRegistration{})
+ require.NoError(t, err)
+ resource, err = catalog.ResolveStorageBinding(ctx, second)
+ require.NoError(t, err)
+ require.NotEqual(t, firstID, resource.StorageBackendID)
+ resource, err = catalog.ResolveStorageBinding(ctx, first)
+ require.NoError(t, err)
+ require.Equal(t, firstID, resource.StorageBackendID)
+ backend, err = storage.GetByID(ctx, 7, firstID)
+ require.NoError(t, err)
+ require.Equal(t, "first-bucket", backend.Config.BucketName)
+}
+
+func TestBoundGlobalResourceDoesNotRecreateMissingOrDisabledInstance(t *testing.T) {
+ for _, state := range []string{"disabled", "deleted"} {
+ t.Run(state, func(t *testing.T) {
+ t.Setenv("STORAGE_TYPE", "local")
+ _, db := newResourceCatalogForTest(t)
+ require.NoError(t, db.AutoMigrate(&types.StorageBackend{}))
+ storage := repository.NewStorageBackendRepository(db)
+ catalog := NewResourceCatalogWithStorage(repository.NewResourceRepository(db), storage).(*resourceCatalog)
+ ctx := context.Background()
+ ref, err := catalog.RegisterGlobal(ctx, 7, "local://7/exports/a.png", interfaces.ResourceRegistration{})
+ require.NoError(t, err)
+ resource, err := catalog.Resolve(ctx, ref)
+ require.NoError(t, err)
+ if state == "disabled" {
+ require.NoError(t, db.Model(&types.StorageBackend{}).Where("id = ?", resource.StorageBackendID).
+ Update("status", types.StorageBackendStatusDisabled).Error)
+ } else {
+ require.NoError(t, storage.Delete(ctx, 7, resource.StorageBackendID))
+ }
+ _, err = catalog.ResolveStorageBinding(ctx, ref)
+ require.Error(t, err)
+ stored, err := catalog.Resolve(ctx, ref)
+ require.NoError(t, err)
+ require.Equal(t, resource.StorageBackendID, stored.StorageBackendID)
+ })
+ }
+}
+
+func TestGlobalLocalWritesIgnoreWorkspacePathPrefix(t *testing.T) {
+ t.Setenv("STORAGE_TYPE", "local")
+ t.Setenv("LOCAL_STORAGE_PATH_PREFIX", "workspace-only")
+ _, db := newResourceCatalogForTest(t)
+ require.NoError(t, db.AutoMigrate(&types.StorageBackend{}))
+ storage := repository.NewStorageBackendRepository(db)
+ catalog := NewResourceCatalogWithStorage(repository.NewResourceRepository(db), storage)
+ baseDir := t.TempDir()
+ writer := filesvc.NewGlobalResourceCatalogFileService(filesvc.NewLocalFileService(baseDir, ""), catalog)
+ ctx := context.Background()
+ ref, err := writer.SaveBytes(ctx, []byte("artifact"), 7, "a.txt", false)
+ require.NoError(t, err)
+ resource, err := catalog.Resolve(ctx, ref)
+ require.NoError(t, err)
+ backend, err := storage.GetByID(ctx, 7, resource.StorageBackendID)
+ require.NoError(t, err)
+ require.NotNil(t, backend)
+ require.Empty(t, backend.Config.PathPrefix)
+ reader, _, err := NewStorageBackendService(storage, nil, catalog).
+ ResolveFileService(ctx, &types.Tenant{ID: 7}, backend.ID, "local", baseDir)
+ require.NoError(t, err)
+ file, err := reader.GetFile(ctx, ref)
+ require.NoError(t, err)
+ require.NoError(t, file.Close())
+}
+
+func TestLegacyResourceBindingNeverOverwritesExistingBinding(t *testing.T) {
+ catalog, db := newResourceCatalogForTest(t)
+ ctx := context.Background()
+ ref, err := catalog.Register(ctx, 7, "oss://bucket/7/exports/a.png", interfaces.ResourceRegistration{})
+ require.NoError(t, err)
+ resource, err := catalog.Resolve(ctx, ref)
+ require.NoError(t, err)
+ repo := repository.NewResourceRepository(db)
+ bound, err := repo.BindStorageBackend(ctx, resource.ID, "actual-instance")
+ require.NoError(t, err)
+ require.Equal(t, "actual-instance", bound.StorageBackendID)
+ bound, err = repo.BindStorageBackend(ctx, resource.ID, "stale-candidate")
+ require.NoError(t, err)
+ require.Equal(t, "actual-instance", bound.StorageBackendID)
+}
diff --git a/internal/container/container.go b/internal/container/container.go
index 81f775f38..50493e5b4 100644
--- a/internal/container/container.go
+++ b/internal/container/container.go
@@ -322,7 +322,7 @@ func BuildContainer(container *dig.Container) *dig.Container {
must(container.Provide(repository.NewStorageBackendRepository))
must(container.Provide(repository.NewResourceRepository))
must(container.Provide(repository.NewTemporaryDocumentRepository))
- must(container.Provide(service.NewResourceCatalog))
+ must(container.Provide(service.NewResourceCatalogWithStorage))
// TenantStoreOwnership adapter used by the retriever factory functions
// to verify that a resolved VectorStore belongs to the caller's tenant.
must(container.Provide(retriever.NewVectorStoreRepoOwnership))
@@ -1338,7 +1338,10 @@ func initFileService(cfg *config.Config, catalog interfaces.ResourceCatalog) (in
if err != nil {
return nil, err
}
- return file.NewResourceCatalogFileService(inner, catalog), nil
+ if _, dummy := inner.(*file.DummyFileService); dummy {
+ return file.NewResourceCatalogFileService(inner, catalog), nil
+ }
+ return file.NewGlobalResourceCatalogFileService(inner, catalog), nil
}
func initRawFileService(_ *config.Config) (interfaces.FileService, error) {
diff --git a/internal/im/content_rewrite_test.go b/internal/im/content_rewrite_test.go
index d5135fec8..70376865b 100644
--- a/internal/im/content_rewrite_test.go
+++ b/internal/im/content_rewrite_test.go
@@ -373,7 +373,7 @@ func TestCleanIMContent_AfterStreamReassembly(t *testing.T) {
sent, rem := simulateIMStreamFlush(parts)
require.Empty(t, rem)
joined := strings.Join(sent, "")
- out := cleanIMContent(context.Background(), joined, tenant, nil)
+ out := cleanIMContent(context.Background(), joined, newIMFileServiceResolver(tenant, nil))
assert.Contains(t, out, "/api/v1/files/presigned")
assert.NotContains(t, out, "local://10000")
}
diff --git a/internal/im/full_output_test.go b/internal/im/full_output_test.go
index 12b44c839..d8cba3bde 100644
--- a/internal/im/full_output_test.go
+++ b/internal/im/full_output_test.go
@@ -362,7 +362,7 @@ func TestExecuteQARequestFullOutputSkipsProgressWhenNotSupported(t *testing.T) {
func TestFormatIMOutboundAnswerOrFallbackAfterCleanup(t *testing.T) {
got := formatIMOutboundAnswerOrFallback(
- context.Background(), "<think>only reasoning</think>", nil, nil,
+ context.Background(), "<think>only reasoning</think>", nil,
)
if got != imNoAnswerFallback {
t.Fatalf("think-only final content = %q, want fallback %q", got, imNoAnswerFallback)
diff --git a/internal/im/global_resource_storage_test.go b/internal/im/global_resource_storage_test.go
new file mode 100644
index 000000000..2f1d7f780
--- /dev/null
+++ b/internal/im/global_resource_storage_test.go
@@ -0,0 +1,121 @@
+package im
+
+import (
+ "fmt"
+ "net/url"
+ "strings"
+ "testing"
+
+ "github.com/Tencent/WeKnora/internal/application/repository"
+ appsvc "github.com/Tencent/WeKnora/internal/application/service"
+ filesvc "github.com/Tencent/WeKnora/internal/application/service/file"
+ "github.com/Tencent/WeKnora/internal/types"
+ "github.com/Tencent/WeKnora/internal/types/interfaces"
+ "github.com/stretchr/testify/require"
+)
+
+func configureIMGlobalOSS(t *testing.T, f *imResourceStorageFixture) interfaces.FileService {
+ t.Helper()
+ for name, value := range map[string]string{
+ "STORAGE_TYPE": "oss", "OSS_ENDPOINT": f.baseURL, "OSS_REGION": "cn-hangzhou",
+ "OSS_BUCKET_NAME": "global-artifacts", "OSS_ACCESS_KEY": "global-key", "OSS_SECRET_KEY": "test-secret",
+ "OSS_PATH_PREFIX": "", "OSS_TEMP_BUCKET_NAME": "", "OSS_TEMP_REGION": "",
+ } {
+ t.Setenv(name, value)
+ }
+ repo := repository.NewStorageBackendRepository(f.db)
+ f.catalog = appsvc.NewResourceCatalogWithStorage(repository.NewResourceRepository(f.db), repo)
+ f.storage = appsvc.NewStorageBackendService(repo, f.db, f.catalog)
+ driver, err := filesvc.NewOssFileService(f.baseURL, "cn-hangzhou", "global-key", "test-secret",
+ "global-artifacts", "weknora/")
+ require.NoError(t, err)
+ f.global = filesvc.NewGlobalResourceCatalogFileService(driver, f.catalog)
+ return driver
+}
+
+func TestIMGlobalResourcesKeepTheirActualStorage(t *testing.T) {
+ for _, workspaceProvider := range []string{"local", "oss"} {
+ for _, origin := range []string{"artifact", "temporary document", "legacy artifact"} {
+ t.Run(workspaceProvider+"/"+origin, func(t *testing.T) {
+ f := newIMResourceStorageFixture(t)
+ driver := configureIMGlobalOSS(t, f)
+ backend := &types.StorageBackend{
+ ID: "workspace-default", TenantID: 7, Name: "Workspace default", Provider: workspaceProvider,
+ LegacyAlias: true,
+ Config: types.StorageBackendConfig{
+ Endpoint: f.baseURL, Region: "cn-hangzhou", BucketName: "workspace-bucket",
+ AccessKeyID: "workspace-key", SecretAccessKey: "workspace-secret",
+ },
+ }
+ require.NoError(t, repository.NewStorageBackendRepository(f.db).Create(f.context(), backend))
+ require.NoError(t, f.db.Model(&types.Tenant{}).Where("id = ?", 7).
+ Update("default_storage_backend_id", backend.ID).Error)
+ writer := f.global
+ if origin == "legacy artifact" {
+ writer = filesvc.NewResourceCatalogFileService(driver, f.catalog)
+ }
+ ref, err := writer.SaveBytes(f.context(), []byte("generated content"), 7, "report.png",
+ origin == "temporary document")
+ require.NoError(t, err)
+ resource, err := f.catalog.Resolve(f.context(), ref)
+ require.NoError(t, err)
+ if origin == "legacy artifact" {
+ require.Empty(t, resource.StorageBackendID)
+ } else {
+ require.NotEmpty(t, resource.StorageBackendID, "new writes must record the actual instance")
+ }
+ s, _, _, _ := newFullOutputHarness("")
+ f.wire(s)
+ content := "![report](" + ref + ")"
+ check := func() {
+ out := cleanIMContent(f.context(), content, s.newOutboundFileServiceResolver(f.tenant, nil, nil))
+ require.NotContains(t, out, "resource://")
+ u, err := url.Parse(strings.TrimSuffix(strings.TrimPrefix(out, "![report]("), ")"))
+ require.NoError(t, err)
+ require.Contains(t, u.Path, "global-artifacts/weknora/7/exports/")
+ require.Contains(t, u.Query().Get("x-oss-credential"), "global-key/")
+ require.NotEmpty(t, u.Query().Get("x-oss-signature"))
+ }
+ check()
+ resource, err = f.catalog.Resolve(f.context(), ref)
+ require.NoError(t, err)
+ require.NotEmpty(t, resource.StorageBackendID, "legacy resources acquire a concrete binding")
+ require.NotEqual(t, backend.ID, resource.StorageBackendID)
+
+ // Simulate a restart with a different process-wide driver. The prior
+ // file must retain the instance that actually stores its bytes.
+ t.Setenv("STORAGE_TYPE", "local")
+ repo := repository.NewStorageBackendRepository(f.db)
+ f.catalog = appsvc.NewResourceCatalogWithStorage(repository.NewResourceRepository(f.db), repo)
+ f.storage = appsvc.NewStorageBackendService(repo, f.db, f.catalog)
+ f.global = filesvc.NewGlobalResourceCatalogFileService(
+ filesvc.NewLocalFileService(t.TempDir(), ""), f.catalog)
+ f.wire(s)
+ check()
+ })
+ }
+ }
+}
+
+func TestIMLegacyResourceDoesNotGuessBetweenEndpoints(t *testing.T) {
+ f := newIMResourceStorageFixture(t)
+ driver := configureIMGlobalOSS(t, f)
+ legacy := filesvc.NewResourceCatalogFileService(driver, f.catalog)
+ ref, err := legacy.SaveBytes(f.context(), []byte("legacy content"), 7, "image.png", false)
+ require.NoError(t, err)
+ require.NoError(t, f.db.Create(&types.StorageBackend{
+ ID: "ambiguous", TenantID: 7, Name: "Same bucket elsewhere", Provider: "oss",
+ Config: types.StorageBackendConfig{
+ Endpoint: "https://another.example", Region: "cn-hangzhou", BucketName: "global-artifacts",
+ AccessKeyID: "different-key", SecretAccessKey: "different-secret",
+ },
+ }).Error)
+ s, _, _, _ := newFullOutputHarness("")
+ f.wire(s)
+ content := fmt.Sprintf("![legacy](%s)", ref)
+ out := cleanIMContent(f.context(), content, s.newOutboundFileServiceResolver(f.tenant, nil, nil))
+ require.Equal(t, content, out)
+ resource, err := f.catalog.Resolve(f.context(), ref)
+ require.NoError(t, err)
+ require.Empty(t, resource.StorageBackendID)
+}
diff --git a/internal/im/im_file_service_test.go b/internal/im/im_file_service_test.go
index aaae77d44..2ef565260 100644
--- a/internal/im/im_file_service_test.go
+++ b/internal/im/im_file_service_test.go
@@ -111,16 +111,16 @@ func TestRewriteStorageURLs_MinIOFallbackViaGlobal(t *testing.T) {
assert.NotContains(t, out, "](minio://")
}
-func TestRewriteStorageURLs_ScopedPath(t *testing.T) {
+func TestRewriteStorageURLs_ScopedPathRequiresBoundBackend(t *testing.T) {
stub := &stubIMFileService{
getFileURL: func(_ context.Context, filePath string) (string, error) {
- assert.Equal(t, "storage://backend-a/cos://bucket/ap-test/10000/exports/a.png", filePath)
- return "https://storage.example/a.png", nil
+ t.Fatal("an explicit backend must not fall back to global storage")
+ return "", nil
},
}
input := "![img](storage://backend-a/cos://bucket/ap-test/10000/exports/a.png)"
output := rewriteStorageURLs(context.Background(), input, newIMFileServiceResolver(&types.Tenant{}, stub))
- assert.Contains(t, output, "https://storage.example/a.png")
+ assert.Equal(t, input, output)
}
// When GetFileURL resolves a resource:// alias to a still-internal storage://
@@ -163,6 +163,6 @@ func TestCleanIMContent_MinIOFallbackIntegration(t *testing.T) {
StorageEngineConfig: &types.StorageEngineConfig{DefaultProvider: "cos"},
}
in := "see ![x](minio://wizard-test/10000/exports/x.png) ok"
- out := cleanIMContent(context.Background(), in, tenant, stub)
+ out := cleanIMContent(context.Background(), in, newIMFileServiceResolver(tenant, stub))
assert.Contains(t, out, "https://minio.example/img.png")
}
diff --git a/internal/im/resource_access.go b/internal/im/resource_access.go
new file mode 100644
index 000000000..972fb7d8c
--- /dev/null
+++ b/internal/im/resource_access.go
@@ -0,0 +1,93 @@
+package im
+
+import (
+ "context"
+ "slices"
+
+ "github.com/Tencent/WeKnora/internal/application/access"
+ "github.com/Tencent/WeKnora/internal/types"
+ "github.com/Tencent/WeKnora/internal/types/interfaces"
+ secutils "github.com/Tencent/WeKnora/internal/utils"
+)
+
+// authorizeOutboundResource checks actual file ownership and live KB sharing.
+// An answer can echo a user-supplied handle; appearing in that answer never
+// grants access to another workspace's storage credentials.
+func (s *Service) authorizeOutboundResource(
+ ctx context.Context,
+ tenant *types.Tenant,
+ agent *types.CustomAgent,
+ kbIDs []string,
+ reference string,
+) error {
+ if tenant == nil || tenant.ID == 0 || s.resourceCatalog == nil {
+ return access.ErrUnauthorized
+ }
+ caller := types.CallerFromContext(ctx)
+ if caller.TenantID != tenant.ID {
+ return access.ErrUnauthorized
+ }
+ physical, resource, err := s.resourceCatalog.ResolvePath(ctx, reference)
+ if err != nil {
+ return err
+ }
+ owner := secutils.ParseTenantIDFromStoragePath(physical)
+ if resource != nil {
+ owner = resource.TenantID
+ }
+ if owner == 0 {
+ return access.ErrForbidden
+ }
+ if owner == tenant.ID {
+ return secutils.ValidateStoragePathTenant(physical, owner)
+ }
+ bindings, ok := s.resourceCatalog.(interface {
+ interfaces.KBResourceLookup
+ interfaces.MessageFileBindingLookup
+ })
+ if !ok || s.kbService == nil || s.kbShareService == nil {
+ return access.ErrForbidden
+ }
+ origins, err := bindings.GetMessageFileBindings(ctx, owner, reference, "")
+ if err != nil {
+ return err
+ }
+ if origins == nil {
+ return access.ErrForbidden
+ }
+ for _, kbID := range origins.KnowledgeBaseIDs {
+ if !outboundKBInScope(agent, kbIDs, kbID) {
+ continue
+ }
+ kb, err := s.kbService.GetKnowledgeBaseByIDOnly(ctx, kbID)
+ if err != nil || kb == nil || kb.TenantID != owner {
+ continue
+ }
+ grant, err := access.ResolveKB(ctx, access.KBRequest{Caller: caller}, kb,
+ types.OrgRoleViewer, s.kbShareService, nil)
+ if err != nil {
+ continue
+ }
+ if _, err := access.ResolveKBFile(ctx, grant, kbID, reference, s.resourceCatalog, bindings); err == nil {
+ return nil
+ }
+ }
+ return access.ErrForbidden
+}
+
+func outboundKBInScope(agent *types.CustomAgent, kbIDs []string, kbID string) bool {
+ if len(kbIDs) != 0 {
+ return slices.Contains(kbIDs, kbID)
+ }
+ if agent == nil {
+ return true
+ }
+ switch agent.Config.KBSelectionMode {
+ case "all":
+ return true
+ case "none":
+ return false
+ default:
+ return slices.Contains(agent.Config.KnowledgeBases, kbID)
+ }
+}
diff --git a/internal/im/resource_access_test.go b/internal/im/resource_access_test.go
new file mode 100644
index 000000000..53f882dd0
--- /dev/null
+++ b/internal/im/resource_access_test.go
@@ -0,0 +1,102 @@
+package im
+
+import (
+ "context"
+ "errors"
+ "testing"
+
+ "github.com/Tencent/WeKnora/internal/types"
+ "github.com/Tencent/WeKnora/internal/types/interfaces"
+ "github.com/stretchr/testify/require"
+)
+
+type failingIMResourceCatalog struct{ interfaces.ResourceCatalog }
+
+func (s failingIMResourceCatalog) ResolvePath(context.Context, string) (string, *types.StoredResource, error) {
+ return "", nil, errors.New("catalog unavailable")
+}
+
+type failingIMShareService struct{ interfaces.KBShareService }
+
+func (s failingIMShareService) CheckTenantKBPermission(
+ context.Context, string, uint64, types.TenantRole,
+) (types.OrgMemberRole, bool, error) {
+ return "", false, errors.New("sharing unavailable")
+}
+
+func TestIMResourceAccessFailsClosed(t *testing.T) {
+ cases := []string{
+ "unshared", "binding missing", "knowledge deleted", "borrower removed", "owner removed",
+ "organization deleted", "catalog failure", "sharing failure", "missing identity",
+ "other selected KB", "no KBs", "explicit KB restriction",
+ }
+ for _, externalURL := range []string{"", "https://weknora.example"} {
+ for _, scenario := range cases {
+ t.Run(scenario+externalURL, func(t *testing.T) {
+ f := newIMResourceStorageFixture(t)
+ t.Setenv("APP_EXTERNAL_URL", externalURL)
+ s, _, _, _ := newFullOutputHarness("")
+ f.wire(s)
+ ctx := f.context()
+ var agent *types.CustomAgent
+ var kbIDs []string
+ switch scenario {
+ case "unshared":
+ require.NoError(t, f.db.Where("id = ?", "share").Delete(&types.KnowledgeBaseShare{}).Error)
+ case "binding missing":
+ require.NoError(t, f.db.Where("owner_id = ?", "shared-doc").Delete(&types.ResourceBinding{}).Error)
+ case "knowledge deleted":
+ require.NoError(t, f.db.Where("id = ?", "shared-doc").Delete(&types.Knowledge{}).Error)
+ case "borrower removed", "owner removed":
+ id := uint64(7)
+ if scenario == "owner removed" {
+ id = 9
+ }
+ require.NoError(t, f.db.Where("tenant_id = ?", id).Delete(&types.OrganizationTenantMember{}).Error)
+ case "organization deleted":
+ require.NoError(t, f.db.Where("id = ?", "org").Delete(&types.Organization{}).Error)
+ case "catalog failure":
+ s.resourceCatalog = failingIMResourceCatalog{ResourceCatalog: f.catalog}
+ case "sharing failure":
+ s.kbShareService = failingIMShareService{}
+ case "missing identity":
+ ctx = context.Background()
+ case "other selected KB":
+ agent = &types.CustomAgent{Config: types.CustomAgentConfig{
+ KBSelectionMode: "selected", KnowledgeBases: []string{"other-kb"},
+ }}
+ case "no KBs":
+ agent = &types.CustomAgent{Config: types.CustomAgentConfig{KBSelectionMode: "none"}}
+ case "explicit KB restriction":
+ kbIDs = []string{"other-kb"}
+ }
+ resource, err := f.catalog.Resolve(ctx, f.refs[2])
+ require.NoError(t, err)
+ for _, reference := range []string{f.refs[2], resource.PhysicalPath} {
+ content := "![private](" + reference + ")"
+ out := cleanIMContent(ctx, content, s.newOutboundFileServiceResolver(f.tenant, agent, kbIDs))
+ require.Equal(t, content, out, "an answer mentioning a resource cannot authorize access")
+ }
+ var grants int64
+ require.NoError(t, f.db.Model(&types.ResourceAccessGrant{}).Count(&grants).Error)
+ require.Zero(t, grants, "denied resources must not mint short-link capabilities")
+ })
+ }
+ }
+}
+
+func TestIMResourceAccessRechecksSharingWithCachedStorage(t *testing.T) {
+ f := newIMResourceStorageFixture(t)
+ s, _, _, _ := newFullOutputHarness("")
+ f.wire(s)
+ agent := &types.CustomAgent{Config: types.CustomAgentConfig{
+ KBSelectionMode: "selected", KnowledgeBases: []string{"shared-kb"},
+ }}
+ resolver := s.newOutboundFileServiceResolver(f.tenant, agent, nil)
+ content := "![shared](" + f.refs[2] + ")"
+ first := cleanIMContent(f.context(), content, resolver)
+ require.Contains(t, first, "x-oss-signature=")
+ require.NoError(t, f.db.Where("id = ?", "share").Delete(&types.KnowledgeBaseShare{}).Error)
+ require.Equal(t, content, cleanIMContent(f.context(), content, resolver),
+ "a cached storage client must not bypass a revoked share on the next stream update")
+}
diff --git a/internal/im/resource_storage_test.go b/internal/im/resource_storage_test.go
new file mode 100644
index 000000000..902fbb398
--- /dev/null
+++ b/internal/im/resource_storage_test.go
@@ -0,0 +1,297 @@
+package im
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "regexp"
+ "strings"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/Tencent/WeKnora/internal/application/repository"
+ appsvc "github.com/Tencent/WeKnora/internal/application/service"
+ filesvc "github.com/Tencent/WeKnora/internal/application/service/file"
+ "github.com/Tencent/WeKnora/internal/event"
+ "github.com/Tencent/WeKnora/internal/types"
+ "github.com/Tencent/WeKnora/internal/types/interfaces"
+ "github.com/stretchr/testify/require"
+ "gorm.io/driver/sqlite"
+ "gorm.io/gorm"
+ "gorm.io/gorm/logger"
+)
+
+// Use the real catalog, backend repository, resolver and OSS signer. Only the
+// storage HTTP server and IM delivery are local stand-ins; no cloud account or
+// platform credentials are needed to verify which instance signs each image.
+type imResourceStorageFixture struct {
+ db *gorm.DB
+ catalog interfaces.ResourceCatalog
+ storage interfaces.StorageBackendResolver
+ tenants interfaces.TenantService
+ shares interfaces.KBShareService
+ global interfaces.FileService
+ tenant *types.Tenant
+ answer string
+ refs []string
+ baseURL string
+}
+
+func newIMResourceStorageFixture(t *testing.T) *imResourceStorageFixture {
+ t.Helper()
+ t.Setenv("STORAGE_TYPE", "local")
+ t.Setenv("APP_EXTERNAL_URL", "")
+ t.Setenv("SSRF_WHITELIST", "127.0.0.1")
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodHead && r.Method != http.MethodPut {
+ w.WriteHeader(http.StatusMethodNotAllowed)
+ return
+ }
+ w.WriteHeader(http.StatusOK)
+ }))
+ t.Cleanup(server.Close)
+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
+ require.NoError(t, err)
+ sqlDB, err := db.DB()
+ require.NoError(t, err)
+ sqlDB.SetMaxOpenConns(1)
+ t.Cleanup(func() { require.NoError(t, sqlDB.Close()) })
+ require.NoError(t, db.AutoMigrate(
+ &types.Tenant{}, &types.StorageBackend{}, &types.StoredResource{},
+ &types.ResourceBinding{}, &types.ResourceAccessGrant{},
+ &types.KnowledgeBase{}, &types.Knowledge{}, &types.Organization{},
+ &types.OrganizationTenantMember{}, &types.KnowledgeBaseShare{},
+ ))
+ for _, id := range []uint64{7, 9} {
+ require.NoError(t, db.Create(&types.Tenant{ID: id, Name: fmt.Sprintf("Workspace %d", id)}).Error)
+ }
+ storageRepo := repository.NewStorageBackendRepository(db)
+ catalog := appsvc.NewResourceCatalog(repository.NewResourceRepository(db))
+ f := &imResourceStorageFixture{
+ db: db, catalog: catalog, storage: appsvc.NewStorageBackendService(storageRepo, db, catalog),
+ tenants: appsvc.NewTenantService(repository.NewTenantRepository(db), storageRepo),
+ global: filesvc.NewResourceCatalogFileService(filesvc.NewLocalFileService(t.TempDir(), ""), catalog),
+ tenant: &types.Tenant{ID: 7}, baseURL: server.URL,
+ }
+ f.shares = appsvc.NewKBShareService(repository.NewKBShareRepository(db),
+ repository.NewOrganizationRepository(db), repository.NewKnowledgeBaseRepository(db), nil, nil, nil)
+ require.NoError(t, db.Create(&types.Organization{ID: "org", Name: "Shared workspace", OwnerTenantID: 9}).Error)
+ for _, id := range []uint64{7, 9} {
+ require.NoError(t, db.Create(&types.OrganizationTenantMember{
+ ID: fmt.Sprintf("member-%d", id), OrganizationID: "org", TenantID: id, Role: types.OrgRoleViewer,
+ }).Error)
+ }
+ require.NoError(t, db.Create(&types.KnowledgeBase{ID: "shared-kb", TenantID: 9, Name: "Shared KB"}).Error)
+ require.NoError(t, db.Create(&types.Knowledge{ID: "shared-doc", TenantID: 9, KnowledgeBaseID: "shared-kb"}).Error)
+ require.NoError(t, db.Create(&types.KnowledgeBaseShare{
+ ID: "share", KnowledgeBaseID: "shared-kb", OrganizationID: "org",
+ SourceTenantID: 9, Permission: types.OrgRoleViewer,
+ }).Error)
+ for i, owner := range []uint64{7, 7, 9} {
+ backend := &types.StorageBackend{
+ ID: fmt.Sprintf("oss-%d", i), TenantID: owner, Name: fmt.Sprintf("OSS %d", i), Provider: "oss",
+ Config: types.StorageBackendConfig{
+ Endpoint: server.URL, Region: "cn-hangzhou", BucketName: fmt.Sprintf("bucket-%d", i),
+ AccessKeyID: fmt.Sprintf("instance-key-%d", i), SecretAccessKey: "test-only-secret",
+ },
+ }
+ require.NoError(t, storageRepo.Create(context.Background(), backend))
+ physical := fmt.Sprintf("storage://%s/oss://bucket-%d/%d/exports/image.png", backend.ID, i, owner)
+ ref, err := catalog.Register(context.Background(), owner, physical,
+ interfaces.ResourceRegistration{Kind: "image", OriginalName: "image.png"})
+ require.NoError(t, err)
+ if owner == 9 {
+ require.NoError(t, catalog.Bind(context.Background(), ref,
+ types.ResourceOwnerKnowledge, "shared-doc", types.ResourceRelationExtractedImage))
+ }
+ f.refs = append(f.refs, ref)
+ f.answer += fmt.Sprintf("![image %d](%s)\n", i, ref)
+ }
+ return f
+}
+
+func (f *imResourceStorageFixture) wire(s *Service) {
+ s.defaultFileSvc = f.global
+ s.resourceCatalog = f.catalog
+ s.storageResolver = f.storage
+ s.tenantService = f.tenants
+ s.kbService = &resourceKBLookup{db: f.db}
+ s.kbShareService = f.shares
+}
+
+type resourceKBLookup struct {
+ interfaces.KnowledgeBaseService
+ db *gorm.DB
+}
+
+func (s *resourceKBLookup) GetKnowledgeBaseByIDOnly(ctx context.Context, id string) (*types.KnowledgeBase, error) {
+ var kb types.KnowledgeBase
+ if err := s.db.WithContext(ctx).Where("id = ?", id).First(&kb).Error; err != nil {
+ return nil, err
+ }
+ return &kb, nil
+}
+
+func (f *imResourceStorageFixture) context() context.Context {
+ return withIMIdentity(context.Background(), &IMChannel{TenantID: f.tenant.ID},
+ &IncomingMessage{Platform: PlatformWeCom, UserID: "test-user"})
+}
+
+func (f *imResourceStorageFixture) checkSignedImages(t *testing.T, content string) {
+ t.Helper()
+ require.NotContains(t, content, "resource://")
+ images := regexp.MustCompile(`!\[[^\]]*\]\(([^)]+)\)`).FindAllStringSubmatch(content, -1)
+ require.Len(t, images, 3)
+ for i, match := range images {
+ u, err := url.Parse(match[1])
+ require.NoError(t, err)
+ require.Equal(t, strings.TrimPrefix(f.baseURL, "http://"), u.Host)
+ require.Contains(t, u.Path, fmt.Sprintf("bucket-%d/", i))
+ require.Contains(t, u.Query().Get("x-oss-credential"), fmt.Sprintf("instance-key-%d/", i))
+ require.NotEmpty(t, u.Query().Get("x-oss-signature"))
+ }
+}
+
+func TestIMDeliveryUsesResourceStorageAcrossPlatformsAndModes(t *testing.T) {
+ f := newIMResourceStorageFixture(t)
+ checkIMDeliveryModes(t, f, f.checkSignedImages)
+}
+
+func TestIMDeliveryDoesNotSignUnsharedResourcesAcrossPlatformsAndModes(t *testing.T) {
+ f := newIMResourceStorageFixture(t)
+ require.NoError(t, f.db.Where("id = ?", "share").Delete(&types.KnowledgeBaseShare{}).Error)
+ f.answer = "![private image](" + f.refs[2] + ")"
+ checkIMDeliveryModes(t, f, func(t *testing.T, content string) {
+ require.Equal(t, f.answer, content)
+ })
+}
+
+func checkIMDeliveryModes(t *testing.T, f *imResourceStorageFixture, check func(*testing.T, string)) {
+ t.Helper()
+ platforms := []Platform{
+ PlatformWeCom, PlatformFeishu, PlatformLark, PlatformDingtalk,
+ PlatformSlack, PlatformTelegram, PlatformMattermost, PlatformWeChat, PlatformQQBot, PlatformYunzhijia,
+ }
+ modes := []string{"stream", "full", "full without progress", "stream start failure", "stream finalize failure"}
+ for _, platform := range platforms {
+ for _, mode := range modes {
+ t.Run(string(platform)+"/"+mode, func(t *testing.T) {
+ s, adapter, _, _ := newFullOutputHarness(f.answer)
+ f.wire(s)
+ messages := &deliveryMessageService{}
+ s.messageService = messages
+ channel := &IMChannel{OutputMode: "stream"}
+ var sender Adapter = adapter
+ switch mode {
+ case "full":
+ channel.OutputMode = "full"
+ case "full without progress":
+ channel.OutputMode = "full"
+ sender = &fullOutputNoProgressAdapter{fullOutputAdapter: adapter}
+ case "stream start failure":
+ adapter.startErr = errors.New("stream unavailable")
+ case "stream finalize failure":
+ adapter.finalizeErr = errors.New("update failed")
+ }
+ ctx, cancel := context.WithCancel(f.context())
+ defer cancel()
+ s.executeQARequest(&qaRequest{
+ ctx: ctx, cancel: cancel, tenant: f.tenant, channel: channel, adapter: sender,
+ msg: &IncomingMessage{Platform: platform, UserID: "test-user", Content: "Show the images"},
+ session: &types.Session{ID: "test-session"}, userKey: "test-user",
+ })
+ content := adapter.finalContent
+ if adapter.plainReplies > 0 {
+ content = adapter.plainContent
+ }
+ check(t, content)
+ require.NotNil(t, messages.saved)
+ require.Equal(t, strings.TrimSpace(f.answer), strings.TrimSpace(messages.saved.Content),
+ "persist stable references, not signed URLs")
+ })
+ }
+ }
+}
+
+func TestIMResourceStoragePreservesShortLinksAndRejectsUnavailableInstances(t *testing.T) {
+ f := newIMResourceStorageFixture(t)
+ s, _, _, _ := newFullOutputHarness(f.answer)
+ f.wire(s)
+ ctx := f.context()
+ t.Setenv("APP_EXTERNAL_URL", "https://weknora.example")
+ out := cleanIMContent(ctx, f.answer, s.newOutboundFileServiceResolver(f.tenant, nil, nil))
+ require.Equal(t, 3, strings.Count(out, "https://weknora.example/r/"))
+ require.NotContains(t, out, "resource://")
+
+ t.Setenv("APP_EXTERNAL_URL", "")
+ require.NoError(t, f.db.Model(&types.StorageBackend{}).Where("id = ?", "oss-0").
+ Update("status", types.StorageBackendStatusDisabled).Error)
+ require.NoError(t, f.db.Where("id = ?", "oss-1").Delete(&types.StorageBackend{}).Error)
+ out = cleanIMContent(ctx, f.answer, s.newOutboundFileServiceResolver(f.tenant, nil, nil))
+ require.Contains(t, out, f.refs[0])
+ require.Contains(t, out, f.refs[1])
+ require.NotContains(t, out, f.refs[2], "the available shared instance still resolves")
+ require.Contains(t, out, "x-oss-signature=")
+}
+
+type resourceStreamingSession struct {
+ interfaces.SessionService
+ answer string
+ updated <-chan struct{}
+}
+
+func (s *resourceStreamingSession) KnowledgeQA(ctx context.Context, req *types.QARequest, bus *event.EventBus) error {
+ if err := bus.Emit(ctx, event.Event{
+ Type: event.EventAgentFinalAnswer, SessionID: req.Session.ID,
+ Data: event.AgentFinalAnswerData{Content: s.answer},
+ }); err != nil {
+ return err
+ }
+ select {
+ case <-s.updated:
+ case <-ctx.Done():
+ return ctx.Err()
+ }
+ return bus.Emit(ctx, event.Event{
+ Type: event.EventAgentFinalAnswer, SessionID: req.Session.ID,
+ Data: event.AgentFinalAnswerData{Done: true},
+ })
+}
+
+type resourceStreamingAdapter struct {
+ *fullOutputAdapter
+ once sync.Once
+ updated chan struct{}
+ content string
+}
+
+func (a *resourceStreamingAdapter) UpdateStreamContent(
+ ctx context.Context,
+ msg *IncomingMessage,
+ streamID, content string,
+) error {
+ a.content = content
+ a.once.Do(func() { close(a.updated) })
+ return a.fullOutputAdapter.UpdateStreamContent(ctx, msg, streamID, content)
+}
+
+func TestIMStreamUpdatesUseResourceStorageBeforeCompletion(t *testing.T) {
+ f := newIMResourceStorageFixture(t)
+ s, base, _, _ := newFullOutputHarness(f.answer)
+ f.wire(s)
+ adapter := &resourceStreamingAdapter{fullOutputAdapter: base, updated: make(chan struct{})}
+ s.sessionService = &resourceStreamingSession{answer: f.answer, updated: adapter.updated}
+ ctx, cancel := context.WithTimeout(f.context(), 5*time.Second)
+ defer cancel()
+ err := s.handleMessageStream(ctx,
+ &IncomingMessage{Platform: PlatformWeCom, UserID: "test-user", Content: "Show the images"},
+ &types.Session{ID: "test-session"}, nil, nil, nil, nil, adapter, adapter, "test-user", f.tenant)
+ require.NoError(t, err)
+ require.Positive(t, adapter.updates)
+ f.checkSignedImages(t, adapter.content)
+ f.checkSignedImages(t, adapter.finalContent)
+}
diff --git a/internal/im/service.go b/internal/im/service.go
index 838afb7e5..f61c700b8 100644
--- a/internal/im/service.go
+++ b/internal/im/service.go
@@ -141,8 +141,8 @@ func holdbackCutoff(chunk string) int {
}
// formatIMOutboundAnswer strips thinking/tool blocks and applies IM content cleanup.
-func formatIMOutboundAnswer(ctx context.Context, raw string, tenant *types.Tenant, defaultFileSvc interfaces.FileService, storageResolvers ...interfaces.StorageBackendResolver) string {
- return cleanIMContent(ctx, FormatIMDisplayContent(raw, StreamDisplayFinal), tenant, defaultFileSvc, storageResolvers...)
+func formatIMOutboundAnswer(ctx context.Context, raw string, resolver *storageurl.FileServiceResolver) string {
+ return cleanIMContent(ctx, FormatIMDisplayContent(raw, StreamDisplayFinal), resolver)
}
// formatIMOutboundAnswerOrFallback guarantees that cleanup cannot turn a
@@ -152,11 +152,9 @@ func formatIMOutboundAnswer(ctx context.Context, raw string, tenant *types.Tenan
func formatIMOutboundAnswerOrFallback(
ctx context.Context,
raw string,
- tenant *types.Tenant,
- defaultFileSvc interfaces.FileService,
- storageResolvers ...interfaces.StorageBackendResolver,
+ resolver *storageurl.FileServiceResolver,
) string {
- content := formatIMOutboundAnswer(ctx, raw, tenant, defaultFileSvc, storageResolvers...)
+ content := formatIMOutboundAnswer(ctx, raw, resolver)
if strings.TrimSpace(content) == "" {
return imNoAnswerFallback
}
@@ -184,11 +182,13 @@ func imQAFailureReply(err error) string {
// cleanIMContent applies all IM-specific content transformations:
// 1. Collapse <image> XML blocks back to plain markdown
// 2. Strip <kb/> and <web/> citation tags
-// 3. Rewrite provider:// URLs to HTTP URLs (scheme-aware per tenant config)
-func cleanIMContent(ctx context.Context, content string, tenant *types.Tenant, defaultFileSvc interfaces.FileService, storageResolvers ...interfaces.StorageBackendResolver) string {
+// 3. Rewrite storage references to HTTP URLs using their owning storage instance
+func cleanIMContent(ctx context.Context, content string, resolver *storageurl.FileServiceResolver) string {
content = stripImageXMLTags(content)
content = stripIMCitationTags(content)
- resolver := newIMFileServiceResolver(tenant, defaultFileSvc, storageResolvers...).WithContext(ctx)
+ if resolver != nil {
+ resolver.WithContext(ctx)
+ }
content = rewriteStorageURLs(ctx, content, resolver)
return content
}
@@ -204,6 +204,21 @@ func newIMFileServiceResolver(
return storageurl.NewFileServiceResolver(tenant, defaultSvc, storageResolvers...)
}
+// Every platform and output mode uses the same resource-aware resolver. Keep
+// it scoped to the reply so shared KB images select their owner's backend and
+// multiple images on the same instance reuse its client during streaming.
+func (s *Service) newOutboundFileServiceResolver(
+ tenant *types.Tenant,
+ agent *types.CustomAgent,
+ kbIDs []string,
+) *storageurl.FileServiceResolver {
+ return newIMFileServiceResolver(tenant, s.defaultFileSvc, s.storageResolver).
+ WithResources(s.resourceCatalog, s.tenantService).
+ WithAuthorization(func(ctx context.Context, reference string) error {
+ return s.authorizeOutboundResource(ctx, tenant, agent, kbIDs, reference)
+ })
+}
+
func buildIMFileServiceForProvider(
tenant *types.Tenant,
provider string,
@@ -298,7 +313,8 @@ type Service struct {
knowledgeService interfaces.KnowledgeService
// kbService is used by slash-commands (/info) to list and inspect knowledge bases.
- kbService interfaces.KnowledgeBaseService
+ kbService interfaces.KnowledgeBaseService
+ kbShareService interfaces.KBShareService
// oauthManager builds MCP OAuth authorization URLs so IM users can authorize
// OAuth-enabled MCP services out-of-band (IM cannot resolve the in-conversation
@@ -315,6 +331,7 @@ type Service struct {
defaultFileSvc interfaces.FileService
documentReader interfaces.DocumentReader
storageResolver interfaces.StorageBackendResolver
+ resourceCatalog interfaces.ResourceCatalog
// cmdRegistry holds all registered slash-commands.
cmdRegistry *CommandRegistry
@@ -858,6 +875,8 @@ func NewService(
redisClient *redis.Client,
appCfg *config.Config,
storageResolver interfaces.StorageBackendResolver,
+ resourceCatalog interfaces.ResourceCatalog,
+ kbShareService interfaces.KBShareService,
) *Service {
// Resolve IM configuration with defaults.
workers, maxQueue, maxPerUser, globalMaxWorkers, rlWindow, rlMax := resolveIMConfig(appCfg)
@@ -883,6 +902,8 @@ func NewService(
defaultFileSvc: defaultFileSvc,
documentReader: documentReader,
storageResolver: storageResolver,
+ resourceCatalog: resourceCatalog,
+ kbShareService: kbShareService,
oauthManager: oauthManager,
cmdRegistry: registry,
channels: make(map[string]*channelState),
@@ -2005,7 +2026,8 @@ func (s *Service) executeQARequest(req *qaRequest) {
outCtx := imOutboundContext(ctx)
reply := &ReplyMessage{
- Content: formatIMOutboundAnswerOrFallback(outCtx, answer, req.tenant, s.defaultFileSvc, s.storageResolver),
+ Content: formatIMOutboundAnswerOrFallback(outCtx, answer,
+ s.newOutboundFileServiceResolver(req.tenant, req.agent, kbIDs)),
IsFinal: true,
}
if err := req.adapter.SendReply(outCtx, req.msg, reply); err != nil {
@@ -2053,7 +2075,8 @@ func (s *Service) handleMessageFullOutput(
// QA (and /stop) may have cancelled ctx. Platform updates must still run so
// the thinking card is replaced instead of hanging forever.
outCtx := imOutboundContext(ctx)
- finalContent := formatIMOutboundAnswerOrFallback(outCtx, answer, tenant, s.defaultFileSvc, s.storageResolver)
+ finalContent := formatIMOutboundAnswerOrFallback(outCtx, answer,
+ s.newOutboundFileServiceResolver(tenant, customAgent, kbIDs))
finalizeErr := streamer.FinalizeStream(outCtx, msg, streamID, finalContent)
if finalizeErr != nil {
@@ -2829,6 +2852,7 @@ func (s *Service) handleMessageStream(ctx context.Context, msg *IncomingMessage,
// XML tags that straddle a chunk boundary (see holdbackCutoff).
ticker := time.NewTicker(streamFlushInterval)
defer ticker.Stop()
+ fileResolver := s.newOutboundFileServiceResolver(tenant, customAgent, kbIDs)
flush := func() {
bufMu.Lock()
@@ -2845,7 +2869,7 @@ func (s *Service) handleMessageStream(ctx context.Context, msg *IncomingMessage,
displaySource = displaySource[:cut]
}
- display := cleanIMContent(ctx, displaySource, tenant, s.defaultFileSvc, s.storageResolver)
+ display := cleanIMContent(ctx, displaySource, fileResolver)
if err := streamer.UpdateStreamContent(ctx, msg, streamID, display); err != nil {
logger.Warnf(ctx, "[IM] UpdateStreamContent failed: %v", err)
}
@@ -2885,7 +2909,7 @@ loop:
bufMu.Unlock()
outCtx := imOutboundContext(ctx)
- finalDisplay := cleanIMContent(outCtx, FormatIMFinalFromParts(parts), tenant, s.defaultFileSvc, s.storageResolver)
+ finalDisplay := cleanIMContent(outCtx, FormatIMFinalFromParts(parts), fileResolver)
if noVisibleContent || finalDisplay == "" {
fallback := imNoAnswerFallback
if finalErr != nil {
@@ -2949,7 +2973,8 @@ func (s *Service) fallbackNonStream(ctx context.Context, msg *IncomingMessage, s
outCtx := imOutboundContext(ctx)
return adapter.SendReply(outCtx, msg, &ReplyMessage{
- Content: formatIMOutboundAnswerOrFallback(outCtx, answer, tenant, s.defaultFileSvc, s.storageResolver),
+ Content: formatIMOutboundAnswerOrFallback(outCtx, answer,
+ s.newOutboundFileServiceResolver(tenant, customAgent, kbIDs)),
IsFinal: true,
})
}
diff --git a/internal/storageurl/resolver.go b/internal/storageurl/resolver.go
index 550552ca7..33fe29990 100644
--- a/internal/storageurl/resolver.go
+++ b/internal/storageurl/resolver.go
@@ -21,7 +21,13 @@ func LocalStorageBaseDir() string {
return baseDir
}
-// FileServiceResolver resolves and caches one FileService per storage provider.
+type fileServiceKey struct {
+ tenantID uint64
+ backendID string
+ provider string
+}
+
+// FileServiceResolver resolves and caches one FileService per owner and storage instance.
// The cache is scoped to a single request or outbound message so a long answer
// with many images does not re-create an SDK client per reference.
//
@@ -30,13 +36,17 @@ type FileServiceResolver struct {
tenant *types.Tenant
defaultSvc interfaces.FileService
storageResolver interfaces.StorageBackendResolver
+ resourceCatalog interfaces.ResourceCatalog
+ tenantService interfaces.TenantService
ctx context.Context
- cache map[string]interfaces.FileService
+ cache map[fileServiceKey]interfaces.FileService
+ owners map[uint64]*types.Tenant
+ authorize func(context.Context, string) error
}
// NewFileServiceResolver builds a resolver for tenant. defaultSvc is the
-// process-wide FileService used for `resource://` handles and as the fallback
-// when tenant storage config is missing.
+// process-wide fallback for legacy references without an explicit backend.
+// WithResources enables owner/instance routing for resource:// handles.
func NewFileServiceResolver(
tenant *types.Tenant,
defaultSvc interfaces.FileService,
@@ -46,7 +56,8 @@ func NewFileServiceResolver(
tenant: tenant,
defaultSvc: defaultSvc,
ctx: context.Background(),
- cache: make(map[string]interfaces.FileService),
+ cache: make(map[fileServiceKey]interfaces.FileService),
+ owners: make(map[uint64]*types.Tenant),
}
if len(storageResolvers) > 0 {
resolver.storageResolver = storageResolvers[0]
@@ -54,6 +65,25 @@ func NewFileServiceResolver(
return resolver
}
+// WithResources enables routing resource handles through their recorded owner
+// and storage instance. Callers must already be authorized to expose the
+// references; this only selects storage and does not grant resource access.
+func (r *FileServiceResolver) WithResources(
+ catalog interfaces.ResourceCatalog,
+ tenants interfaces.TenantService,
+) *FileServiceResolver {
+ r.resourceCatalog = catalog
+ r.tenantService = tenants
+ return r
+}
+
+// WithAuthorization gates every reference before any storage credentials are
+// selected. Model output and editable Markdown are not authorization evidence.
+func (r *FileServiceResolver) WithAuthorization(authorize func(context.Context, string) error) *FileServiceResolver {
+ r.authorize = authorize
+ return r
+}
+
// WithContext sets the context used for backend lookups and their logs.
func (r *FileServiceResolver) WithContext(ctx context.Context) *FileServiceResolver {
if ctx != nil {
@@ -64,7 +94,16 @@ func (r *FileServiceResolver) WithContext(ctx context.Context) *FileServiceResol
// ResolveFileService implements Resolver.
func (r *FileServiceResolver) ResolveFileService(filePath string) interfaces.FileService {
+ if r.authorize != nil {
+ if err := r.authorize(r.ctx, filePath); err != nil {
+ logger.Warnf(r.ctx, "resource URL access denied: src=%s err=%v", filePath, err)
+ return nil
+ }
+ }
if _, ok := types.ParseResourcePath(filePath); ok {
+ if r.resourceCatalog != nil {
+ return r.resolveResource(filePath)
+ }
return r.defaultSvc
}
backendID, _, _ := types.ParseStorageBackendPath(filePath)
@@ -77,20 +116,73 @@ func (r *FileServiceResolver) ResolveFileService(filePath string) interfaces.Fil
return nil
}
}
- cacheKey := backendID + ":" + provider
+ return r.resolveStorage(r.tenant, backendID, provider, backendID == "")
+}
+
+func (r *FileServiceResolver) resolveResource(reference string) interfaces.FileService {
+ resolve := r.resourceCatalog.Resolve
+ if bindings, ok := r.resourceCatalog.(interfaces.ResourceStorageBindingResolver); ok {
+ resolve = bindings.ResolveStorageBinding
+ }
+ resource, err := resolve(r.ctx, reference)
+ if err != nil || resource == nil || resource.TenantID == 0 {
+ logger.Warnf(r.ctx, "resolve resource storage failed: src=%s err=%v", reference, err)
+ return nil
+ }
+ tenant := r.tenant
+ if tenant == nil || tenant.ID != resource.TenantID {
+ tenant = r.owners[resource.TenantID]
+ if tenant == nil && r.tenantService != nil {
+ tenant, err = r.tenantService.GetTenantByID(r.ctx, resource.TenantID)
+ }
+ if err != nil || tenant == nil || tenant.ID != resource.TenantID {
+ logger.Warnf(r.ctx, "resolve resource owner failed: src=%s tenant_id=%d err=%v",
+ reference, resource.TenantID, err)
+ return nil
+ }
+ r.owners[resource.TenantID] = tenant
+ }
+ backendID := resource.StorageBackendID
+ if backendID == "" {
+ backendID, _, _ = types.ParseStorageBackendPath(resource.PhysicalPath)
+ }
+ if backendID == "" {
+ return nil
+ }
+ provider := resource.Provider
+ if provider == "" {
+ provider = types.ParseProviderScheme(resource.PhysicalPath)
+ }
+ // A registered resource belongs to this owner's backend. Failure must not
+ // sign its physical path with unrelated process-global credentials.
+ return r.resolveStorage(tenant, backendID, provider, false)
+}
+
+func (r *FileServiceResolver) resolveStorage(
+ tenant *types.Tenant,
+ backendID, provider string,
+ allowFallback bool,
+) interfaces.FileService {
+ cacheKey := fileServiceKey{backendID: backendID, provider: provider}
+ if tenant != nil {
+ cacheKey.tenantID = tenant.ID
+ }
if svc, ok := r.cache[cacheKey]; ok {
return svc
}
- if r.storageResolver != nil && r.tenant != nil {
- svc, _, err := r.storageResolver.ResolveFileService(r.ctx, r.tenant, backendID, provider, LocalStorageBaseDir())
- if err == nil {
+ if r.storageResolver != nil && tenant != nil {
+ svc, _, err := r.storageResolver.ResolveFileService(r.ctx, tenant, backendID, provider, LocalStorageBaseDir())
+ if err == nil && svc != nil {
r.cache[cacheKey] = svc
return svc
}
logger.Warnf(r.ctx, "resolve storage backend failed: backend_id=%s provider=%s err=%v",
backendID, provider, err)
}
- svc := BuildFileServiceForProvider(r.tenant, provider, r.defaultSvc)
+ if !allowFallback {
+ return nil
+ }
+ svc := BuildFileServiceForProvider(tenant, provider, r.defaultSvc)
if svc != nil {
r.cache[cacheKey] = svc
}
diff --git a/internal/storageurl/resolver_test.go b/internal/storageurl/resolver_test.go
new file mode 100644
index 000000000..789495f2e
--- /dev/null
+++ b/internal/storageurl/resolver_test.go
@@ -0,0 +1,198 @@
+package storageurl
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "testing"
+ "time"
+
+ filesvc "github.com/Tencent/WeKnora/internal/application/service/file"
+ "github.com/Tencent/WeKnora/internal/types"
+ "github.com/Tencent/WeKnora/internal/types/interfaces"
+ "github.com/stretchr/testify/require"
+)
+
+type resolverResourceCatalog struct {
+ interfaces.ResourceCatalog
+ resources map[string]*types.StoredResource
+}
+
+func (c *resolverResourceCatalog) Resolve(_ context.Context, ref string) (*types.StoredResource, error) {
+ resource := c.resources[ref]
+ if resource == nil {
+ return nil, errors.New("resource not found")
+ }
+ return resource, nil
+}
+
+func (c *resolverResourceCatalog) ResolvePath(ctx context.Context, ref string) (string, *types.StoredResource, error) {
+ if _, ok := types.ParseResourcePath(ref); !ok {
+ return ref, nil, nil
+ }
+ resource, err := c.Resolve(ctx, ref)
+ if err != nil {
+ return "", nil, err
+ }
+ return resource.PhysicalPath, resource, nil
+}
+
+func (c *resolverResourceCatalog) CreateAccessGrant(context.Context, string, time.Duration) (string, error) {
+ return "resource-grant", nil
+}
+
+type resolverTenantService struct {
+ interfaces.TenantService
+ get func(uint64) (*types.Tenant, error)
+}
+
+func (s *resolverTenantService) GetTenantByID(_ context.Context, id uint64) (*types.Tenant, error) {
+ return s.get(id)
+}
+
+type resolverStorageService struct {
+ interfaces.StorageBackendResolver
+ resolve func(context.Context, *types.Tenant, string, string) (interfaces.FileService, string, error)
+}
+
+func (s *resolverStorageService) ResolveFileService(
+ ctx context.Context,
+ tenant *types.Tenant,
+ backendID, provider, _ string,
+) (interfaces.FileService, string, error) {
+ return s.resolve(ctx, tenant, backendID, provider)
+}
+
+func TestResourceURLsUseBoundStorageDespiteGlobalDefault(t *testing.T) {
+ for _, globalType := range []string{"local", "minio", "oss"} {
+ t.Run(globalType, func(t *testing.T) {
+ t.Setenv("STORAGE_TYPE", globalType)
+ t.Setenv("APP_EXTERNAL_URL", "")
+ catalog := &resolverResourceCatalog{resources: map[string]*types.StoredResource{}}
+ for i, backendID := range []string{"oss-a", "oss-b", "oss-a"} {
+ ref := types.BuildResourcePath(fmt.Sprintf("Handle%016d", i))
+ catalog.resources[ref] = &types.StoredResource{
+ TenantID: 7, StorageBackendID: backendID, Provider: "oss",
+ PhysicalPath: fmt.Sprintf("storage://%s/oss://bucket-%s/7/exports/%d.png", backendID, backendID, i),
+ }
+ }
+ global := &stubFileService{}
+ lookups := map[string]int{}
+ storage := &resolverStorageService{resolve: func(
+ _ context.Context,
+ tenant *types.Tenant,
+ backendID, provider string,
+ ) (interfaces.FileService, string, error) {
+ require.Equal(t, uint64(7), tenant.ID)
+ require.Equal(t, "oss", provider)
+ lookups[backendID]++
+ driver := &stubFileService{getFileURL: func(_ context.Context, path string) (string, error) {
+ require.Contains(t, path, "oss://bucket-"+backendID+"/")
+ return "https://" + backendID + ".example/image.png", nil
+ }}
+ scoped := filesvc.NewBackendScopedFileService(backendID, driver)
+ return filesvc.NewResourceCatalogFileService(scoped, catalog), provider, nil
+ }}
+ resolver := NewFileServiceResolver(&types.Tenant{ID: 7}, global, storage).WithResources(catalog, nil)
+ w := NewRewriter(resolver, "TEST")
+ for i, backendID := range []string{"oss-a", "oss-b", "oss-a"} {
+ ref := types.BuildResourcePath(fmt.Sprintf("Handle%016d", i))
+ require.Equal(t, "![image](https://"+backendID+".example/image.png)",
+ w.String(context.Background(), "![image]("+ref+")"))
+ }
+ require.Zero(t, global.calls, "bound resources must never use the global driver")
+ require.Equal(t, map[string]int{"oss-a": 1, "oss-b": 1}, lookups,
+ "cache by storage instance, not just provider")
+ })
+ }
+}
+
+func TestResourceURLsUseOwnerTenantAndPreserveShortLinks(t *testing.T) {
+ for _, externalURL := range []string{"", "https://weknora.example"} {
+ t.Run(externalURL, func(t *testing.T) {
+ t.Setenv("APP_EXTERNAL_URL", externalURL)
+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"
+ catalog := &resolverResourceCatalog{resources: map[string]*types.StoredResource{
+ ref: {
+ TenantID: 9, StorageBackendID: "owner-oss", Provider: "oss",
+ PhysicalPath: "storage://owner-oss/oss://bucket/9/image.png",
+ },
+ }}
+ owner := &types.Tenant{ID: 9}
+ tenants := &resolverTenantService{get: func(id uint64) (*types.Tenant, error) {
+ require.Equal(t, owner.ID, id)
+ return owner, nil
+ }}
+ global := &stubFileService{}
+ storage := &resolverStorageService{resolve: func(
+ _ context.Context,
+ tenant *types.Tenant,
+ backendID, provider string,
+ ) (interfaces.FileService, string, error) {
+ require.Same(t, owner, tenant)
+ require.Equal(t, "owner-oss", backendID)
+ require.Equal(t, "oss", provider)
+ driver := &stubFileService{getFileURL: func(context.Context, string) (string, error) {
+ return "https://owner-oss.example/image.png", nil
+ }}
+ return filesvc.NewResourceCatalogFileService(driver, catalog), provider, nil
+ }}
+ resolver := NewFileServiceResolver(&types.Tenant{ID: 7}, global, storage).WithResources(catalog, tenants)
+ want := "https://owner-oss.example/image.png"
+ if externalURL != "" {
+ want = externalURL + "/r/resource-grant"
+ }
+ require.Equal(t, want, NewRewriter(resolver, "TEST").Ref(context.Background(), ref))
+ require.Zero(t, global.calls)
+ })
+ }
+}
+
+func TestResourceURLResolutionFailureDoesNotFallBackToGlobal(t *testing.T) {
+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"
+ failures := []string{"resource missing", "owner missing", "backend missing", "backend disabled", "resolver missing"}
+ for _, failure := range failures {
+ t.Run(failure, func(t *testing.T) {
+ t.Setenv("APP_EXTERNAL_URL", "")
+ catalog := &resolverResourceCatalog{resources: map[string]*types.StoredResource{}}
+ if failure != "resource missing" {
+ catalog.resources[ref] = &types.StoredResource{
+ TenantID: 9, StorageBackendID: "bound-oss", Provider: "oss",
+ PhysicalPath: "storage://bound-oss/oss://bucket/9/image.png",
+ }
+ }
+ tenants := &resolverTenantService{get: func(id uint64) (*types.Tenant, error) {
+ if failure == "owner missing" {
+ return nil, errors.New(failure)
+ }
+ return &types.Tenant{ID: id}, nil
+ }}
+ storage := &resolverStorageService{resolve: func(
+ context.Context, *types.Tenant, string, string,
+ ) (interfaces.FileService, string, error) {
+ return nil, "", errors.New(failure)
+ }}
+ global := &stubFileService{}
+ var backends interfaces.StorageBackendResolver = storage
+ if failure == "resolver missing" {
+ backends = nil
+ }
+ resolver := NewFileServiceResolver(&types.Tenant{ID: 7}, global, backends).WithResources(catalog, tenants)
+ require.Equal(t, ref, NewRewriter(resolver, "TEST").Ref(context.Background(), ref))
+ require.Zero(t, global.calls)
+ })
+ }
+}
+
+func TestExplicitStorageBackendFailureDoesNotFallBackToGlobal(t *testing.T) {
+ global := &stubFileService{}
+ storage := &resolverStorageService{resolve: func(
+ context.Context, *types.Tenant, string, string,
+ ) (interfaces.FileService, string, error) {
+ return nil, "", errors.New("backend unavailable")
+ }}
+ resolver := NewFileServiceResolver(&types.Tenant{ID: 7}, global, storage)
+ const ref = "storage://bound-oss/oss://bucket/7/image.png"
+ require.Equal(t, ref, NewRewriter(resolver, "TEST").Ref(context.Background(), ref))
+ require.Zero(t, global.calls)
+}
diff --git a/internal/types/interfaces/resource.go b/internal/types/interfaces/resource.go
index 04b79a817..f4d14d416 100644
--- a/internal/types/interfaces/resource.go
+++ b/internal/types/interfaces/resource.go
@@ -25,6 +25,8 @@ type ResourceRepository interface {
GetByID(ctx context.Context, id string) (*types.StoredResource, error)
GetByHandle(ctx context.Context, handle string) (*types.StoredResource, error)
GetByTenantLocation(ctx context.Context, tenantID uint64, locationHash string) (*types.StoredResource, error)
+ // BindStorageBackend fills an absent binding without replacing an existing one.
+ BindStorageBackend(ctx context.Context, id, backendID string) (*types.StoredResource, error)
// GetActiveByContentHash finds a live resource holding the exact same
// bytes. Unlike location, content is not unique: several rows may carry
// the same hash (duplicates registered before this lookup existed), so
@@ -52,12 +54,24 @@ type ResourceRepository interface {
// ResourceRegistration describes one physical object at registration time.
type ResourceRegistration struct {
- Kind string
- MimeType string
- OriginalName string
- Size int64
- ContentHash string
- Temporary bool
+ StorageBackendID string
+ Kind string
+ MimeType string
+ OriginalName string
+ Size int64
+ ContentHash string
+ Temporary bool
+}
+
+// GlobalResourceRegistrar records the concrete instance used by the process-wide writer.
+type GlobalResourceRegistrar interface {
+ RegisterGlobal(ctx context.Context, tenantID uint64, physicalPath string, meta ResourceRegistration) (string, error)
+}
+
+// ResourceStorageBindingResolver resolves legacy, unbound resources only when
+// their physical location identifies a single storage instance.
+type ResourceStorageBindingResolver interface {
+ ResolveStorageBinding(ctx context.Context, reference string) (*types.StoredResource, error)
}
// ResourceCatalog maps public resource references to internal storage
diff --git a/website-docs/03-features/12-im-integration.md b/website-docs/03-features/12-im-integration.md
index a2904a876..d8afa1784 100644
--- a/website-docs/03-features/12-im-integration.md
+++ b/website-docs/03-features/12-im-integration.md
@@ -61,8 +61,11 @@ IM 集成将智能体接入企业微信、飞书、钉钉、Slack、Telegram 等
答案里引用知识库图片时,正文中是 `resource://` 或 `local://` / `minio://` 等内部引用,IM 客户端无法直接拉取。`rewriteStorageURLs`(`internal/im/service.go`)在发送前把它们换成可访问的 http(s) URL:
+- 各 IM 渠道共用这条转换链路。`resource://` 按资源记录中的所属空间和存储实例生成链接;同一回答可引用多个实例,共享知识库图片使用资源所属空间的实例,无需把全局 `STORAGE_TYPE` 改成相同类型。绑定实例缺失、停用或解析失败时保留原引用并记录 WARN,不回退到全局存储;
+- 跨空间图片在签名前检查实际知识库绑定、当前共享权限和智能体知识库范围;仅在答案中出现引用不会获得访问权。共享撤销后不再签发新链接;已签发链接仍按原有效期过期;
+- 聊天附件和生成文件在写入时记录实际使用的全局存储实例。历史未绑定资源仅在物理路径能唯一匹配存储位置时补齐绑定,不使用空间默认存储猜测;
- 解析结果**不是** http(s) 时(例如仍是内部 `storage://` 路径),保留原引用并打一条可操作的 WARN,而不是把 IM 端注定加载失败的链接发出去;
-- 成功改写记 INFO 日志(含签名 URL,便于排障,代价是有日志权限的人可在有效期内使用该链接)。
+- 成功改写的 INFO 日志只记录原引用;签名 URL 仅在 DEBUG 日志中输出。
要让图片正常显示,二选一:
diff --git a/website-docs/03-features/21-file-access.md b/website-docs/03-features/21-file-access.md
index 1b05446e6..91c63ecc0 100644
--- a/website-docs/03-features/21-file-access.md
+++ b/website-docs/03-features/21-file-access.md
@@ -48,6 +48,10 @@ Web 前端将 `resource://` 和 `provider://` 引用转换为鉴权代理地址
IM 平台无法携带 WeKnora 凭证,需要可公开访问的 HTTP(S) URL。发送消息前,系统根据存储与部署配置生成外链:
+`resource://` 使用资源实际绑定的存储实例,共享资源使用其所属空间的实例。知识库已绑定 OSS 等对象存储时,无需同步修改全局 `STORAGE_TYPE`。绑定实例不可用时保留原引用并记录告警,不使用其他实例或全局存储代替。
+
+跨空间图片生成外链前会检查资源的知识库绑定、当前共享权限和智能体知识库范围。聊天附件、生成文件在写入时记录所用的全局存储实例;历史未绑定资源只在存储位置能唯一确定时补齐绑定,无法确定时保留原引用。
+
1. **存储后端本身公网可达**——对象存储用公网 endpoint,或把 `MINIO_ENDPOINT` 设成公网 host。此时回退到存储预签名 URL,不需要额外配置;
2. **配置 `APP_EXTERNAL_URL`**——引用被改写成 `<APP_EXTERNAL_URL>/r/<token>`,请求经 nginx 的 `location ^~ /r/` 反代回 app。官方前端镜像已内置该 location,自建反代必须补上,否则请求落进 SPA fallback 返回空白页。