Merge branch 'main' into feat_oss
This commit is contained in:
@@ -59,6 +59,15 @@ func (r *vectorStoreRepository) Update(ctx context.Context, store *types.VectorS
|
||||
).Select("name").Updates(store).Error
|
||||
}
|
||||
|
||||
// UpdateConnectionConfig updates only the connection_config JSONB column.
|
||||
// Used for saving auto-detected metadata (e.g., server version) without
|
||||
// touching user-immutable fields like engine_type or index_config.
|
||||
func (r *vectorStoreRepository) UpdateConnectionConfig(ctx context.Context, store *types.VectorStore) error {
|
||||
return r.db.WithContext(ctx).Model(&types.VectorStore{}).Where(
|
||||
"id = ? AND tenant_id = ?", store.ID, store.TenantID,
|
||||
).Select("connection_config").Updates(store).Error
|
||||
}
|
||||
|
||||
// Delete soft-deletes a vector store
|
||||
func (r *vectorStoreRepository) Delete(ctx context.Context, tenantID uint64, id string) error {
|
||||
return r.db.WithContext(ctx).Where(
|
||||
|
||||
@@ -65,6 +65,7 @@ type knowledgeService struct {
|
||||
repo interfaces.KnowledgeRepository
|
||||
kbService interfaces.KnowledgeBaseService
|
||||
tenantRepo interfaces.TenantRepository
|
||||
tenantService interfaces.TenantService
|
||||
documentReader interfaces.DocumentReader
|
||||
chunkService interfaces.ChunkService
|
||||
chunkRepo interfaces.ChunkRepository
|
||||
@@ -92,6 +93,7 @@ func NewKnowledgeService(
|
||||
documentReader interfaces.DocumentReader,
|
||||
kbService interfaces.KnowledgeBaseService,
|
||||
tenantRepo interfaces.TenantRepository,
|
||||
tenantService interfaces.TenantService,
|
||||
chunkService interfaces.ChunkService,
|
||||
chunkRepo interfaces.ChunkRepository,
|
||||
tagRepo interfaces.KnowledgeTagRepository,
|
||||
@@ -110,6 +112,7 @@ func NewKnowledgeService(
|
||||
repo: repo,
|
||||
kbService: kbService,
|
||||
tenantRepo: tenantRepo,
|
||||
tenantService: tenantService,
|
||||
documentReader: documentReader,
|
||||
chunkService: chunkService,
|
||||
chunkRepo: chunkRepo,
|
||||
@@ -7994,7 +7997,7 @@ func (s *knowledgeService) convert(
|
||||
logger.Infof(ctx, "[convert] kb=%s fileType=%s isURL=%v engine=%q rules=%+v",
|
||||
kb.ID, fileType, isURL, parserEngine, kb.ChunkingConfig.ParserEngineRules)
|
||||
|
||||
var reader interfaces.DocReader = s.resolveDocReader(parserEngine, fileType, isURL, overrides)
|
||||
var reader interfaces.DocReader = s.resolveDocReader(ctx, parserEngine, fileType, isURL, overrides)
|
||||
if reader == nil {
|
||||
knowledge.ParseStatus = "failed"
|
||||
knowledge.ErrorMessage = "Document parsing service is not configured. Please use text/paragraph import or set DOCREADER_ADDR."
|
||||
@@ -8042,10 +8045,24 @@ func (s *knowledgeService) convert(
|
||||
|
||||
// resolveDocReader returns the appropriate DocReader for the given engine.
|
||||
// Returns nil when the required service is unavailable.
|
||||
func (s *knowledgeService) resolveDocReader(engine, fileType string, isURL bool, overrides map[string]string) interfaces.DocReader {
|
||||
func (s *knowledgeService) resolveDocReader(ctx context.Context, engine, fileType string, isURL bool, overrides map[string]string) interfaces.DocReader {
|
||||
switch engine {
|
||||
case docparser.SimpleEngineName:
|
||||
return &docparser.SimpleFormatReader{}
|
||||
case docparser.WeKnoraCloudEngineName:
|
||||
addr := strings.TrimSpace(overrides["docreader_addr"])
|
||||
if !IsWeKnoraCloudDocReaderAddr(addr) {
|
||||
return nil
|
||||
}
|
||||
creds := s.tenantService.GetDocreaderCredentials(ctx)
|
||||
if creds == nil {
|
||||
return nil
|
||||
}
|
||||
reader, err := docparser.NewWeKnoraCloudSignedDocumentReader(addr, creds.AppID, creds.APIKey)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return reader
|
||||
case "mineru":
|
||||
return docparser.NewMinerUReader(overrides)
|
||||
case "mineru_cloud":
|
||||
|
||||
@@ -5,14 +5,15 @@ import (
|
||||
"errors"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/logger"
|
||||
"github.com/Tencent/WeKnora/internal/models/asr"
|
||||
"github.com/Tencent/WeKnora/internal/models/chat"
|
||||
"github.com/Tencent/WeKnora/internal/models/embedding"
|
||||
"github.com/Tencent/WeKnora/internal/models/rerank"
|
||||
"github.com/Tencent/WeKnora/internal/models/asr"
|
||||
"github.com/Tencent/WeKnora/internal/models/utils/ollama"
|
||||
"github.com/Tencent/WeKnora/internal/models/vlm"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
"github.com/Tencent/WeKnora/internal/utils"
|
||||
)
|
||||
|
||||
// ErrModelNotFound is returned when a model cannot be found in the repository
|
||||
@@ -26,7 +27,10 @@ type modelService struct {
|
||||
}
|
||||
|
||||
// NewModelService creates a new model service instance
|
||||
func NewModelService(repo interfaces.ModelRepository, ollamaService *ollama.OllamaService, pooler embedding.EmbedderPooler) interfaces.ModelService {
|
||||
func NewModelService(repo interfaces.ModelRepository,
|
||||
ollamaService *ollama.OllamaService,
|
||||
pooler embedding.EmbedderPooler,
|
||||
) interfaces.ModelService {
|
||||
return &modelService{
|
||||
repo: repo,
|
||||
ollamaService: ollamaService,
|
||||
@@ -34,6 +38,19 @@ func NewModelService(repo interfaces.ModelRepository, ollamaService *ollama.Olla
|
||||
}
|
||||
}
|
||||
|
||||
// decryptAppSecret 解密 AppSecret(如果为空或 cryptoSvc 为空则原样返回)
|
||||
func (s *modelService) decryptAppSecret(encrypted string) string {
|
||||
if encrypted == "" {
|
||||
return encrypted
|
||||
}
|
||||
if key := utils.GetAESKey(); key != nil {
|
||||
if encrypted, err := utils.DecryptAESGCM(encrypted, key); err == nil {
|
||||
return encrypted
|
||||
}
|
||||
}
|
||||
return encrypted
|
||||
}
|
||||
|
||||
// CreateModel creates a new model in the repository
|
||||
// For local models, it initiates an asynchronous download process
|
||||
// Remote models are immediately set to active status
|
||||
@@ -256,7 +273,9 @@ func (s *modelService) GetEmbeddingModel(ctx context.Context, modelId string) (e
|
||||
Dimensions: model.Parameters.EmbeddingParameters.Dimension,
|
||||
TruncatePromptTokens: model.Parameters.EmbeddingParameters.TruncatePromptTokens,
|
||||
Provider: model.Parameters.Provider,
|
||||
Extra: stringMapToAnyMap(model.Parameters.ExtraConfig),
|
||||
ExtraConfig: model.Parameters.ExtraConfig,
|
||||
AppID: model.Parameters.AppID,
|
||||
AppSecret: s.decryptAppSecret(model.Parameters.AppSecret),
|
||||
}, s.pooler, s.ollamaService)
|
||||
if err != nil {
|
||||
logger.ErrorWithFields(ctx, err, map[string]interface{}{
|
||||
@@ -312,7 +331,9 @@ func (s *modelService) GetEmbeddingModelForTenant(ctx context.Context, modelId s
|
||||
Dimensions: model.Parameters.EmbeddingParameters.Dimension,
|
||||
TruncatePromptTokens: model.Parameters.EmbeddingParameters.TruncatePromptTokens,
|
||||
Provider: model.Parameters.Provider,
|
||||
Extra: stringMapToAnyMap(model.Parameters.ExtraConfig),
|
||||
ExtraConfig: model.Parameters.ExtraConfig,
|
||||
AppID: model.Parameters.AppID,
|
||||
AppSecret: s.decryptAppSecret(model.Parameters.AppSecret),
|
||||
}, s.pooler, s.ollamaService)
|
||||
if err != nil {
|
||||
logger.ErrorWithFields(ctx, err, map[string]interface{}{
|
||||
@@ -343,11 +364,15 @@ func (s *modelService) GetRerankModel(ctx context.Context, modelId string) (rera
|
||||
|
||||
// Initialize the reranker with model configuration
|
||||
reranker, err := rerank.NewReranker(&rerank.RerankerConfig{
|
||||
ModelID: model.ID,
|
||||
APIKey: model.Parameters.APIKey,
|
||||
BaseURL: model.Parameters.BaseURL,
|
||||
ModelName: model.Name,
|
||||
Source: model.Source,
|
||||
ModelID: model.ID,
|
||||
APIKey: model.Parameters.APIKey,
|
||||
BaseURL: model.Parameters.BaseURL,
|
||||
ModelName: model.Name,
|
||||
Source: model.Source,
|
||||
Provider: model.Parameters.Provider,
|
||||
ExtraConfig: model.Parameters.ExtraConfig,
|
||||
AppID: model.Parameters.AppID,
|
||||
AppSecret: s.decryptAppSecret(model.Parameters.AppSecret),
|
||||
})
|
||||
if err != nil {
|
||||
logger.ErrorWithFields(ctx, err, map[string]interface{}{
|
||||
@@ -391,13 +416,15 @@ func (s *modelService) GetChatModel(ctx context.Context, modelId string) (chat.C
|
||||
|
||||
// Initialize the chat model with model configuration
|
||||
chatModel, err := chat.NewChat(&chat.ChatConfig{
|
||||
ModelID: model.ID,
|
||||
APIKey: model.Parameters.APIKey,
|
||||
BaseURL: model.Parameters.BaseURL,
|
||||
ModelName: model.Name,
|
||||
Source: model.Source,
|
||||
Provider: model.Parameters.Provider,
|
||||
Extra: stringMapToAnyMap(model.Parameters.ExtraConfig),
|
||||
ModelID: model.ID,
|
||||
APIKey: model.Parameters.APIKey,
|
||||
BaseURL: model.Parameters.BaseURL,
|
||||
ModelName: model.Name,
|
||||
Source: model.Source,
|
||||
Provider: model.Parameters.Provider,
|
||||
ExtraConfig: model.Parameters.ExtraConfig,
|
||||
AppID: model.Parameters.AppID,
|
||||
AppSecret: s.decryptAppSecret(model.Parameters.AppSecret),
|
||||
}, s.ollamaService)
|
||||
if err != nil {
|
||||
logger.ErrorWithFields(ctx, err, map[string]interface{}{
|
||||
|
||||
@@ -342,3 +342,43 @@ func (s *tenantService) GetTenantByIDForUser(ctx context.Context, tenantID uint6
|
||||
|
||||
return tenant, nil
|
||||
}
|
||||
|
||||
func (s *tenantService) GetDocreaderCredentials(ctx context.Context) *types.DocreaderCredentials {
|
||||
// Try to get tenant info directly first
|
||||
if tenant, ok := types.TenantInfoFromContext(ctx); ok {
|
||||
if tenant.ParserEngineConfig != nil {
|
||||
appID := strings.TrimSpace(tenant.ParserEngineConfig.DocreaderAppID)
|
||||
if appID == "" || tenant.ParserEngineConfig.DocreaderAPIKey == "" {
|
||||
return nil
|
||||
}
|
||||
if key := utils.GetAESKey(); key != nil {
|
||||
if encrypted, err := utils.DecryptAESGCM(tenant.ParserEngineConfig.DocreaderAPIKey, key); err == nil {
|
||||
return &types.DocreaderCredentials{AppID: appID, APIKey: encrypted}
|
||||
}
|
||||
}
|
||||
return &types.DocreaderCredentials{AppID: appID, APIKey: tenant.ParserEngineConfig.DocreaderAPIKey}
|
||||
}
|
||||
}
|
||||
|
||||
// If no tenant info in context, try to get tenant ID and load tenant
|
||||
tenantID, ok := types.TenantIDFromContext(ctx)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Load tenant from repo if we only have tenantID
|
||||
tenant, err := s.repo.GetTenantByID(ctx, tenantID)
|
||||
if err == nil && tenant != nil && tenant.ParserEngineConfig != nil {
|
||||
appID := strings.TrimSpace(tenant.ParserEngineConfig.DocreaderAppID)
|
||||
if appID != "" && tenant.ParserEngineConfig.DocreaderAPIKey != "" {
|
||||
if key := utils.GetAESKey(); key != nil {
|
||||
if encrypted, err := utils.DecryptAESGCM(tenant.ParserEngineConfig.DocreaderAPIKey, key); err == nil {
|
||||
return &types.DocreaderCredentials{AppID: appID, APIKey: encrypted}
|
||||
}
|
||||
}
|
||||
return &types.DocreaderCredentials{AppID: appID, APIKey: tenant.ParserEngineConfig.DocreaderAPIKey}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,121 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/errors"
|
||||
"github.com/Tencent/WeKnora/internal/logger"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
secutils "github.com/Tencent/WeKnora/internal/utils"
|
||||
)
|
||||
|
||||
// vectorStoreService implements interfaces.VectorStoreService
|
||||
type vectorStoreService struct {
|
||||
repo interfaces.VectorStoreRepository
|
||||
}
|
||||
|
||||
// NewVectorStoreService creates a new vector store service
|
||||
func NewVectorStoreService(
|
||||
repo interfaces.VectorStoreRepository,
|
||||
) interfaces.VectorStoreService {
|
||||
return &vectorStoreService{repo: repo}
|
||||
}
|
||||
|
||||
// CreateStore validates and creates a new vector store.
|
||||
func (s *vectorStoreService) CreateStore(ctx context.Context, store *types.VectorStore) error {
|
||||
// 1. Basic validation (name, engine_type, tenant_id)
|
||||
if err := store.Validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// 2. Engine-specific connection config validation
|
||||
if err := validateConnectionConfig(store.EngineType, store.ConnectionConfig); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// 3. Duplicate check — DB stores
|
||||
endpoint := store.ConnectionConfig.GetEndpoint()
|
||||
indexName := store.IndexConfig.GetIndexNameOrDefault(store.EngineType)
|
||||
|
||||
exists, err := s.repo.ExistsByEndpointAndIndex(ctx, store.TenantID, store.EngineType, endpoint, indexName)
|
||||
if err != nil {
|
||||
return errors.NewInternalServerError("failed to check for duplicates")
|
||||
}
|
||||
if exists {
|
||||
return errors.NewConflictError("a vector store with the same endpoint and index already exists")
|
||||
}
|
||||
|
||||
// 4. Duplicate check — env stores (pure function, no os.Getenv in types)
|
||||
for _, envStore := range types.BuildEnvVectorStores(os.Getenv("RETRIEVE_DRIVER"), os.Getenv) {
|
||||
if envStore.EngineType == store.EngineType &&
|
||||
envStore.ConnectionConfig.GetEndpoint() == endpoint &&
|
||||
envStore.IndexConfig.GetIndexNameOrDefault(store.EngineType) == indexName {
|
||||
return errors.NewConflictError(
|
||||
"a vector store with the same endpoint and index is already configured via environment variables")
|
||||
}
|
||||
}
|
||||
|
||||
// 5. Persist
|
||||
logger.Infof(ctx, "Creating vector store: tenant=%d, name=%s, engine=%s",
|
||||
store.TenantID, secutils.SanitizeForLog(store.Name), store.EngineType)
|
||||
return s.repo.Create(ctx, store)
|
||||
}
|
||||
|
||||
// UpdateStore updates an existing vector store (name only).
|
||||
func (s *vectorStoreService) UpdateStore(ctx context.Context, store *types.VectorStore) error {
|
||||
if store.TenantID == 0 {
|
||||
return errors.NewValidationError("tenant_id is required")
|
||||
}
|
||||
if store.Name == "" {
|
||||
return errors.NewValidationError("name is required")
|
||||
}
|
||||
|
||||
logger.Infof(ctx, "Updating vector store: tenant=%d, id=%s", store.TenantID, store.ID)
|
||||
return s.repo.Update(ctx, store)
|
||||
}
|
||||
|
||||
// DeleteStore deletes a vector store by tenant + id.
|
||||
// Phase 2: KB binding check will be added here.
|
||||
func (s *vectorStoreService) DeleteStore(ctx context.Context, tenantID uint64, id string) error {
|
||||
logger.Infof(ctx, "Deleting vector store: tenant=%d, id=%s", tenantID, id)
|
||||
return s.repo.Delete(ctx, tenantID, id)
|
||||
}
|
||||
|
||||
// SaveDetectedVersion updates the connection_config.version for a stored vector store.
|
||||
// Works on a copy to avoid mutating the caller's object.
|
||||
func (s *vectorStoreService) SaveDetectedVersion(ctx context.Context, store *types.VectorStore, version string) error {
|
||||
updated := *store
|
||||
updated.ConnectionConfig.Version = version
|
||||
return s.repo.UpdateConnectionConfig(ctx, &updated)
|
||||
}
|
||||
|
||||
// validateConnectionConfig validates required fields per engine type.
|
||||
func validateConnectionConfig(engineType types.RetrieverEngineType, config types.ConnectionConfig) error {
|
||||
switch engineType {
|
||||
case types.ElasticsearchRetrieverEngineType:
|
||||
if config.Addr == "" {
|
||||
return errors.NewValidationError("addr is required for elasticsearch")
|
||||
}
|
||||
case types.PostgresRetrieverEngineType:
|
||||
if !config.UseDefaultConnection && config.Addr == "" {
|
||||
return errors.NewValidationError("addr or use_default_connection is required for postgres")
|
||||
}
|
||||
case types.QdrantRetrieverEngineType:
|
||||
if config.Host == "" {
|
||||
return errors.NewValidationError("host is required for qdrant")
|
||||
}
|
||||
case types.MilvusRetrieverEngineType:
|
||||
if config.Addr == "" {
|
||||
return errors.NewValidationError("addr is required for milvus")
|
||||
}
|
||||
case types.WeaviateRetrieverEngineType:
|
||||
if config.Host == "" {
|
||||
return errors.NewValidationError("host is required for weaviate")
|
||||
}
|
||||
case types.SQLiteRetrieverEngineType:
|
||||
// No connection config needed for SQLite
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/errors"
|
||||
"github.com/Tencent/WeKnora/internal/logger"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
_ "github.com/jackc/pgx/v5/stdlib" // pgx driver for database/sql
|
||||
"github.com/qdrant/go-client/qdrant"
|
||||
"github.com/weaviate/weaviate-go-client/v5/weaviate"
|
||||
"github.com/weaviate/weaviate-go-client/v5/weaviate/auth"
|
||||
wgrpc "github.com/weaviate/weaviate-go-client/v5/weaviate/grpc"
|
||||
)
|
||||
|
||||
const connectionTestTimeout = 10 * time.Second
|
||||
|
||||
// TestConnection tests connectivity to a vector database.
|
||||
// Returns the detected server version on success (e.g., "7.10.1"), empty string if unknown.
|
||||
func (s *vectorStoreService) TestConnection(
|
||||
ctx context.Context,
|
||||
engineType types.RetrieverEngineType,
|
||||
config types.ConnectionConfig,
|
||||
) (string, error) {
|
||||
switch engineType {
|
||||
case types.ElasticsearchRetrieverEngineType:
|
||||
return testElasticsearchConnection(ctx, config)
|
||||
case types.PostgresRetrieverEngineType:
|
||||
return testPostgresConnection(ctx, config)
|
||||
case types.QdrantRetrieverEngineType:
|
||||
return testQdrantConnection(ctx, config)
|
||||
case types.MilvusRetrieverEngineType:
|
||||
return testMilvusConnection(ctx, config)
|
||||
case types.WeaviateRetrieverEngineType:
|
||||
return testWeaviateConnection(ctx, config)
|
||||
case types.SQLiteRetrieverEngineType:
|
||||
// SQLite is file-based, no remote connection to test
|
||||
return "", nil
|
||||
default:
|
||||
return "", errors.NewBadRequestError(
|
||||
fmt.Sprintf("connection test not supported for engine type: %s", engineType))
|
||||
}
|
||||
}
|
||||
|
||||
func testElasticsearchConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
// Use plain HTTP GET to the root endpoint instead of the go-elasticsearch SDK.
|
||||
// The v8 SDK's TypedClient performs a product check that rejects ES7 servers,
|
||||
// so we use a raw HTTP request to support both v7 and v8.
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, config.Addr, nil)
|
||||
if err != nil {
|
||||
return "", errors.NewBadRequestError("failed to create elasticsearch request: invalid address")
|
||||
}
|
||||
if config.Username != "" {
|
||||
req.SetBasicAuth(config.Username, config.Password)
|
||||
}
|
||||
|
||||
client := &http.Client{Timeout: connectionTestTimeout}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
logger.Warnf(ctx, "Elasticsearch connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to connect to elasticsearch: connection refused or authentication failed")
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
logger.Warnf(ctx, "Elasticsearch connection test returned status %d", resp.StatusCode)
|
||||
return "", errors.NewBadRequestError("failed to connect to elasticsearch: authentication failed or server error")
|
||||
}
|
||||
|
||||
// Parse version from response: {"version": {"number": "7.10.1"}, ...}
|
||||
body, err := io.ReadAll(io.LimitReader(resp.Body, 4096))
|
||||
if err != nil {
|
||||
return "", nil // connected but version unknown
|
||||
}
|
||||
|
||||
var esInfo struct {
|
||||
Version struct {
|
||||
Number string `json:"number"`
|
||||
} `json:"version"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &esInfo); err != nil {
|
||||
return "", nil // connected but version unparseable
|
||||
}
|
||||
|
||||
return esInfo.Version.Number, nil
|
||||
}
|
||||
|
||||
func testPostgresConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
testCtx, cancel := context.WithTimeout(ctx, connectionTestTimeout)
|
||||
defer cancel()
|
||||
|
||||
if config.UseDefaultConnection {
|
||||
// Using the default app DB connection — always reachable if the app is running.
|
||||
// Cannot query version without a DB handle; return empty.
|
||||
return "", nil
|
||||
}
|
||||
|
||||
db, err := sql.Open("pgx", config.Addr)
|
||||
if err != nil {
|
||||
return "", errors.NewBadRequestError("failed to create postgres connection: invalid configuration")
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
if err := db.PingContext(testCtx); err != nil {
|
||||
logger.Warnf(ctx, "Postgres connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to connect to postgres: connection refused or authentication failed")
|
||||
}
|
||||
|
||||
// Detect version
|
||||
var version string
|
||||
if err := db.QueryRowContext(testCtx, "SHOW server_version").Scan(&version); err != nil {
|
||||
logger.Warnf(ctx, "Postgres version detection failed: %v", err)
|
||||
return "", nil // connected but version unknown
|
||||
}
|
||||
|
||||
return version, nil
|
||||
}
|
||||
|
||||
func testQdrantConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
testCtx, cancel := context.WithTimeout(ctx, connectionTestTimeout)
|
||||
defer cancel()
|
||||
|
||||
port := config.Port
|
||||
if port == 0 {
|
||||
port = 6334
|
||||
}
|
||||
|
||||
client, err := qdrant.NewClient(&qdrant.Config{
|
||||
Host: config.Host,
|
||||
Port: port,
|
||||
APIKey: config.APIKey,
|
||||
UseTLS: config.UseTLS,
|
||||
})
|
||||
if err != nil {
|
||||
return "", errors.NewBadRequestError("failed to create qdrant client: invalid configuration")
|
||||
}
|
||||
defer client.Close()
|
||||
|
||||
result, err := client.HealthCheck(testCtx)
|
||||
if err != nil {
|
||||
logger.Warnf(ctx, "Qdrant connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to connect to qdrant: connection refused or authentication failed")
|
||||
}
|
||||
|
||||
return result.GetVersion(), nil
|
||||
}
|
||||
|
||||
func testMilvusConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
// Use TCP dial instead of the Milvus SDK to avoid protobuf namespace conflict
|
||||
// between milvus-proto and qdrant-client (both register "common.proto").
|
||||
// A TCP dial is sufficient for connectivity verification; the Milvus SDK client
|
||||
// creation in container.go (PR 3) will validate full gRPC connectivity.
|
||||
// Version detection is not possible with TCP dial alone.
|
||||
testCtx, cancel := context.WithTimeout(ctx, connectionTestTimeout)
|
||||
defer cancel()
|
||||
|
||||
addr := config.Addr
|
||||
if addr == "" {
|
||||
addr = "localhost:19530"
|
||||
}
|
||||
|
||||
conn, err := (&net.Dialer{}).DialContext(testCtx, "tcp", addr)
|
||||
if err != nil {
|
||||
logger.Warnf(ctx, "Milvus connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to connect to milvus: connection refused or server unreachable")
|
||||
}
|
||||
defer conn.Close()
|
||||
|
||||
return "", nil
|
||||
}
|
||||
|
||||
func testWeaviateConnection(ctx context.Context, config types.ConnectionConfig) (string, error) {
|
||||
testCtx, cancel := context.WithTimeout(ctx, connectionTestTimeout)
|
||||
defer cancel()
|
||||
|
||||
host := config.Host
|
||||
if host == "" {
|
||||
host = "weaviate:8080"
|
||||
}
|
||||
grpcAddress := config.GrpcAddress
|
||||
if grpcAddress == "" {
|
||||
grpcAddress = "weaviate:50051"
|
||||
}
|
||||
scheme := config.Scheme
|
||||
if scheme == "" {
|
||||
scheme = "http"
|
||||
}
|
||||
|
||||
weaviateCfg := weaviate.Config{
|
||||
Host: host,
|
||||
GrpcConfig: &wgrpc.Config{
|
||||
Host: grpcAddress,
|
||||
},
|
||||
Scheme: scheme,
|
||||
}
|
||||
if config.APIKey != "" {
|
||||
weaviateCfg.AuthConfig = auth.ApiKey{Value: config.APIKey}
|
||||
}
|
||||
|
||||
// Weaviate Go client v5 does not expose a Close() method;
|
||||
// it uses HTTP + gRPC transports that are managed internally.
|
||||
client, err := weaviate.NewClient(weaviateCfg)
|
||||
if err != nil {
|
||||
logger.Warnf(ctx, "Weaviate connection test failed: %v", err)
|
||||
return "", errors.NewBadRequestError("failed to create weaviate client: invalid configuration")
|
||||
}
|
||||
|
||||
isReady, err := client.Misc().ReadyChecker().Do(testCtx)
|
||||
if err != nil || !isReady {
|
||||
logger.Warnf(ctx, "Weaviate connection test failed: ready=%v, err=%v", isReady, err)
|
||||
return "", errors.NewBadRequestError("failed to connect to weaviate: server not ready or authentication failed")
|
||||
}
|
||||
|
||||
// Detect version via /v1/meta
|
||||
meta, err := client.Misc().MetaGetter().Do(testCtx)
|
||||
if err != nil || meta == nil {
|
||||
return "", nil // connected but version unknown
|
||||
}
|
||||
|
||||
return meta.Version, nil
|
||||
}
|
||||
@@ -0,0 +1,525 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/errors"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Mock repository
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
type mockVectorStoreRepo struct {
|
||||
stores []*types.VectorStore
|
||||
createErr error
|
||||
updateErr error
|
||||
deleteErr error
|
||||
existsByEndpointErr error
|
||||
existsByEndpoint bool
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) Create(_ context.Context, store *types.VectorStore) error {
|
||||
if m.createErr != nil {
|
||||
return m.createErr
|
||||
}
|
||||
m.stores = append(m.stores, store)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) GetByID(_ context.Context, tenantID uint64, id string) (*types.VectorStore, error) {
|
||||
for _, s := range m.stores {
|
||||
if s.ID == id && s.TenantID == tenantID {
|
||||
return s, nil
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) List(_ context.Context, tenantID uint64) ([]*types.VectorStore, error) {
|
||||
var result []*types.VectorStore
|
||||
for _, s := range m.stores {
|
||||
if s.TenantID == tenantID {
|
||||
result = append(result, s)
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) Update(_ context.Context, store *types.VectorStore) error {
|
||||
return m.updateErr
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) UpdateConnectionConfig(_ context.Context, _ *types.VectorStore) error {
|
||||
return m.updateErr
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) Delete(_ context.Context, _ uint64, _ string) error {
|
||||
return m.deleteErr
|
||||
}
|
||||
|
||||
func (m *mockVectorStoreRepo) ExistsByEndpointAndIndex(
|
||||
_ context.Context, _ uint64, _ types.RetrieverEngineType, _ string, _ string,
|
||||
) (bool, error) {
|
||||
if m.existsByEndpointErr != nil {
|
||||
return false, m.existsByEndpointErr
|
||||
}
|
||||
return m.existsByEndpoint, nil
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// CreateStore tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestCreateStore_Success(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "test-es",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
assert.NoError(t, err)
|
||||
assert.Len(t, repo.stores, 1)
|
||||
}
|
||||
|
||||
func TestCreateStore_ValidationError(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
store *types.VectorStore
|
||||
}{
|
||||
{
|
||||
name: "empty name",
|
||||
store: &types.VectorStore{TenantID: 1, EngineType: types.PostgresRetrieverEngineType},
|
||||
},
|
||||
{
|
||||
name: "invalid engine type",
|
||||
store: &types.VectorStore{TenantID: 1, Name: "test", EngineType: "unknown"},
|
||||
},
|
||||
{
|
||||
name: "zero tenant ID",
|
||||
store: &types.VectorStore{Name: "test", EngineType: types.PostgresRetrieverEngineType},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := svc.CreateStore(context.Background(), tt.store)
|
||||
require.Error(t, err)
|
||||
var appErr *errors.AppError
|
||||
assert.ErrorAs(t, err, &appErr)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateStore_ConnectionConfigValidation(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
store *types.VectorStore
|
||||
wantError bool
|
||||
}{
|
||||
{
|
||||
name: "elasticsearch without addr",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "postgres without addr or default connection",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.PostgresRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "postgres with use_default_connection",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.PostgresRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{UseDefaultConnection: true},
|
||||
},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "qdrant without host",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.QdrantRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "milvus without addr",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.MilvusRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "weaviate without host",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.WeaviateRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "sqlite with no config (ok)",
|
||||
store: &types.VectorStore{
|
||||
TenantID: 1, Name: "test",
|
||||
EngineType: types.SQLiteRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{},
|
||||
},
|
||||
wantError: false,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := svc.CreateStore(context.Background(), tt.store)
|
||||
if tt.wantError {
|
||||
require.Error(t, err)
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateStore_DuplicateCheck_DBStore(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{existsByEndpoint: true}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "dup-store",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
require.Error(t, err)
|
||||
|
||||
var appErr *errors.AppError
|
||||
require.ErrorAs(t, err, &appErr)
|
||||
assert.Equal(t, errors.ErrConflict, appErr.Code)
|
||||
}
|
||||
|
||||
func TestCreateStore_DuplicateCheck_DBError(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{
|
||||
existsByEndpointErr: assert.AnError,
|
||||
}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "test",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
require.Error(t, err)
|
||||
}
|
||||
|
||||
func TestCreateStore_DuplicateCheck_EnvStore(t *testing.T) {
|
||||
// Set up env to simulate an existing elasticsearch env store
|
||||
t.Setenv("RETRIEVE_DRIVER", "elasticsearch_v8")
|
||||
t.Setenv("ELASTICSEARCH_ADDR", "http://es:9200")
|
||||
t.Setenv("ELASTICSEARCH_USERNAME", "elastic")
|
||||
t.Setenv("ELASTICSEARCH_PASSWORD", "secret")
|
||||
t.Setenv("ELASTICSEARCH_INDEX", "xwrag_default")
|
||||
|
||||
repo := &mockVectorStoreRepo{existsByEndpoint: false} // no DB duplicate
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "dup-env-store",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
IndexConfig: types.IndexConfig{
|
||||
IndexName: "xwrag_default",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
require.Error(t, err)
|
||||
|
||||
var appErr *errors.AppError
|
||||
require.ErrorAs(t, err, &appErr)
|
||||
assert.Equal(t, errors.ErrConflict, appErr.Code)
|
||||
assert.Contains(t, appErr.Error(), "environment variables")
|
||||
}
|
||||
|
||||
func TestCreateStore_DuplicateCheck_EnvStore_DifferentIndex_Allowed(t *testing.T) {
|
||||
// Same endpoint as env store but different index — should be allowed
|
||||
t.Setenv("RETRIEVE_DRIVER", "elasticsearch_v8")
|
||||
t.Setenv("ELASTICSEARCH_ADDR", "http://es:9200")
|
||||
t.Setenv("ELASTICSEARCH_INDEX", "xwrag_default")
|
||||
|
||||
repo := &mockVectorStoreRepo{existsByEndpoint: false}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "different-index",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es:9200",
|
||||
},
|
||||
IndexConfig: types.IndexConfig{
|
||||
IndexName: "different_index",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestCreateStore_DifferentEndpointSameIndex_Allowed(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{existsByEndpoint: false}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
TenantID: 1,
|
||||
Name: "new-store",
|
||||
EngineType: types.ElasticsearchRetrieverEngineType,
|
||||
ConnectionConfig: types.ConnectionConfig{
|
||||
Addr: "http://es-new:9200",
|
||||
},
|
||||
IndexConfig: types.IndexConfig{
|
||||
IndexName: "shared_index",
|
||||
},
|
||||
}
|
||||
|
||||
err := svc.CreateStore(context.Background(), store)
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// UpdateStore tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestUpdateStore_Success(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
store := &types.VectorStore{
|
||||
ID: "test-id",
|
||||
TenantID: 1,
|
||||
Name: "updated-name",
|
||||
}
|
||||
|
||||
err := svc.UpdateStore(context.Background(), store)
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestUpdateStore_ValidationError(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
store *types.VectorStore
|
||||
}{
|
||||
{
|
||||
name: "empty name",
|
||||
store: &types.VectorStore{ID: "id", TenantID: 1, Name: ""},
|
||||
},
|
||||
{
|
||||
name: "zero tenant ID",
|
||||
store: &types.VectorStore{ID: "id", TenantID: 0, Name: "test"},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := svc.UpdateStore(context.Background(), tt.store)
|
||||
require.Error(t, err)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// DeleteStore tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestDeleteStore_Success(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
err := svc.DeleteStore(context.Background(), 1, "test-id")
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
func TestDeleteStore_RepoError(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{deleteErr: assert.AnError}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
err := svc.DeleteStore(context.Background(), 1, "test-id")
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// TestConnection tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestTestConnection_UnsupportedEngineType(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
_, err := svc.TestConnection(context.Background(), "unknown_engine", types.ConnectionConfig{})
|
||||
require.Error(t, err)
|
||||
|
||||
var appErr *errors.AppError
|
||||
require.ErrorAs(t, err, &appErr)
|
||||
assert.Equal(t, errors.ErrBadRequest, appErr.Code)
|
||||
}
|
||||
|
||||
func TestTestConnection_SQLiteAlwaysSucceeds(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
version, err := svc.TestConnection(context.Background(), types.SQLiteRetrieverEngineType, types.ConnectionConfig{})
|
||||
assert.NoError(t, err)
|
||||
assert.Empty(t, version)
|
||||
}
|
||||
|
||||
func TestTestConnection_PostgresDefaultConnection(t *testing.T) {
|
||||
repo := &mockVectorStoreRepo{}
|
||||
svc := NewVectorStoreService(repo)
|
||||
|
||||
version, err := svc.TestConnection(context.Background(), types.PostgresRetrieverEngineType,
|
||||
types.ConnectionConfig{UseDefaultConnection: true})
|
||||
assert.NoError(t, err)
|
||||
assert.Empty(t, version) // default connection cannot detect version without DB handle
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// validateConnectionConfig tests
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestValidateConnectionConfig(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
engineType types.RetrieverEngineType
|
||||
config types.ConnectionConfig
|
||||
wantError bool
|
||||
}{
|
||||
{
|
||||
name: "elasticsearch valid",
|
||||
engineType: types.ElasticsearchRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Addr: "http://es:9200"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "elasticsearch missing addr",
|
||||
engineType: types.ElasticsearchRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "postgres with default connection",
|
||||
engineType: types.PostgresRetrieverEngineType,
|
||||
config: types.ConnectionConfig{UseDefaultConnection: true},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "postgres with addr",
|
||||
engineType: types.PostgresRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Addr: "postgres://host:5432/db"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "postgres without addr or default",
|
||||
engineType: types.PostgresRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "qdrant valid",
|
||||
engineType: types.QdrantRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Host: "qdrant-host"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "qdrant missing host",
|
||||
engineType: types.QdrantRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "milvus valid",
|
||||
engineType: types.MilvusRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Addr: "milvus:19530"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "milvus missing addr",
|
||||
engineType: types.MilvusRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "weaviate valid",
|
||||
engineType: types.WeaviateRetrieverEngineType,
|
||||
config: types.ConnectionConfig{Host: "weaviate:8080"},
|
||||
wantError: false,
|
||||
},
|
||||
{
|
||||
name: "weaviate missing host",
|
||||
engineType: types.WeaviateRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: true,
|
||||
},
|
||||
{
|
||||
name: "sqlite always valid",
|
||||
engineType: types.SQLiteRetrieverEngineType,
|
||||
config: types.ConnectionConfig{},
|
||||
wantError: false,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
err := validateConnectionConfig(tt.engineType, tt.config)
|
||||
if tt.wantError {
|
||||
assert.Error(t, err)
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,408 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/Tencent/WeKnora/internal/models/provider"
|
||||
"github.com/Tencent/WeKnora/internal/types"
|
||||
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
||||
"github.com/Tencent/WeKnora/internal/utils"
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const WeKnoraCloudAPI = "https://weknora.woa.com/platform/openapi"
|
||||
|
||||
type weKnoraCloudService struct {
|
||||
repo interfaces.ModelRepository
|
||||
tenantRepo interfaces.TenantRepository
|
||||
}
|
||||
|
||||
// NewWeKnoraCloudService 构造 WeKnoraCloudService
|
||||
func NewWeKnoraCloudService(
|
||||
repo interfaces.ModelRepository,
|
||||
tenantRepo interfaces.TenantRepository,
|
||||
) interfaces.WeKnoraCloudService {
|
||||
return &weKnoraCloudService{
|
||||
repo: repo,
|
||||
tenantRepo: tenantRepo,
|
||||
}
|
||||
}
|
||||
|
||||
func IsWeKnoraCloudDocReaderAddr(addr string) bool {
|
||||
return strings.TrimSuffix(strings.TrimSpace(addr), "/") == strings.TrimRight(provider.WeKnoraCloudBaseURL, "/")+"/api/v1/doc/reader"
|
||||
}
|
||||
|
||||
// weKnoraCloudModelDefs 三个内置模型的静态定义
|
||||
var weKnoraCloudModelDefs = []struct {
|
||||
name string
|
||||
modelType types.ModelType
|
||||
remoteModelName string
|
||||
}{
|
||||
{name: "weknoracloud-chat", modelType: types.ModelTypeKnowledgeQA, remoteModelName: "chat"},
|
||||
{name: "weknoracloud-embedding", modelType: types.ModelTypeEmbedding, remoteModelName: "embedding"},
|
||||
{name: "weknoracloud-rerank", modelType: types.ModelTypeRerank, remoteModelName: "rerank"},
|
||||
}
|
||||
|
||||
func (s *weKnoraCloudService) Initialize(ctx context.Context, appID, appSecret string) (*types.InitializeResult, error) {
|
||||
if err := s.validateInitializeInput(appID, appSecret); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
prepared, err := s.prepareInitialize(ctx, appID, appSecret)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
result := &types.InitializeResult{}
|
||||
|
||||
actions, err := s.installBuiltinModels(ctx, prepared.tenantID, appID, prepared.encryptedSecret)
|
||||
if err != nil {
|
||||
return nil, s.failInitializeAndRollback(ctx, prepared.tenantID, prepared.snapshot, err)
|
||||
}
|
||||
result.Models = actions
|
||||
|
||||
if err := s.updateTenantDocReaderAddr(ctx, prepared.tenantID, appID, prepared.encryptedSecret); err != nil {
|
||||
return nil, s.failInitializeAndRollback(ctx, prepared.tenantID, prepared.snapshot, err)
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// validateInitializeInput validates that appID and appSecret are not empty.
|
||||
func (s *weKnoraCloudService) validateInitializeInput(appID, appSecret string) error {
|
||||
if appID == "" {
|
||||
return fmt.Errorf("app_id is required")
|
||||
}
|
||||
if appSecret == "" {
|
||||
return fmt.Errorf("app_secret is required")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// weKnoraCloudInitPrepared holds the prepared state for initialize operation.
|
||||
type weKnoraCloudInitPrepared struct {
|
||||
tenantID uint64
|
||||
encryptedSecret string
|
||||
snapshot *weKnoraCloudInitSnapshot
|
||||
}
|
||||
|
||||
// prepareInitialize performs pre-initialization checks: ping WeKnoraCloud, encrypt secret, and snapshot current state.
|
||||
func (s *weKnoraCloudService) prepareInitialize(ctx context.Context, appID, appSecret string) (*weKnoraCloudInitPrepared, error) {
|
||||
// Step 1: Check WeKnoraCloud service reachability
|
||||
if err := s.pingWeKnoraCloud(ctx, appID, appSecret); err != nil {
|
||||
return nil, fmt.Errorf("WeKnoraCloud service reachability check failed: %w", err)
|
||||
}
|
||||
|
||||
// Step 2: Encrypt appSecret
|
||||
encryptedSecret := appSecret
|
||||
if key := utils.GetAESKey(); key != nil {
|
||||
if encrypted, err := utils.EncryptAESGCM(appSecret, key); err == nil {
|
||||
encryptedSecret = encrypted
|
||||
}
|
||||
}
|
||||
|
||||
// Step 3: Get tenantID and take snapshot
|
||||
tenantID := types.MustTenantIDFromContext(ctx)
|
||||
snapshot, err := s.snapshotInitializeState(ctx, tenantID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("snapshot initialize state failed: %w", err)
|
||||
}
|
||||
|
||||
return &weKnoraCloudInitPrepared{
|
||||
tenantID: tenantID,
|
||||
encryptedSecret: encryptedSecret,
|
||||
snapshot: snapshot,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// installBuiltinModels installs or updates the three builtin WeKnoraCloud models (chat, embedding, rerank).
|
||||
// Returns a slice of ModelAction describing what was done.
|
||||
func (s *weKnoraCloudService) installBuiltinModels(
|
||||
ctx context.Context,
|
||||
tenantID uint64,
|
||||
appID, encryptedSecret string,
|
||||
) ([]types.ModelAction, error) {
|
||||
result := make([]types.ModelAction, 0, len(weKnoraCloudModelDefs))
|
||||
|
||||
for _, def := range weKnoraCloudModelDefs {
|
||||
action, err := s.upsertModel(ctx, tenantID, def.name, def.modelType, def.remoteModelName, appID, encryptedSecret)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("upsert model %s failed: %w", def.name, err)
|
||||
}
|
||||
result = append(result, types.ModelAction{
|
||||
Name: def.name,
|
||||
Type: string(def.modelType),
|
||||
Action: action,
|
||||
})
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// weKnoraCloudInitSnapshot holds a snapshot of the state before initialization.
|
||||
type weKnoraCloudInitSnapshot struct {
|
||||
modelsByType map[types.ModelType][]*types.Model
|
||||
tenant *types.Tenant
|
||||
}
|
||||
|
||||
func (s *weKnoraCloudService) snapshotInitializeState(ctx context.Context, tenantID uint64) (*weKnoraCloudInitSnapshot, error) {
|
||||
snapshot := &weKnoraCloudInitSnapshot{modelsByType: make(map[types.ModelType][]*types.Model, len(weKnoraCloudModelDefs))}
|
||||
for _, def := range weKnoraCloudModelDefs {
|
||||
models, err := s.repo.List(ctx, tenantID, def.modelType, types.ModelSourceRemote)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
copies := make([]*types.Model, 0, len(models))
|
||||
for _, model := range models {
|
||||
copies = append(copies, cloneWeKnoraCloudModel(model))
|
||||
}
|
||||
snapshot.modelsByType[def.modelType] = copies
|
||||
}
|
||||
if s.tenantRepo != nil {
|
||||
tenant, err := s.tenantRepo.GetTenantByID(ctx, tenantID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
snapshot.tenant = cloneWeKnoraCloudTenant(tenant)
|
||||
}
|
||||
return snapshot, nil
|
||||
}
|
||||
|
||||
func (s *weKnoraCloudService) failInitializeAndRollback(ctx context.Context, tenantID uint64, snapshot *weKnoraCloudInitSnapshot, err error) error {
|
||||
if rollbackErr := s.rollbackInitializeState(ctx, tenantID, snapshot); rollbackErr != nil {
|
||||
return fmt.Errorf("%w;回滚失败:%v", err, rollbackErr)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *weKnoraCloudService) rollbackInitializeState(ctx context.Context, tenantID uint64, snapshot *weKnoraCloudInitSnapshot) error {
|
||||
if snapshot == nil {
|
||||
return nil
|
||||
}
|
||||
var rollbackErrs []string
|
||||
for _, def := range weKnoraCloudModelDefs {
|
||||
currentModels, err := s.repo.List(ctx, tenantID, def.modelType, types.ModelSourceRemote)
|
||||
if err != nil {
|
||||
rollbackErrs = append(rollbackErrs, err.Error())
|
||||
continue
|
||||
}
|
||||
snapshotByID := map[string]*types.Model{}
|
||||
for _, model := range snapshot.modelsByType[def.modelType] {
|
||||
snapshotByID[model.ID] = cloneWeKnoraCloudModel(model)
|
||||
}
|
||||
for _, current := range currentModels {
|
||||
if current == nil {
|
||||
continue
|
||||
}
|
||||
if _, ok := snapshotByID[current.ID]; ok {
|
||||
continue
|
||||
}
|
||||
if current.Parameters.Provider == string(provider.ProviderWeKnoraCloud) && isWeKnoraCloudBuiltinModelName(current.Name) {
|
||||
if err := s.repo.Delete(ctx, tenantID, current.ID); err != nil {
|
||||
rollbackErrs = append(rollbackErrs, err.Error())
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, model := range snapshot.modelsByType[def.modelType] {
|
||||
if err := s.repo.Update(ctx, cloneWeKnoraCloudModel(model)); err != nil {
|
||||
rollbackErrs = append(rollbackErrs, err.Error())
|
||||
}
|
||||
}
|
||||
}
|
||||
if snapshot.tenant != nil && s.tenantRepo != nil {
|
||||
if err := s.tenantRepo.UpdateTenant(ctx, cloneWeKnoraCloudTenant(snapshot.tenant)); err != nil {
|
||||
rollbackErrs = append(rollbackErrs, err.Error())
|
||||
}
|
||||
}
|
||||
if len(rollbackErrs) > 0 {
|
||||
return fmt.Errorf("%s", strings.Join(rollbackErrs, "; "))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func isWeKnoraCloudBuiltinModelName(name string) bool {
|
||||
for _, def := range weKnoraCloudModelDefs {
|
||||
if def.name == name {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func cloneWeKnoraCloudModel(model *types.Model) *types.Model {
|
||||
if model == nil {
|
||||
return nil
|
||||
}
|
||||
clone := *model
|
||||
if model.Parameters.ExtraConfig != nil {
|
||||
clone.Parameters.ExtraConfig = make(map[string]string, len(model.Parameters.ExtraConfig))
|
||||
for k, v := range model.Parameters.ExtraConfig {
|
||||
clone.Parameters.ExtraConfig[k] = v
|
||||
}
|
||||
}
|
||||
return &clone
|
||||
}
|
||||
|
||||
func cloneWeKnoraCloudTenant(tenant *types.Tenant) *types.Tenant {
|
||||
if tenant == nil {
|
||||
return nil
|
||||
}
|
||||
clone := *tenant
|
||||
if tenant.ParserEngineConfig != nil {
|
||||
cfg := *tenant.ParserEngineConfig
|
||||
clone.ParserEngineConfig = &cfg
|
||||
}
|
||||
return &clone
|
||||
}
|
||||
|
||||
// pingWeKnoraCloud 调用 WeKnoraCloud 服务的 GET /health 接口验证可达性。
|
||||
// 注意:这里仅检查服务可达,不校验 APPID / API Key 是否有效。
|
||||
func (s *weKnoraCloudService) pingWeKnoraCloud(ctx context.Context, appID, appSecret string) error {
|
||||
baseURL := strings.TrimRight(provider.WeKnoraCloudBaseURL, "/")
|
||||
healthURL := baseURL + "/api/v1/health"
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, healthURL, nil)
|
||||
if err != nil {
|
||||
return fmt.Errorf("创建健康检查请求失败: %w", err)
|
||||
}
|
||||
|
||||
client := &http.Client{Timeout: 10 * time.Second}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return fmt.Errorf("WeKnoraCloud 服务不可达 (%s): %w", healthURL, err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return fmt.Errorf("WeKnoraCloud 健康检查返回非 200 状态码: %d", resp.StatusCode)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CheckStatus 检查 WeKnoraCloud 凭证是否可正常解密
|
||||
func (s *weKnoraCloudService) CheckStatus(ctx context.Context) (*types.WeKnoraCloudStatusResult, error) {
|
||||
tenantID := types.MustTenantIDFromContext(ctx)
|
||||
|
||||
tenant, err := s.tenantRepo.GetTenantByID(ctx, tenantID)
|
||||
if err != nil || tenant == nil {
|
||||
return &types.WeKnoraCloudStatusResult{HasModels: false, NeedsReinit: false}, nil
|
||||
}
|
||||
|
||||
// Check if tenant has WeKnoraCloud credentials in parser config
|
||||
if tenant.ParserEngineConfig == nil || tenant.ParserEngineConfig.DocreaderAppID == "" || tenant.ParserEngineConfig.DocreaderAPIKey == "" {
|
||||
return &types.WeKnoraCloudStatusResult{
|
||||
HasModels: true,
|
||||
NeedsReinit: true,
|
||||
Reason: fmt.Sprintf("WeKnoraCloud 凭证为空,请重新填写 APPID 和 API Key, 请前往:%s", WeKnoraCloudAPI),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Try to decrypt the API key
|
||||
if key := utils.GetAESKey(); key != nil {
|
||||
if _, err := utils.DecryptAESGCM(tenant.ParserEngineConfig.DocreaderAPIKey, key); err != nil {
|
||||
return &types.WeKnoraCloudStatusResult{
|
||||
HasModels: true,
|
||||
NeedsReinit: true,
|
||||
Reason: "WeKnoraCloud 凭证解密失败(服务重启后加密密钥已变更),请重新填写 APPID 和 API Key",
|
||||
}, nil
|
||||
}
|
||||
}
|
||||
|
||||
return &types.WeKnoraCloudStatusResult{HasModels: true, NeedsReinit: false}, nil
|
||||
}
|
||||
|
||||
// updateTenantDocReaderAddr updates tenant parser config with WeKnoraCloud credentials and DocReaderAddr
|
||||
func (s *weKnoraCloudService) updateTenantDocReaderAddr(ctx context.Context, tenantID uint64, appID, encryptedSecret string) error {
|
||||
if s.tenantRepo == nil {
|
||||
return fmt.Errorf("tenant repository is required")
|
||||
}
|
||||
|
||||
tenant, err := s.tenantRepo.GetTenantByID(ctx, tenantID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if tenant.ParserEngineConfig == nil {
|
||||
tenant.ParserEngineConfig = &types.ParserEngineConfig{}
|
||||
}
|
||||
tenant.ParserEngineConfig.DocReaderAddr = strings.TrimRight(provider.WeKnoraCloudBaseURL, "/") + "/api/v1/doc/reader"
|
||||
tenant.ParserEngineConfig.DocreaderAppID = appID
|
||||
tenant.ParserEngineConfig.DocreaderAPIKey = encryptedSecret
|
||||
return s.tenantRepo.UpdateTenant(ctx, tenant)
|
||||
}
|
||||
|
||||
func (s *weKnoraCloudService) upsertModel(
|
||||
ctx context.Context,
|
||||
tenantID uint64,
|
||||
name string,
|
||||
modelType types.ModelType,
|
||||
remoteModelName string,
|
||||
appID, encryptedSecret string,
|
||||
) (string, error) {
|
||||
// 列出该类型的远程模型,过滤出 weknoracloud provider
|
||||
models, err := s.repo.List(ctx, tenantID, modelType, types.ModelSourceRemote)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
var existing *types.Model
|
||||
for _, m := range models {
|
||||
if m.Name == name && m.Parameters.Provider == string(provider.ProviderWeKnoraCloud) {
|
||||
existing = m
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// 先清除同类型其他模型的默认标记
|
||||
excludeID := ""
|
||||
if existing != nil {
|
||||
excludeID = existing.ID
|
||||
}
|
||||
if err := s.repo.ClearDefaultByType(ctx, uint(tenantID), modelType, excludeID); err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
if existing != nil {
|
||||
// 更新凭证和默认标记
|
||||
existing.Parameters.BaseURL = provider.WeKnoraCloudBaseURL
|
||||
existing.Parameters.AppID = appID
|
||||
existing.Parameters.AppSecret = encryptedSecret
|
||||
if existing.Parameters.ExtraConfig == nil {
|
||||
existing.Parameters.ExtraConfig = map[string]string{}
|
||||
}
|
||||
existing.Parameters.ExtraConfig["remote_model_name"] = remoteModelName
|
||||
existing.IsDefault = true
|
||||
if err := s.repo.Update(ctx, existing); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return "updated", nil
|
||||
}
|
||||
|
||||
// 创建新模型
|
||||
newModel := &types.Model{
|
||||
ID: uuid.New().String(),
|
||||
TenantID: tenantID,
|
||||
Name: name,
|
||||
Type: modelType,
|
||||
Source: types.ModelSourceRemote,
|
||||
IsBuiltin: true,
|
||||
IsDefault: true,
|
||||
Status: types.ModelStatusActive,
|
||||
Parameters: types.ModelParameters{
|
||||
Provider: string(provider.ProviderWeKnoraCloud),
|
||||
BaseURL: provider.WeKnoraCloudBaseURL,
|
||||
AppID: appID,
|
||||
AppSecret: encryptedSecret,
|
||||
ExtraConfig: map[string]string{
|
||||
"remote_model_name": remoteModelName,
|
||||
},
|
||||
},
|
||||
}
|
||||
if err := s.repo.Create(ctx, newModel); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return "created", nil
|
||||
}
|
||||
Reference in New Issue
Block a user