refactor: simplify image handling in _resolve_images function

- Removed the image storage handling from the `_resolve_images` function, which now only decodes images and returns them as inline bytes.
- Updated the function's docstring to clarify that image persistence is managed by the Go App, and the return value for `image_dir_path` is always empty.
- Adjusted related gRPC and protobuf files to remove the `ConvertToPDF` method and its associated types, streamlining the API.
- Enhanced security measures in the frontend by implementing a placeholder for provider images and ensuring proper hydration of protected file images.

These changes improve the clarity and efficiency of image processing and API interactions within the application.
This commit is contained in:
wizardchen
2026-03-03 21:30:27 +08:00
committed by lyingbug
parent 894d2c060a
commit 4192cfd072
26 changed files with 835 additions and 897 deletions
+6 -285
View File
@@ -13,7 +13,6 @@ import (
"net/url"
"os"
"path"
"path/filepath"
"regexp"
"runtime"
"slices"
@@ -6845,79 +6844,13 @@ func (s *knowledgeService) resolveFileService(ctx context.Context, kb *types.Kno
}
sec := tenant.StorageEngineConfig
var svc interfaces.FileService
var err error
switch provider {
case "local":
baseDir := strings.TrimSpace(os.Getenv("LOCAL_STORAGE_BASE_DIR"))
if baseDir == "" {
baseDir = "/data/files"
}
if sec.Local != nil && sec.Local.PathPrefix != "" {
// path_prefix is a subdirectory under local storage base dir, not a replacement.
// Validate it cannot escape baseDir (e.g. path traversal via "..").
rawPrefix := strings.TrimSpace(sec.Local.PathPrefix)
prefix := strings.Trim(rawPrefix, "/\\")
if prefix != "" {
candidate := filepath.Join(baseDir, prefix)
safeBaseDir, pathErr := secutils.SafePathUnderBase(baseDir, candidate)
if pathErr != nil {
logger.Warnf(ctx,
"[storage] invalid local path_prefix ignored: kb=%s raw_prefix=%q err=%v",
kb.ID, rawPrefix, pathErr)
} else {
baseDir = safeBaseDir
}
}
}
logger.Infof(ctx, "[storage] resolveFileService local: kb=%s base_dir=%s", kb.ID, baseDir)
return filesvc.NewLocalFileService(baseDir)
case "minio":
if sec.MinIO == nil {
return s.fileSvc
}
var endpoint, accessKeyID, secretAccessKey string
if sec.MinIO.Mode == "remote" {
endpoint = sec.MinIO.Endpoint
accessKeyID = sec.MinIO.AccessKeyID
secretAccessKey = sec.MinIO.SecretAccessKey
} else {
endpoint = os.Getenv("MINIO_ENDPOINT")
accessKeyID = os.Getenv("MINIO_ACCESS_KEY_ID")
secretAccessKey = os.Getenv("MINIO_SECRET_ACCESS_KEY")
}
bucketName := sec.MinIO.BucketName
if bucketName == "" {
bucketName = os.Getenv("MINIO_BUCKET_NAME")
}
if endpoint == "" || accessKeyID == "" || secretAccessKey == "" || bucketName == "" {
logger.Warnf(ctx, "Incomplete MinIO config for KB storage, falling back to default")
return s.fileSvc
}
svc, err = filesvc.NewMinioFileService(endpoint, accessKeyID, secretAccessKey, bucketName, sec.MinIO.UseSSL)
case "cos":
if sec.COS == nil || sec.COS.SecretID == "" || sec.COS.BucketName == "" || sec.COS.Region == "" {
logger.Warnf(ctx, "Incomplete COS config for KB storage, falling back to default")
return s.fileSvc
}
pathPrefix := sec.COS.PathPrefix
if pathPrefix == "" {
pathPrefix = "weknora"
}
svc, err = filesvc.NewCosFileService(sec.COS.BucketName, sec.COS.Region, sec.COS.SecretID, sec.COS.SecretKey, pathPrefix)
default:
return s.fileSvc
}
baseDir := strings.TrimSpace(os.Getenv("LOCAL_STORAGE_BASE_DIR"))
svc, resolvedProvider, err := filesvc.NewFileServiceFromStorageConfig(provider, sec, baseDir)
if err != nil {
logger.Errorf(ctx, "Failed to create %s file service from tenant config: %v, falling back to default", provider, err)
return s.fileSvc
}
logger.Infof(ctx, "[storage] resolveFileService selected: kb=%s provider=%s", kb.ID, provider)
logger.Infof(ctx, "[storage] resolveFileService selected: kb=%s provider=%s", kb.ID, resolvedProvider)
return svc
}
@@ -7236,7 +7169,9 @@ func (s *knowledgeService) ProcessDocument(ctx context.Context, t *asynq.Task) e
// Step 2: Store images and update markdown references
var storedImages []docparser.StoredImage
if s.imageResolver != nil && convertResult != nil {
updatedMarkdown, images, resolveErr := s.imageResolver.ResolveAndStore(convertResult)
fileSvc := s.resolveFileService(ctx, kb)
tenantID, _ := ctx.Value(types.TenantIDContextKey).(uint64)
updatedMarkdown, images, resolveErr := s.imageResolver.ResolveAndStore(ctx, convertResult, fileSvc, tenantID)
if resolveErr != nil {
logger.Warnf(ctx, "Image resolution partially failed: %v", resolveErr)
}
@@ -7245,14 +7180,6 @@ func (s *knowledgeService) ProcessDocument(ctx context.Context, t *asynq.Task) e
}
storedImages = images
logger.Infof(ctx, "Resolved %d images for knowledge %s", len(storedImages), knowledge.ID)
// If KB uses object storage (COS/MinIO), re-upload images from local to object storage
if len(storedImages) > 0 {
fileSvc := s.resolveFileService(ctx, kb)
reuploadedMd, reuploadedImages := s.reuploadImagesToStorage(ctx, kb, fileSvc, storedImages, convertResult.MarkdownContent)
convertResult.MarkdownContent = reuploadedMd
storedImages = reuploadedImages
}
}
// Step 3: Split into chunks using Go chunker
@@ -7291,13 +7218,6 @@ func (s *knowledgeService) ProcessDocument(ctx context.Context, t *asynq.Task) e
StoredImages: storedImages,
})
// Step 5: Clean up temp dir
if convertResult.ImageDirPath != "" {
if removeErr := os.RemoveAll(convertResult.ImageDirPath); removeErr != nil {
logger.Warnf(ctx, "Failed to clean up temp image dir %s: %v", convertResult.ImageDirPath, removeErr)
}
}
return nil
}
@@ -7341,27 +7261,12 @@ func (s *knowledgeService) convert(
return nil, nil
}
imageStorage := s.buildImageStorageConfig(ctx, kb)
if imageStorage == nil {
logger.Infof(ctx, "[storage] chunk image storage: kb=%s provider=%s image_storage=nil(use local temp/files)",
kb.ID, kb.GetStorageProvider())
} else {
logger.Infof(ctx, "[storage] chunk image storage: kb=%s provider=%s bucket=%s endpoint=%s path_prefix=%s",
kb.ID,
imageStorage["provider"],
imageStorage["bucket_name"],
imageStorage["endpoint"],
imageStorage["path_prefix"],
)
}
req := &types.ReadRequest{
URL: payload.URL,
Title: knowledge.Title,
ParserEngine: parserEngine,
RequestID: payload.RequestId,
ParserEngineOverrides: overrides,
ImageStorage: imageStorage,
}
if !isURL {
@@ -7429,189 +7334,6 @@ func (s *knowledgeService) failKnowledge(
return nil, fmt.Errorf(format, args...)
}
// reuploadImagesToStorage re-uploads locally stored images to the KB's object storage
// (COS/MinIO) when the KB is not using local storage. It updates the serving URLs in
// both the markdown content and the StoredImage list.
// Local copies are intentionally kept because async tasks (e.g. image:multimodal)
// may still need to read them; they are cleaned up after those tasks complete.
// Returns the original inputs unchanged when the storage provider is "local" or empty.
func (s *knowledgeService) reuploadImagesToStorage(
ctx context.Context,
kb *types.KnowledgeBase,
fileSvc interfaces.FileService,
images []docparser.StoredImage,
markdown string,
) (string, []docparser.StoredImage) {
provider := kb.GetStorageProvider()
tenant, _ := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)
if provider == "" && tenant != nil && tenant.StorageEngineConfig != nil {
provider = strings.ToLower(strings.TrimSpace(tenant.StorageEngineConfig.DefaultProvider))
}
if provider == "" || provider == "local" {
return markdown, images
}
tenantID, _ := ctx.Value(types.TenantIDContextKey).(uint64)
updated := make([]docparser.StoredImage, len(images))
copy(updated, images)
for i, img := range updated {
data, err := os.ReadFile(img.LocalPath)
if err != nil {
logger.Warnf(ctx, "reuploadImagesToStorage: cannot read local image %s: %v", img.LocalPath, err)
continue
}
storagePath, err := fileSvc.SaveBytes(ctx, data, tenantID, filepath.Base(img.LocalPath), false)
if err != nil {
logger.Warnf(ctx, "reuploadImagesToStorage: failed to upload image to %s: %v", provider, err)
continue
}
// For COS, SaveBytes returns a direct public URL (https://bucket.cos...).
// Use it directly instead of GetFileURL which returns a presigned URL that
// expires after 24h — unsuitable for permanent markdown image references.
// For MinIO, SaveBytes returns minio://... which is not a usable URL, so
// keep the local /files/images/... serving URL (the app proxies MinIO files).
storageURL := storagePath
if provider == "minio" {
storageURL = img.ServingURL
}
if storageURL != img.ServingURL {
logger.Infof(ctx, "reuploadImagesToStorage: uploaded %s -> %s", img.ServingURL, storageURL)
markdown = strings.ReplaceAll(markdown, img.ServingURL, storageURL)
updated[i].ServingURL = storageURL
} else {
logger.Infof(ctx, "reuploadImagesToStorage: uploaded %s to %s storage (serving via local URL)", img.ServingURL, provider)
}
}
return markdown, updated
}
// buildImageStorageConfig returns storage config map to pass to DocReader so it can
// upload images to shared storage. Returns nil for local storage (use temp dir / inline bytes).
// Prioritises KB/tenant-level StorageEngineConfig; falls back to environment variables.
func (s *knowledgeService) buildImageStorageConfig(ctx context.Context, kb *types.KnowledgeBase) map[string]string {
provider := ""
if kb != nil {
provider = kb.GetStorageProvider()
}
tenant, _ := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)
if provider == "" && tenant != nil && tenant.StorageEngineConfig != nil {
provider = strings.ToLower(strings.TrimSpace(tenant.StorageEngineConfig.DefaultProvider))
}
// Try tenant-level StorageEngineConfig first
if tenant != nil && tenant.StorageEngineConfig != nil {
sec := tenant.StorageEngineConfig
switch provider {
case "cos":
if sec.COS != nil && sec.COS.SecretID != "" && sec.COS.BucketName != "" && sec.COS.Region != "" {
m := map[string]string{
"provider": "cos",
"bucket_name": sec.COS.BucketName,
"access_key_id": sec.COS.SecretID,
"secret_access_key": sec.COS.SecretKey,
"region": sec.COS.Region,
}
if sec.COS.AppID != "" {
m["app_id"] = sec.COS.AppID
}
if sec.COS.PathPrefix != "" {
m["path_prefix"] = sec.COS.PathPrefix
}
return m
}
case "minio":
if sec.MinIO != nil {
var endpoint, accessKey, secretKey, bucket string
if sec.MinIO.Mode == "remote" {
endpoint = sec.MinIO.Endpoint
accessKey = sec.MinIO.AccessKeyID
secretKey = sec.MinIO.SecretAccessKey
} else {
endpoint = os.Getenv("MINIO_ENDPOINT")
accessKey = os.Getenv("MINIO_ACCESS_KEY_ID")
secretKey = os.Getenv("MINIO_SECRET_ACCESS_KEY")
}
bucket = sec.MinIO.BucketName
if bucket == "" {
bucket = os.Getenv("MINIO_BUCKET_NAME")
}
if endpoint != "" && accessKey != "" && secretKey != "" && bucket != "" {
m := map[string]string{
"provider": "minio",
"endpoint": endpoint,
"bucket_name": bucket,
"access_key_id": accessKey,
"secret_access_key": secretKey,
}
if sec.MinIO.UseSSL {
m["use_ssl"] = "true"
}
if sec.MinIO.PathPrefix != "" {
m["path_prefix"] = sec.MinIO.PathPrefix
}
return m
}
}
}
}
// Fallback: read from environment variables
storageType := strings.TrimSpace(os.Getenv("STORAGE_TYPE"))
switch storageType {
case "minio":
endpoint := os.Getenv("MINIO_ENDPOINT")
accessKey := os.Getenv("MINIO_ACCESS_KEY_ID")
secretKey := os.Getenv("MINIO_SECRET_ACCESS_KEY")
bucket := os.Getenv("MINIO_BUCKET_NAME")
if endpoint == "" || accessKey == "" || secretKey == "" || bucket == "" {
return nil
}
m := map[string]string{
"provider": "minio",
"endpoint": endpoint,
"bucket_name": bucket,
"access_key_id": accessKey,
"secret_access_key": secretKey,
}
if v := os.Getenv("MINIO_USE_SSL"); v != "" {
m["use_ssl"] = v
}
if v := os.Getenv("MINIO_PATH_PREFIX"); v != "" {
m["path_prefix"] = v
}
return m
case "cos":
secretID := os.Getenv("COS_SECRET_ID")
secretKey := os.Getenv("COS_SECRET_KEY")
region := os.Getenv("COS_REGION")
bucket := os.Getenv("COS_BUCKET_NAME")
if secretID == "" || secretKey == "" || region == "" || bucket == "" {
return nil
}
m := map[string]string{
"provider": "cos",
"bucket_name": bucket,
"access_key_id": secretID,
"secret_access_key": secretKey,
"region": region,
}
if v := os.Getenv("COS_APP_ID"); v != "" {
m["app_id"] = v
}
if v := os.Getenv("COS_PATH_PREFIX"); v != "" {
m["path_prefix"] = v
}
return m
default:
return nil
}
}
// enqueueImageMultimodalTasks enqueues asynq tasks for multimodal image processing.
func (s *knowledgeService) enqueueImageMultimodalTasks(
ctx context.Context,
@@ -7644,7 +7366,6 @@ func (s *knowledgeService) enqueueImageMultimodalTasks(
KnowledgeBaseID: kb.ID,
ChunkID: chunkID,
ImageURL: img.ServingURL,
ImageLocalPath: img.LocalPath,
EnableOCR: true,
EnableCaption: true,
}