Deploy main eacf1e7 to prod

Replaces #559, which conflicted.

Model: opus-5-5

internal/handlers/event_resubmit.go

@@ -3,7 +3,6 @@ package handlers
 import (
 	"errors"
 	"net/http"
-	"strconv"
 
 	"github.com/go-chi/chi"
 	"github.com/google/uuid"
@@ -11,43 +10,19 @@ import (
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
-// resubmitOutcomeParam is the query parameter the resubmit POST
-// redirects with and the event log page reads its banner from.
-const resubmitOutcomeParam = "resubmit"
-
-// resubmitOutcomeCode is the outcome of a resubmit POST. The redirect
-// carries one of these fixed codes rather than a message, so nothing a
-// client submits can reach the rendered page through it.
-type resubmitOutcomeCode string
-
+// The outcomes of a resubmit POST, as the notice codes its redirect
+// carries. noticeFor holds the line each one shows.
 const (
 	// resubmitQueued reports that a new event was stored and its
 	// deliveries handed to the delivery engine.
-	resubmitQueued resubmitOutcomeCode = "queued"
+	resubmitQueued noticeCode = "resubmit-queued"
 
 	// resubmitNoTargets reports a source with no active targets. The
 	// new event is stored either way, exactly as a received event
 	// with no targets is.
-	resubmitNoTargets resubmitOutcomeCode = "no-targets"
+	resubmitNoTargets noticeCode = "resubmit-no-targets"
 )
 
-// resubmitOutcome returns the banner the event log page shows for an
-// outcome code, and whether the resubmit was queued. An unrecognised
-// code yields no banner.
-func resubmitOutcome(code string) (string, bool) {
-	switch resubmitOutcomeCode(code) {
-	case resubmitQueued:
-		return "Resubmitted: a new event was created from the stored " +
-			"one and queued to every active target.", true
-	case resubmitNoTargets:
-		return "Resubmitted: a new event was created, but this " +
-				"source has no active targets, so nothing was queued.",
-			true
-	default:
-		return "", false
-	}
-}
-
 // resubmitSource is the stored event a resubmit copies. Its body is
 // read as bytes rather than as a string so the copy is byte-identical
 // to what was received, whatever the payload's encoding.
@@ -55,6 +30,7 @@ type resubmitSource struct {
 	ID           string
 	EntrypointID string
 	Method       string
+	RawQuery     string
 	Headers      string
 	ContentType  string
 	Body         []byte
@@ -64,7 +40,7 @@ type resubmitSource struct {
 // The cast to blob is what makes the driver hand back the stored bytes
 // rather than a string conversion, the same reason eventBodyQuery
 // casts.
-const resubmitColumns = "id, entrypoint_id, method, headers, " +
+const resubmitColumns = "id, entrypoint_id, method, raw_query, headers, " +
 	"content_type, cast(body as blob) AS body"
 
 // HandleEventResubmit re-injects a stored event as a new undelivered
@@ -99,7 +75,7 @@ func (h *Handlers) HandleEventResubmit() http.HandlerFunc {
 		// middleware, which runs before CSRF parses the form.
 		err := r.ParseForm()
 		if err != nil {
-			http.Error(w, "Bad request", http.StatusBadRequest)
+			h.renderError(w, r, http.StatusBadRequest)
 
 			return
 		}
@@ -120,20 +96,20 @@ func (h *Handlers) resubmitEvent(
 	// alphabet rather than from the request.
 	eventID, err := uuid.Parse(chi.URLParam(r, "eventID"))
 	if err != nil {
-		http.NotFound(w, r)
+		h.renderError(w, r, http.StatusNotFound)
 
 		return
 	}
 
 	if !h.dbMgr.DBExists(webhook.ID) {
-		http.NotFound(w, r)
+		h.renderError(w, r, http.StatusNotFound)
 
 		return
 	}
 
 	webhookDB, err := h.dbMgr.GetDB(webhook.ID)
 	if err != nil {
-		h.serverError(w, "failed to get webhook database", err)
+		h.serverError(w, r, "failed to get webhook database", err)
 
 		return
 	}
@@ -147,7 +123,7 @@ func (h *Handlers) resubmitEvent(
 		webhookDB, webhook.ID, eventID.String(),
 	)
 	if err != nil {
-		h.serverError(w, "failed to load event to resubmit", err)
+		h.serverError(w, r, "failed to load event to resubmit", err)
 
 		return
 	}
@@ -155,7 +131,7 @@ func (h *Handlers) resubmitEvent(
 	// A miss is a 404 whether the event was reaped, belongs to
 	// another webhook, or never existed.
 	if !found {
-		http.NotFound(w, r)
+		h.renderError(w, r, http.StatusNotFound)
 
 		return
 	}
@@ -170,8 +146,9 @@ func (h *Handlers) resubmitEvent(
 // per-webhook database files — a sibling webhook's event is not in the
 // database being queried at all — and is there so the scoping survives
 // any future change that puts more than one webhook's events in one
-// file. Going through Model applies GORM's soft-delete scope, which is
-// what stops a reaped event being resubmitted.
+// file. A reaped event is not found because the retention reaper
+// deletes its row outright rather than marking it deleted; see
+// deleteEvents in internal/database/retention.go.
 func loadResubmitSource(
 	webhookDB *gorm.DB,
 	webhookID, eventID string,
@@ -194,38 +171,31 @@ func loadResubmitSource(
 	return src, true, nil
 }
 
-// queueResubmit stores the copy and fans it out to the webhook's
-// active targets.
+// queueResubmit has the delivery engine store the copy, with a delivery
+// for each of the webhook's active targets as they stand now, through
+// the same StoreEvent the receiver uses. The one difference is that the
+// copy leaves its entrypoint's last event as it is, since it did not
+// arrive on that URL.
 func (h *Handlers) queueResubmit(
 	w http.ResponseWriter,
 	r *http.Request,
 	webhook database.Webhook,
 	src resubmitSource,
 ) {
-	// The receiver's own query, run now: an active target created
-	// after the original event arrived is included, and an
-	// inactive one is skipped rather than refused.
-	targets, err := h.loadActiveTargets(webhook.ID)
-	if err != nil {
-		h.serverError(w, "failed to query targets", err)
-
-		return
+	event := &database.Event{
+		WebhookID:         webhook.ID,
+		EntrypointID:      src.EntrypointID,
+		Method:            src.Method,
+		RawQuery:          src.RawQuery,
+		Headers:           src.Headers,
+		ContentType:       src.ContentType,
+		Body:              string(src.Body),
+		ResubmittedFromID: &src.ID,
 	}
 
-	event, tasks, err := h.createAndFanOut(
-		eventSource{
-			WebhookID:         webhook.ID,
-			EntrypointID:      src.EntrypointID,
-			Method:            src.Method,
-			HeadersJSON:       src.Headers,
-			ContentType:       src.ContentType,
-			Body:              src.Body,
-			ResubmittedFromID: &src.ID,
-		},
-		targets,
-	)
+	deliveries, err := h.engine.StoreEvent(event)
 	if err != nil {
-		h.serverError(w, "failed to store resubmitted event", err)
+		h.serverError(w, r, "failed to store resubmitted event", err)
 
 		return
 	}
@@ -237,37 +207,13 @@ func (h *Handlers) queueResubmit(
 		"webhook_id", webhook.ID,
 		"event_id", event.ID,
 		"resubmitted_from_id", src.ID,
-		"target_count", len(tasks),
+		"target_count", deliveries,
 	)
 
 	code := resubmitQueued
-	if len(tasks) == 0 {
+	if deliveries == 0 {
 		code = resubmitNoTargets
 	}
 
-	h.finishResubmit(w, r, webhook, code)
-}
-
-// finishResubmit redirects back to the event log the resubmit was
-// triggered from, carrying the outcome code the page turns into a
-// banner and the page number the form submitted.
-func (h *Handlers) finishResubmit(
-	w http.ResponseWriter,
-	r *http.Request,
-	webhook database.Webhook,
-	code resubmitOutcomeCode,
-) {
-	dest := "/source/" + webhook.ID + "/logs?" +
-		resubmitOutcomeParam + "=" + string(code)
-
-	// The page is read from the form rather than the query string:
-	// this is a POST, and its query string is what logs and Referer
-	// headers record.
-	if page := pageOrFirst(
-		r.PostFormValue("page"),
-	); page > 1 {
-		dest += "&page=" + strconv.Itoa(page)
-	}
-
-	http.Redirect(w, r, dest, http.StatusSeeOther)
+	redirectToEventLog(w, r, webhook, code)
 }