Files
Enterprise-Knowledge-Base/internal/application/service/weknoracloud.go
T
begoniezhao d4edd374df refactor: replace CryptoService with utils AES helpers and simplify encryption
- Remove infrastructure/crypto package (CryptoService, config, PBKDF2-based encryption)
- Replace with lightweight utils.GetAESKey/EncryptAESGCM/DecryptAESGCM helpers
- Remove cryptoSvc dependency from modelService, tenantService, weKnoraCloudService
- Remove crypto state persistence logic from container initialization
- Add TruncatePromptTokens field to WeKnoraCloud embed request
- Update frontend hint text for WeKnoraCloud credential errors

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-13 20:55:39 +08:00

409 lines
13 KiB
Go

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
}