flvx/go-backend/internal/http/handler/tunnel_redeploy_stream.go

package handler

import (
	"encoding/json"
	"errors"
	"net/http"
	"time"

	"go-backend/internal/http/response"
)

type redeployProgress struct {
	Total     int `json:"total"`
	Completed int `json:"completed"`
	Success   int `json:"success"`
	Failed    int `json:"failed"`
}

type redeployItemResult struct {
	ID      int64  `json:"id"`
	Name    string `json:"name"`
	Success bool   `json:"success"`
	Reason  string `json:"reason,omitempty"`
}

// tunnelBatchRedeployStream reports completed tunnels, not estimated runtime.
// A disconnected caller may have an in-flight mutation whose result it did not
// receive. Finish that mutation, but never start another or automatically retry.
func (h *Handler) tunnelBatchRedeployStream(w http.ResponseWriter, r *http.Request) {
	ids := idsFromBody(r, w)
	if ids == nil {
		return
	}
	// idsFromBody sorts IDs; ignore duplicate selections so each tunnel runs once.
	unique := ids[:0]
	for _, id := range ids {
		if len(unique) == 0 || unique[len(unique)-1] != id {
			unique = append(unique, id)
		}
	}
	ids = unique
	if len(ids) == 0 {
		response.WriteJSON(w, response.ErrDefault("ids不能为空"))
		return
	}
	_, err := prepareDiagnosisStreamResponse(w)
	if err != nil {
		response.WriteJSON(w, response.ErrDefault(err.Error()))
		return
	}
	encoder := json.NewEncoder(w)
	controller := http.NewResponseController(w)
	emit := func(kind string, data interface{}) bool {
		if r.Context().Err() != nil {
			return false
		}
		// The server's WriteTimeout is an absolute request deadline. Renew only
		// this stream's bounded write window as progress is emitted, so a long
		// batch is not cut off despite making steady progress. Recorders and
		// other non-network writers may not support deadlines.
		if err := controller.SetWriteDeadline(time.Now().Add(2 * time.Minute)); err != nil && !errors.Is(err, http.ErrNotSupported) {
			return false
		}
		event := diagnosisStreamEvent{Type: kind, Data: data, TS: time.Now().UnixMilli()}
		if err := encoder.Encode(event); err != nil {
			return false
		}
		// Buffered writes can succeed while the actual socket flush fails.
		// Do not start a mutation after its processing event failed to flush.
		return controller.Flush() == nil
	}
	progress := redeployProgress{Total: len(ids)}
	result := batchOperationResult{}
	if !emit("start", progress) {
		return
	}
	for _, id := range ids {
		if r.Context().Err() != nil {
			return
		}
		name, _ := h.repo.GetTunnelName(id)
		if !emit("processing", map[string]interface{}{"id": id, "name": name, "progress": progress}) {
			return
		}
		if r.Context().Err() != nil {
			return
		}
		item := redeployItemResult{ID: id, Name: name}
		if err := h.redeployTunnelConfiguration(id); err != nil {
			result.FailCount++
			result.Failures = appendBatchFailure(result.Failures, id, name, err)
			item.Reason = result.Failures[len(result.Failures)-1].Reason
			progress.Failed++
		} else {
			result.SuccessCount++
			item.Success = true
			progress.Success++
		}
		progress.Completed++
		if !emit("item", map[string]interface{}{"result": item, "progress": progress}) {
			return
		}
	}
	emit("done", map[string]interface{}{"progress": progress, "result": result})
}