Rollback Burst

POST /admin/rollback

// Register PR URL for potential burst rollback only while a burst alert is active;
// prune entries older than TTL regardless.
if isGlobalBurstAlertActive() {
	nowPR := time.Now()
	recentBurstPRsMu.Lock()
	cutoffPR := nowPR.Add(-recentBurstPRsTTL)
	newURLs := recentBurstPRs[:0]
	newAts := recentBurstPRsAt[:0]
	for i, at := range recentBurstPRsAt {
		if at.After(cutoffPR) {
			newURLs = append(newURLs, recentBurstPRs[i])
			newAts = append(newAts, at)
		}
	}
	newURLs = append(newURLs, prURL)
	newAts = append(newAts, nowPR)
	recentBurstPRs = newURLs
	recentBurstPRsAt = newAts
	recentBurstPRsMu.Unlock()
}

func RollbackBurstHandler(c *gin.Context) {
	var req struct {
		Password string `json:"password"`
		Token    string `json:"token"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
		return
	}

	// Accept either the static password or a valid single-use action token
	authorized := (panicPassword != "" && req.Password == panicPassword) ||
		(req.Token != "" && consumeActionToken(req.Token))
	if !authorized {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid credentials"})
		return
	}

	// Rate limit: max rollbackLimitMax calls per rollbackLimitWin
	now := time.Now()
	rollbackLimitMu.Lock()
	valid := rollbackLimitTimes[:0]
	for _, t := range rollbackLimitTimes {
		if now.Sub(t) < rollbackLimitWin {
			valid = append(valid, t)
		}
	}
	valid = append(valid, now)
	rollbackLimitTimes = valid
	exceeded := len(valid) > rollbackLimitMax
	rollbackLimitMu.Unlock()
	if exceeded {
		c.JSON(http.StatusTooManyRequests, gin.H{"error": "rollback rate limit exceeded"})
		return
	}

	recentBurstPRsMu.Lock()
	toClose := make([]string, len(recentBurstPRs))
	copy(toClose, recentBurstPRs)
	recentBurstPRs = recentBurstPRs[:0]
	recentBurstPRsAt = recentBurstPRsAt[:0]
	recentBurstPRsMu.Unlock()

	if len(toClose) == 0 {
		c.JSON(http.StatusOK, gin.H{"closed": 0, "message": "no burst PRs to close"})
		return
	}

	const maxCloseWorkers = 5
	closeConcurrency := make(chan struct{}, maxCloseWorkers)
	var (
		wg     sync.WaitGroup
		mu     sync.Mutex
		closed []string
		failed []string
	)
	for _, prURL := range toClose {
		wg.Add(1)
		go func(u string) {
			defer wg.Done()
			closeConcurrency <- struct{}{}
			defer func() { <-closeConcurrency }()
			if err := github.ClosePRByURL(u); err != nil {
				utils.Log("rollback: failed to close %s: %v", u, err)
				mu.Lock()
				failed = append(failed, u)
				mu.Unlock()
			} else {
				mu.Lock()
				closed = append(closed, u)
				mu.Unlock()
			}
		}(prURL)
	}
	wg.Wait()

	utils.Log("rollback: closed %d PRs, failed %d", len(closed), len(failed))
	c.JSON(http.StatusOK, gin.H{
		"closed":      len(closed),
		"failed":      len(failed),
		"closed_urls": closed,
		"failed_urls": failed,
	})
}