zlei6/ragflow
1
0
Fork 0
mirror of https://github.com/infiniflow/ragflow.git synced 2026-07-11 14:15:40 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactor: drop dead canvas runtime selector and tokenizer embedding wiring (#16809)

Browse Source 
Two refactors on the Go port (agent-go-port):

- Remove the dead per-tenant canvas runtime selector (write-only Redis
scaffolding with no runtime callers) and its dependent metrics/admin
code.
- Move the tokenizer embedding-model id from the shared ingestion
globals into a Tokenizer-scoped setup, and wire the production embedder
resolver in the ingestion task package.

32 files changed, 861 insertions, 1228 deletions.
This commit is contained in:
Zhichang Yu
2026-07-10 15:46:45 +08:00
committed by GitHub
parent d317742975
commit fb42e5531d
32 changed files with 861 additions and 1228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
internal/handler/admin_runtime.go
View File

@@ -1,107 +0,0 @@
//
// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package handler
import (
"errors"
"net/http"
"github.com/gin-gonic/gin"
"ragflow/internal/agent/runtime"
"ragflow/internal/common"
)
// AdminRuntimeHandler exposes the per-tenant canvas-runtime override API
// used by the Phase 6 canary operators. It is intentionally small — the
// selector is the only collaborator it needs.
type AdminRuntimeHandler struct {
selector *runtime.Selector
}
// NewAdminRuntimeHandler constructs an AdminRuntimeHandler backed by the
// supplied Selector. A nil selector is treated as a misconfiguration and
// the handler refuses every request with HTTP 500.
func NewAdminRuntimeHandler(selector *runtime.Selector) *AdminRuntimeHandler {
return &AdminRuntimeHandler{selector: selector}
}
// setRuntimeRequest is the wire shape for POST
// /api/v1/admin/canvas-runtime/:tenant_id. The mode is required; empty or
// unknown values yield 400.
type setRuntimeRequest struct {
Runtime string `json:"runtime"`
}
// setRuntimeResponse is what the operator sees in the 200 body.
type setRuntimeResponse struct {
Code common.ErrorCode `json:"code"`
TenantID string `json:"tenant_id"`
Runtime string `json:"runtime"`
Message string `json:"message"`
}
// ErrSelectorNotConfigured is returned when the handler was constructed
// without a backing Selector. It maps to HTTP 500 in the response path.
var ErrSelectorNotConfigured = errors.New("admin runtime: selector not configured")
// SetTenantRuntime implements POST /api/v1/admin/canvas-runtime/:tenant_id.
//
// Auth gap: this handler accepts any authenticated request. The dedicated
// admin-role middleware is a separate workstream; the Phase 6 PR documents
// the gap here so the staging canary operator flips tenants only via a
// trusted network. Production rollout MUST wire admin auth before opening
// this endpoint publicly.
func (h *AdminRuntimeHandler) SetTenantRuntime(c *gin.Context) {
if h.selector == nil {
common.ResponseWithCodeData(c, common.CodeExceptionError, nil, ErrSelectorNotConfigured.Error())
return
}
tenantID := c.Param("tenant_id")
if tenantID == "" {
common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "tenant_id is required")
return
}
var req setRuntimeRequest
if err := c.ShouldBindJSON(&req); err != nil {
common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "Invalid request body: "+err.Error())
return
}
mode := runtime.RuntimeMode(req.Runtime)
switch mode {
case runtime.RuntimeGo, runtime.RuntimePython, runtime.RuntimeAuto:
// allowed
default:
common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "runtime must be one of: go, python, auto")
return
}
if err := h.selector.Set(c.Request.Context(), tenantID, mode); err != nil {
common.ResponseWithCodeData(c, common.CodeDataError, nil, err.Error())
return
}
c.JSON(http.StatusOK, setRuntimeResponse{
Code: common.CodeSuccess,
TenantID: tenantID,
Runtime: string(mode),
Message: "ok",
})
}

135
internal/handler/admin_runtime_test.go
View File

@@ -1,135 +0,0 @@
//
// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
package handler
import (
"bytes"
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
"github.com/alicebob/miniredis/v2"
"github.com/gin-gonic/gin"
"github.com/redis/go-redis/v9"
"ragflow/internal/agent/runtime"
)
func init() {
gin.SetMode(gin.TestMode)
}
// newAdminRuntimeTestRig wires a Selector backed by miniredis and returns
// a fully-mounted gin engine with the route registered, so tests can issue
// real HTTP requests against it.
func newAdminRuntimeTestRig(t *testing.T) (*gin.Engine, *runtime.Selector, *miniredis.Miniredis) {
t.Helper()
mr := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: mr.Addr()})
t.Cleanup(func() { _ = rdb.Close() })
selector := runtime.NewSelector(rdb, nil)
h := NewAdminRuntimeHandler(selector)
eng := gin.New()
g := eng.Group("/api/v1/admin")
g.POST("/canvas-runtime/:tenant_id", h.SetTenantRuntime)
return eng, selector, mr
}
func TestAdminRuntime_SetGo(t *testing.T) {
eng, selector, _ := newAdminRuntimeTestRig(t)
body, _ := json.Marshal(map[string]string{"runtime": "go"})
req := httptest.NewRequest(http.MethodPost, "/api/v1/admin/canvas-runtime/tenant_123", bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
eng.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200; body=%s", w.Code, w.Body.String())
}
var resp setRuntimeResponse
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
t.Fatalf("decode response: %v", err)
}
if resp.Code != 0 || resp.TenantID != "tenant_123" || resp.Runtime != "go" {
t.Errorf("unexpected response: %+v", resp)
}
// Round-trip: the selector should now report the override.
mode, err := selector.Select(req.Context(), "tenant_123")
if err != nil {
t.Fatalf("Select(): %v", err)
}
if mode != runtime.RuntimeGo {
t.Errorf("Select() after SetGo = %q, want %q", mode, runtime.RuntimeGo)
}
}
func TestAdminRuntime_SetPython(t *testing.T) {
eng, selector, _ := newAdminRuntimeTestRig(t)
body, _ := json.Marshal(map[string]string{"runtime": "python"})
req := httptest.NewRequest(http.MethodPost, "/api/v1/admin/canvas-runtime/tenant_xyz", bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
eng.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200; body=%s", w.Code, w.Body.String())
}
mode, err := selector.Select(req.Context(), "tenant_xyz")
if err != nil {
t.Fatalf("Select(): %v", err)
}
if mode != runtime.RuntimePython {
t.Errorf("Select() after SetPython = %q, want %q", mode, runtime.RuntimePython)
}
}
func TestAdminRuntime_BadRequest(t *testing.T) {
cases := []struct {
name string
body string
}{
{"unknown_mode", `{"runtime":"rust"}`},
{"empty_mode", `{"runtime":""}`},
{"malformed_json", `{"runtime":`},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
eng, _, _ := newAdminRuntimeTestRig(t)
req := httptest.NewRequest(http.MethodPost,
"/api/v1/admin/canvas-runtime/tenant_1",
bytes.NewReader([]byte(tc.body)))
req.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
eng.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 envelope", w.Code)
}
var env map[string]any
if err := json.Unmarshal(w.Body.Bytes(), &env); err != nil {
t.Fatalf("decode: %v", err)
}
// 101 == CodeArgumentError, the only acceptable error for bad input.
if code, _ := env["code"].(float64); code != 101 {
t.Errorf("code = %v, want 101 (CodeArgumentError); body=%s", env["code"], w.Body.String())
}
})
}
}