droboticflow/internal/api/worker_proxy.go
eust-w f560f9b638 🔒 Fix tenant-isolation holes and stale-response races
Backend:
- Reject target=platform in the database browser; it let any org admin
  read every tenant's records (including password hashes) from the
  shared platform database. The UI never uses this target.
- Check run ownership before proxying /worker-api/runs/{id}/retry so an
  org cannot re-run another org's workflow.
- Resolve symlinks when reading lightweight operator files; a symlinked
  parent directory could expose files outside the code root.
- Remove uploaded image archives after import instead of leaving
  multi-GB tarballs on the shared workspace PVC.

Frontend:
- Ignore stale responses in the lightweight code editors (component and
  Operators page) so a slow load cannot put file A's content under file
  B, where Save would overwrite B. Stop re-listing on every file click.
- Ignore stale collection queries in the database browser so edits
  cannot be saved against the wrong collection.
- Ignore stale run-detail responses in the Monitoring modal.
- Join an in-flight workflow save instead of starting a second one that
  reports a false "server version changed" conflict.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 11:35:06 +08:00

120 lines
3.7 KiB
Go

package api
import (
"context"
"io"
"net/http"
"net/url"
"strings"
"time"
"github.com/go-chi/chi/v5"
)
var (
workerAPIShortProxyTimeout = 15 * time.Second
workerAPILongProxyTimeout = 4 * time.Hour
workerAPIDashboardTimeout = 3 * time.Second
)
var workerAPIProxyClient = &http.Client{}
func (server *server) resolvedWorkerAPIBaseURL() string {
return strings.TrimRight(strings.TrimSpace(server.workerAPIBaseURL), "/")
}
func (server *server) proxyWorkerAPI(writer http.ResponseWriter, request *http.Request, path string, timeout time.Duration) {
baseURL := server.resolvedWorkerAPIBaseURL()
if baseURL == "" {
renderJSON(writer, http.StatusServiceUnavailable, map[string]string{"error": "worker API is not configured"})
return
}
requestCtx := request.Context()
cancel := func() {}
if timeout > 0 {
requestCtx, cancel = context.WithTimeout(requestCtx, timeout)
}
defer cancel()
upstreamURL := baseURL + path
upstreamRequest, err := http.NewRequestWithContext(requestCtx, request.Method, upstreamURL, request.Body)
if err != nil {
renderError(writer, http.StatusBadGateway, err)
return
}
upstreamRequest.Header = request.Header.Clone()
response, err := workerAPIProxyClient.Do(upstreamRequest)
if err != nil {
renderJSON(writer, http.StatusBadGateway, map[string]string{
"error": "worker API request failed",
"details": err.Error(),
})
return
}
defer response.Body.Close()
for key, values := range response.Header {
for _, value := range values {
writer.Header().Add(key, value)
}
}
writer.WriteHeader(response.StatusCode)
_, _ = io.Copy(writer, response.Body)
}
func (server *server) handleWorkerAPIHealth(writer http.ResponseWriter, request *http.Request) {
server.proxyWorkerAPI(writer, request, "/worker-api/health", workerAPIShortProxyTimeout)
}
func (server *server) handleWorkerAPIReady(writer http.ResponseWriter, request *http.Request) {
server.proxyWorkerAPI(writer, request, "/worker-api/ready", workerAPIShortProxyTimeout)
}
func (server *server) handleWorkerAPIStats(writer http.ResponseWriter, request *http.Request) {
query := url.Values{}
if raw := strings.TrimSpace(request.URL.RawQuery); raw != "" {
parsed, err := url.ParseQuery(raw)
if err == nil {
query = parsed
}
}
if organizationID := strings.TrimSpace(server.requestOrganizationID(request)); organizationID != "" {
query.Set("organizationId", organizationID)
}
path := "/worker-api/stats"
if encoded := query.Encode(); encoded != "" {
path += "?" + encoded
}
server.proxyWorkerAPI(writer, request, path, workerAPIShortProxyTimeout)
}
func (server *server) handleWorkerAPIMetrics(writer http.ResponseWriter, request *http.Request) {
server.proxyWorkerAPI(writer, request, "/worker-api/metrics", workerAPIShortProxyTimeout)
}
func (server *server) handleWorkerAPICapacity(writer http.ResponseWriter, request *http.Request) {
server.proxyWorkerAPI(writer, request, "/worker-api/capacity", workerAPIShortProxyTimeout)
}
func (server *server) handleWorkerAPIProcessOnce(writer http.ResponseWriter, request *http.Request) {
server.proxyWorkerAPI(writer, request, "/worker-api/process-once", workerAPILongProxyTimeout)
}
func (server *server) handleWorkerAPIRetry(writer http.ResponseWriter, request *http.Request) {
run, err := server.loadRun(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if run == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Run not found"})
return
}
if !server.ensureTenantAccess(writer, request, run.OrganizationID, "Run") {
return
}
server.proxyWorkerAPI(writer, request, "/worker-api/runs/"+url.PathEscape(run.ID)+"/retry", workerAPIShortProxyTimeout)
}