Deploy main eacf1e7 to prod

Replaces #559, which conflicted.

Model: opus-5-5

internal/handlers/target_edit.go

@@ -1,9 +1,12 @@
 package handlers
 
 import (
+	"errors"
 	"net/http"
+	"strconv"
 
 	"github.com/go-chi/chi"
+	"sneak.berlin/go/webhooker/internal/archive"
 	"sneak.berlin/go/webhooker/internal/database"
 	"sneak.berlin/go/webhooker/internal/delivery"
 )
@@ -12,44 +15,42 @@ import (
 const targetEditTemplate = "target_edit.html"
 
 // tmplKeyTarget is the template data key for the target being
-// edited, and tmplKeyMaxTimeout for the timeout ceiling the form
-// tells the user about.
+// edited, tmplKeyTargetForm for the values its form shows, and
+// tmplKeyMaxTimeout for the timeout ceiling the form tells the user
+// about. The add target form on the webhook page takes its values
+// under the same key as the edit form.
 const (
 	tmplKeyTarget     = "Target"
+	tmplKeyTargetForm = "TargetForm"
 	tmplKeyMaxTimeout = "MaxTimeout"
 )
 
-// configUnreadableMessage is shown when a target's stored
-// configuration does not parse. It says plainly that saving replaces
-// the stored value rather than preserving it, because the form
-// cannot pre-fill what it could not read.
-const configUnreadableMessage = "The stored configuration for this " +
-	"target could not be read. Enter the values below; saving " +
-	"replaces the stored configuration."
-
-// targetEditView is the display model for the target edit page.
+// targetEditView is the display model for the target edit page: the
+// target's row fields as stored. The values the form shows, the
+// UNMASKED URL and headers among them, come separately, as a
+// targetFormInput.
 //
-// It carries the target's row fields alongside its UNMASKED
-// configuration, and deliberately omits database.Target's raw
-// Config blob: the form renders named fields, and giving the
-// template the blob as well would put an unreviewed second path to
-// the credential on the page.
+// It deliberately omits database.Target's settings: the form renders
+// them from the targetFormInput, and giving the template the target's
+// URL and headers as well would put an unreviewed second path to the
+// credential on the page.
 type targetEditView struct {
-	ID         string
-	Name       string
-	Type       database.TargetType
-	Active     bool
-	MaxRetries int
-	Config     delivery.TargetConfigForm
+	ID     string
+	Name   string
+	Type   database.TargetType
+	Active bool
 }
 
-// HandleTargetEdit shows the form to edit a target.
+// HandleTargetEdit shows the form to edit a target, filled with the
+// target's settings as stored.
 //
 // This page is the one place the full destination URL and header
-// values are shown. It is reachable only through the
-// /source/{sourceID} route group, which supplies RequireAuth and
-// NoCache, and only for a target of a webhook the session's user
-// owns; masking (delivery.TargetView) is unchanged everywhere else.
+// values are shown: an operator cannot correct a value they cannot
+// see. It is reachable only through the /hook/{sourceID} route
+// group, which supplies RequireAuth and NoCache, and only for a
+// target of a webhook the session's user owns; masking
+// (delivery.TargetView) is unchanged everywhere else. Do not fill a
+// form like this one on any other page.
 func (h *Handlers) HandleTargetEdit() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		webhook, target, ok := h.ownedTarget(w, r)
@@ -57,28 +58,29 @@ func (h *Handlers) HandleTargetEdit() http.HandlerFunc {
 			return
 		}
 
-		cfg, err := delivery.NewTargetConfigForm(target)
-		msg := ""
-
-		if err != nil {
-			// The error carries the parse failure, never the
-			// blob, so it is safe to log against the target id.
-			h.log.Warn(
-				"stored target config could not be read for editing",
-				"target_id", target.ID,
-				"error", err,
-			)
-
-			msg = configUnreadableMessage
+		form := targetFormInput{
+			Name:         target.Name,
+			URL:          target.URL,
+			Headers:      delivery.FormatTargetHeaders(target.Headers),
+			Timeout:      delivery.FormatTargetTimeout(target.TimeoutSeconds),
+			ForwardQuery: target.ForwardQuery,
+			MaxAttempts:  strconv.Itoa(target.MaxAttempts),
+			Expiry:       formatArchiveExpiry(target.ArchiveExpiry),
+			Rotation:     target.ArchiveRotation,
 		}
 
-		h.renderTargetEdit(w, r, webhook, target, cfg, msg)
+		h.renderTargetEdit(
+			w, r, webhook, target, form, "", http.StatusOK,
+		)
 	}
 }
 
 // HandleTargetEditSubmit handles the target edit form submission.
 func (h *Handlers) HandleTargetEditSubmit() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+		h.archives.RenameLock().Lock()
+		defer h.archives.RenameLock().Unlock()
+
 		webhook, target, ok := h.ownedTarget(w, r)
 		if !ok {
 			return
@@ -88,9 +90,7 @@ func (h *Handlers) HandleTargetEditSubmit() 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
 		}
@@ -99,83 +99,111 @@ func (h *Handlers) HandleTargetEditSubmit() http.HandlerFunc {
 	}
 }
 
-// applyTargetEdit validates and saves target edits.
+// applyTargetEdit validates and saves target edits. A refused save
+// shows the edit form again with the values submitted and the reason.
 //
-// The submitted configuration goes through buildTargetConfig, the
-// same builder the create path uses, so an edited destination is
-// SSRF-validated exactly as a new one is.
+// The submission goes through setTargetFromForm, as a new target
+// does, so an edited destination is SSRF-validated exactly as a new
+// one is.
 //
-// The target's type is not editable. Each type stores a different
-// configuration shape and its delivery history is recorded against
-// the target row, so changing the type of an existing target is
-// really the creation of a different one. The stored type decides
-// which fields the form offers and which builder runs.
+// The target's type is not editable. Each type uses different
+// settings and its delivery history is recorded against the target
+// row, so changing the type of an existing target is really the
+// creation of a different one. The stored type decides which fields
+// the form offers and which settings are set.
 func (h *Handlers) applyTargetEdit(
 	w http.ResponseWriter,
 	r *http.Request,
 	webhook database.Webhook,
 	target *database.Target,
 ) {
-	name := r.PostFormValue("name")
-	if name == "" {
-		http.Error(
-			w, "Name is required", http.StatusBadRequest,
+	in := targetFormInputFrom(r)
+
+	// edited is the target as the submission leaves it; target stays
+	// as stored, for the page shown again when the save is refused.
+	edited := *target
+
+	errMsg := h.setTargetFromForm(r.Context(), &edited, in)
+	if errMsg != "" {
+		h.renderTargetEdit(
+			w, r, webhook, target, in, errMsg, http.StatusBadRequest,
 		)
 
 		return
 	}
 
-	configJSON, err := h.buildTargetConfig(
-		w, r, target.Type, targetFormInputFrom(r),
+	// A new name renames the archive file before it is saved (see
+	// archive.Writers.Rename). If either step fails, it goes back to
+	// the name that is still stored.
+	err := h.renameTargetArchive(
+		target, webhook.Name, target.Name, edited.Name,
 	)
-	if err != nil {
-		// buildTargetConfig has already written the response.
-		return
+	if err == nil {
+		err = h.db.DB().Save(&edited).Error
 	}
 
-	// Retries are offered only by the forms for target types that
-	// retry, so an absent field means "this form does not edit
-	// retries" rather than "set them to zero". Reading it
-	// unconditionally would silently disable retries on any target
-	// saved from a form that does not render the input.
-	//
-	// A field that IS submitted but does not parse is a 400, through
-	// the same validator the create path uses. It is rejected before
-	// anything is written, so a typo cannot destroy the retry count
-	// the target is already delivering with.
-	if r.PostForm.Has("max_retries") {
-		retries, ok := targetMaxRetries(w, r, target.MaxRetries)
-		if !ok {
+	if err != nil {
+		restoreErr := h.renameTargetArchive(
+			target, webhook.Name, edited.Name, target.Name,
+		)
+		if restoreErr != nil {
+			h.log.Error(
+				"failed to rename archive back",
+				"target_id", target.ID,
+				"error", restoreErr,
+			)
+		}
+
+		if errors.Is(err, archive.ErrNameTaken) {
+			h.renderTargetEdit(
+				w, r, webhook, target, in,
+				"Not saved: "+err.Error()+
+					". Move that archive out of the data directory, "+
+					"its .db together with any -wal and -shm beside "+
+					"it, then save again.",
+				http.StatusConflict,
+			)
+
 			return
 		}
 
-		target.MaxRetries = retries
-	}
-
-	target.Name = name
-	target.Config = configJSON
-
-	err = h.db.DB().Save(target).Error
-	if err != nil {
-		h.serverError(w, "failed to update target", err)
+		h.serverError(w, r, "failed to update target", err)
 
 		return
 	}
 
 	http.Redirect(
-		w, r, "/source/"+webhook.ID, http.StatusSeeOther,
+		w, r, withNotice("/hook/"+webhook.ID, targetSaved),
+		http.StatusSeeOther,
 	)
 }
 
-// renderTargetEdit renders the target edit page with an optional
-// error message.
+// renameTargetArchive renames a database target's archive file from
+// the target name oldName to newName. It does nothing when the name
+// is unchanged; other target types have no archive.
+func (h *Handlers) renameTargetArchive(
+	target *database.Target,
+	webhookName, oldName, newName string,
+) error {
+	if h.archives == nil || oldName == newName ||
+		target.Type != database.TargetTypeDatabase {
+		return nil
+	}
+
+	return h.archives.Rename(target.ID, webhookName, newName)
+}
+
+// renderTargetEdit renders the target edit page for the target as
+// stored, its form showing form's values, with an optional error
+// message above it.
 func (h *Handlers) renderTargetEdit(
 	w http.ResponseWriter,
 	r *http.Request,
 	webhook database.Webhook,
 	target *database.Target,
-	cfg delivery.TargetConfigForm,
+	form targetFormInput,
 	errMsg string,
+	status int,
 ) {
 	// The template calls Webhook methods, which take pointer
 	// receivers; html/template cannot address a value stored in a
@@ -183,18 +211,21 @@ func (h *Handlers) renderTargetEdit(
 	data := map[string]any{
 		tmplKeyWebhook: &webhook,
 		tmplKeyTarget: targetEditView{
-			ID:         target.ID,
-			Name:       target.Name,
-			Type:       target.Type,
-			Active:     target.Active,
-			MaxRetries: target.MaxRetries,
-			Config:     cfg,
+			ID:     target.ID,
+			Name:   target.Name,
+			Type:   target.Type,
+			Active: target.Active,
 		},
-		tmplKeyMaxTimeout: delivery.MaxTargetTimeoutSeconds,
-		tmplKeyError:      errMsg,
+		tmplKeyTargetForm:           form,
+		tmplKeyMaxTimeout:           delivery.MaxTargetTimeoutSeconds,
+		tmplKeyError:                errMsg,
+		tmplKeyArchiveExpiryChoices: archiveExpiryOptions(form.Expiry),
+		tmplKeyArchiveRotationChoices: archiveRotationOptions(
+			form.Rotation,
+		),
 	}
 
-	h.renderTemplate(w, r, targetEditTemplate, data)
+	h.renderTemplateStatus(w, r, targetEditTemplate, data, status)
 }
 
 // ownedTarget resolves the request's sourceID and targetID
@@ -220,7 +251,7 @@ func (h *Handlers) ownedTarget(
 		chi.URLParam(r, "targetID"), webhook.ID,
 	).First(&target).Error
 	if err != nil {
-		http.NotFound(w, r)
+		h.renderError(w, r, http.StatusNotFound)
 
 		return database.Webhook{}, nil, false
 	}