diff --git a/appview/oauth/scopes.go b/appview/oauth/scopes.go index 05eb68e8f..75881b8e1 100644 --- a/appview/oauth/scopes.go +++ b/appview/oauth/scopes.go @@ -33,6 +33,13 @@ var TangledScopes = []string{ "rpc:sh.tangled.knot.removeMember?aud=*", "rpc:sh.tangled.ci.triggerPipeline?aud=*", "rpc:sh.tangled.ci.cancelPipeline?aud=*", + "rpc:org.tangled.webhook.createWebhook?aud=*", + "rpc:org.tangled.webhook.updateWebhook?aud=*", + "rpc:org.tangled.webhook.deleteWebhook?aud=*", + "rpc:org.tangled.webhook.toggleWebhook?aud=*", + "rpc:org.tangled.webhook.listWebhooks?aud=*", + "rpc:org.tangled.webhook.listDeliveries?aud=*", + "rpc:org.tangled.webhook.retryDelivery?aud=*", "rpc:sh.tangled.repo.addCollaborator?aud=*", "rpc:sh.tangled.repo.addSecret?aud=*", "rpc:sh.tangled.repo.create?aud=*", diff --git a/appview/repo/webhooks.go b/appview/repo/webhooks.go index c11d22b10..8a9db4158 100644 --- a/appview/repo/webhooks.go +++ b/appview/repo/webhooks.go @@ -4,10 +4,10 @@ import ( "net/http" "strconv" "strings" + "time" - "github.com/bluesky-social/indigo/atproto/syntax" "github.com/go-chi/chi/v5" - "tangled.org/core/appview/db" + "tangled.org/core/api/tangled" "tangled.org/core/appview/models" "tangled.org/core/appview/pages" ) @@ -36,7 +36,51 @@ func webhookEventsFromForm(r *http.Request) []string { return events } -// Webhooks displays the webhooks settings page +// webhookFromXrpc adapts a spindle listWebhooks item into the view model the +// settings templates render. +func webhookFromXrpc(wh *tangled.WebhookListWebhooks_Webhook) models.Webhook { + m := models.Webhook{ + Id: wh.Id, + Url: wh.Url, + Active: wh.Active, + Events: wh.Events, + } + if t, err := time.Parse(time.RFC3339, wh.CreatedAt); err == nil { + m.CreatedAt = t + } + if wh.UpdatedAt != nil { + if t, err := time.Parse(time.RFC3339, *wh.UpdatedAt); err == nil { + m.UpdatedAt = t + } + } + return m +} + +func deliveryFromXrpc(d *tangled.WebhookListDeliveries_Delivery) models.WebhookDelivery { + m := models.WebhookDelivery{ + Id: d.Id, + DeliveryId: d.DeliveryId, + Event: d.Event, + Url: d.Url, + Success: d.Success, + } + if d.RequestBody != nil { + m.RequestBody = *d.RequestBody + } + if d.ResponseBody != nil { + m.ResponseBody = *d.ResponseBody + } + if d.ResponseCode != nil { + m.ResponseCode = int(*d.ResponseCode) + } + if t, err := time.Parse(time.RFC3339, d.CreatedAt); err == nil { + m.CreatedAt = t + } + return m +} + +// Webhooks displays the webhooks settings page. Webhooks now live on the repo's +// spindle; this handler proxies to the spindle's XRPC API. func (rp *Repo) Webhooks(w http.ResponseWriter, r *http.Request) { l := rp.logger.With("handler", "Webhooks") @@ -49,23 +93,49 @@ func (rp *Repo) Webhooks(w http.ResponseWriter, r *http.Request) { user := rp.oauth.GetMultiAccountUser(r) - webhooks, err := db.GetWebhooksForRepo(rp.db, f.RepoDid) + if f.Spindle == "" { + rp.pages.RepoWebhooksSettings(w, pages.RepoWebhooksSettingsParams{ + BaseParams: pages.BaseParamsFromContext(r.Context()), + RepoInfo: rp.repoResolver.GetRepoInfo(r, user), + }) + rp.pages.Notice(w, "webhooks-error", "This repository has no spindle configured; webhooks are unavailable.") + return + } + + client, err := rp.oauth.SpindleServiceClient(r, f.Spindle, tangled.WebhookListWebhooksNSID) if err != nil { - l.Error("failed to get webhooks", "err", err) + l.Error("failed to build spindle client", "err", err) + rp.pages.Notice(w, "webhooks-error", "Failed to authorize with spindle") + return + } + + out, err := tangled.WebhookListWebhooks(r.Context(), client, f.RepoDid) + if err != nil { + l.Error("failed to list webhooks", "err", err) rp.pages.Notice(w, "webhooks-error", "Failed to load webhooks") return } - // fetch recent deliveries for each webhook + webhooks := make([]models.Webhook, 0, len(out.Webhooks)) + for _, wh := range out.Webhooks { + webhooks = append(webhooks, webhookFromXrpc(wh)) + } + + // fetch recent deliveries for each webhook (best-effort) deliveriesMap := make(map[int64][]models.WebhookDelivery) - for _, webhook := range webhooks { - deliveries, err := db.GetWebhookDeliveries(rp.db, webhook.Id, 4) - if err != nil { - l.Error("failed to get webhook deliveries", "webhook_id", webhook.Id, "err", err) - // continue even if we can't get deliveries for one webhook - continue + if dclient, err := rp.oauth.SpindleServiceClient(r, f.Spindle, tangled.WebhookListDeliveriesNSID); err == nil { + for _, webhook := range webhooks { + dout, err := tangled.WebhookListDeliveries(r.Context(), dclient, webhook.Id, 4, f.RepoDid) + if err != nil { + l.Error("failed to get webhook deliveries", "webhook_id", webhook.Id, "err", err) + continue + } + ds := make([]models.WebhookDelivery, 0, len(dout.Deliveries)) + for _, d := range dout.Deliveries { + ds = append(ds, deliveryFromXrpc(d)) + } + deliveriesMap[webhook.Id] = ds } - deliveriesMap[webhook.Id] = deliveries } rp.pages.RepoWebhooksSettings(w, pages.RepoWebhooksSettingsParams{ @@ -76,7 +146,7 @@ func (rp *Repo) Webhooks(w http.ResponseWriter, r *http.Request) { }) } -// AddWebhook creates a new webhook +// AddWebhook creates a new webhook on the repo's spindle. func (rp *Repo) AddWebhook(w http.ResponseWriter, r *http.Request) { l := rp.logger.With("handler", "AddWebhook") @@ -86,61 +156,54 @@ func (rp *Repo) AddWebhook(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusBadRequest) return } + if f.Spindle == "" { + rp.pages.Notice(w, "webhooks-error", "This repository has no spindle configured; webhooks are unavailable.") + return + } url := strings.TrimSpace(r.FormValue("url")) if url == "" { rp.pages.Notice(w, "webhooks-error", "Webhook URL is required") return } - if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") { rp.pages.Notice(w, "webhooks-error", "Webhook URL must start with http:// or https://") return } - secret := strings.TrimSpace(r.FormValue("secret")) - // if secret is empty, we don't sign - - active := r.FormValue("active") == "on" - events := webhookEventsFromForm(r) if len(events) == 0 { rp.pages.Notice(w, "webhooks-error", "At least one event must be enabled") return } - webhook := &models.Webhook{ - RepoDid: syntax.DID(f.RepoDid), + active := r.FormValue("active") == "on" + input := &tangled.WebhookCreateWebhook_Input{ + RepoDid: f.RepoDid, Url: url, - Secret: secret, - Active: active, Events: events, + Active: &active, + } + if secret := strings.TrimSpace(r.FormValue("secret")); secret != "" { + input.Secret = &secret } - tx, err := rp.db.Begin() + client, err := rp.oauth.SpindleServiceClient(r, f.Spindle, tangled.WebhookCreateWebhookNSID) if err != nil { - l.Error("failed to start transaction", "err", err) - rp.pages.Notice(w, "webhooks-error", "Failed to create webhook") + l.Error("failed to build spindle client", "err", err) + rp.pages.Notice(w, "webhooks-error", "Failed to authorize with spindle") return } - defer tx.Rollback() - - if err := db.AddWebhook(tx, webhook); err != nil { + if _, err := tangled.WebhookCreateWebhook(r.Context(), client, input); err != nil { l.Error("failed to add webhook", "err", err) rp.pages.Notice(w, "webhooks-error", "Failed to create webhook") return } - if err := tx.Commit(); err != nil { - l.Error("failed to commit transaction", "err", err) - rp.pages.Notice(w, "webhooks-error", "Failed to create webhook") - return - } - rp.pages.HxRefresh(w) } -// UpdateWebhook updates an existing webhook +// UpdateWebhook updates an existing webhook on the repo's spindle. func (rp *Repo) UpdateWebhook(w http.ResponseWriter, r *http.Request) { l := rp.logger.With("handler", "UpdateWebhook") @@ -150,74 +213,55 @@ func (rp *Repo) UpdateWebhook(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusBadRequest) return } - - idStr := chi.URLParam(r, "id") - id, err := strconv.ParseInt(idStr, 10, 64) - if err != nil { - l.Error("invalid webhook id", "err", err) - w.WriteHeader(http.StatusBadRequest) + if f.Spindle == "" { + rp.pages.Notice(w, "webhooks-error", "This repository has no spindle configured; webhooks are unavailable.") return } - webhook, err := db.GetWebhook(rp.db, id) + id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) if err != nil { - l.Error("failed to get webhook", "err", err) - rp.pages.Notice(w, "webhooks-error", "Webhook not found") + l.Error("invalid webhook id", "err", err) + w.WriteHeader(http.StatusBadRequest) return } - // Verify webhook belongs to this repo - if string(webhook.RepoDid) != f.RepoDid { - l.Error("webhook does not belong to repo", "webhook_repo", webhook.RepoDid, "current_repo", f.RepoDid) - w.WriteHeader(http.StatusForbidden) - return + active := r.FormValue("active") == "on" + input := &tangled.WebhookUpdateWebhook_Input{ + Id: id, + RepoDid: f.RepoDid, + Active: &active, } - url := strings.TrimSpace(r.FormValue("url")) if url != "" { if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") { rp.pages.Notice(w, "webhooks-error", "Webhook URL must start with http:// or https://") return } - webhook.Url = url + input.Url = &url } - - secret := strings.TrimSpace(r.FormValue("secret")) - if secret != "" { - webhook.Secret = secret + if secret := strings.TrimSpace(r.FormValue("secret")); secret != "" { + input.Secret = &secret } - - webhook.Active = r.FormValue("active") == "on" - - events := webhookEventsFromForm(r) - if len(events) > 0 { - webhook.Events = events + if events := webhookEventsFromForm(r); len(events) > 0 { + input.Events = events } - tx, err := rp.db.Begin() + client, err := rp.oauth.SpindleServiceClient(r, f.Spindle, tangled.WebhookUpdateWebhookNSID) if err != nil { - l.Error("failed to start transaction", "err", err) - rp.pages.Notice(w, "webhooks-error", "Failed to update webhook") + l.Error("failed to build spindle client", "err", err) + rp.pages.Notice(w, "webhooks-error", "Failed to authorize with spindle") return } - defer tx.Rollback() - - if err := db.UpdateWebhook(tx, webhook); err != nil { + if err := tangled.WebhookUpdateWebhook(r.Context(), client, input); err != nil { l.Error("failed to update webhook", "err", err) rp.pages.Notice(w, "webhooks-error", "Failed to update webhook") return } - if err := tx.Commit(); err != nil { - l.Error("failed to commit transaction", "err", err) - rp.pages.Notice(w, "webhooks-error", "Failed to update webhook") - return - } - rp.pages.HxRefresh(w) } -// DeleteWebhook deletes a webhook +// DeleteWebhook deletes a webhook on the repo's spindle. func (rp *Repo) DeleteWebhook(w http.ResponseWriter, r *http.Request) { l := rp.logger.With("handler", "DeleteWebhook") @@ -227,53 +271,37 @@ func (rp *Repo) DeleteWebhook(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusBadRequest) return } - - idStr := chi.URLParam(r, "id") - id, err := strconv.ParseInt(idStr, 10, 64) - if err != nil { - l.Error("invalid webhook id", "err", err) - w.WriteHeader(http.StatusBadRequest) - return - } - - webhook, err := db.GetWebhook(rp.db, id) - if err != nil { - l.Error("failed to get webhook", "err", err) + if f.Spindle == "" { w.WriteHeader(http.StatusNotFound) return } - // Verify webhook belongs to this repo - if string(webhook.RepoDid) != f.RepoDid { - l.Error("webhook does not belong to repo", "webhook_repo", webhook.RepoDid, "current_repo", f.RepoDid) - w.WriteHeader(http.StatusForbidden) + id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) + if err != nil { + l.Error("invalid webhook id", "err", err) + w.WriteHeader(http.StatusBadRequest) return } - tx, err := rp.db.Begin() + client, err := rp.oauth.SpindleServiceClient(r, f.Spindle, tangled.WebhookDeleteWebhookNSID) if err != nil { - l.Error("failed to start transaction", "err", err) - rp.pages.Notice(w, "webhooks-error", "Failed to delete webhook") + l.Error("failed to build spindle client", "err", err) + rp.pages.Notice(w, "webhooks-error", "Failed to authorize with spindle") return } - defer tx.Rollback() - - if err := db.DeleteWebhook(tx, id); err != nil { + if err := tangled.WebhookDeleteWebhook(r.Context(), client, &tangled.WebhookDeleteWebhook_Input{ + Id: id, + RepoDid: f.RepoDid, + }); err != nil { l.Error("failed to delete webhook", "err", err) rp.pages.Notice(w, "webhooks-error", "Failed to delete webhook") return } - if err := tx.Commit(); err != nil { - l.Error("failed to commit transaction", "err", err) - rp.pages.Notice(w, "webhooks-error", "Failed to delete webhook") - return - } - rp.pages.HxRefresh(w) } -// ToggleWebhook toggles the active state of a webhook +// ToggleWebhook toggles the active state of a webhook on the repo's spindle. func (rp *Repo) ToggleWebhook(w http.ResponseWriter, r *http.Request) { l := rp.logger.With("handler", "ToggleWebhook") @@ -283,48 +311,29 @@ func (rp *Repo) ToggleWebhook(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusBadRequest) return } - - idStr := chi.URLParam(r, "id") - id, err := strconv.ParseInt(idStr, 10, 64) - if err != nil { - l.Error("invalid webhook id", "err", err) - w.WriteHeader(http.StatusBadRequest) - return - } - - webhook, err := db.GetWebhook(rp.db, id) - if err != nil { - l.Error("failed to get webhook", "err", err) + if f.Spindle == "" { w.WriteHeader(http.StatusNotFound) return } - // Verify webhook belongs to this repo - if string(webhook.RepoDid) != f.RepoDid { - l.Error("webhook does not belong to repo", "webhook_repo", webhook.RepoDid, "current_repo", f.RepoDid) - w.WriteHeader(http.StatusForbidden) - return - } - - // Toggle the active state - webhook.Active = !webhook.Active - - tx, err := rp.db.Begin() + id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) if err != nil { - l.Error("failed to start transaction", "err", err) - rp.pages.Notice(w, "webhooks-error", "Failed to toggle webhook") + l.Error("invalid webhook id", "err", err) + w.WriteHeader(http.StatusBadRequest) return } - defer tx.Rollback() - if err := db.UpdateWebhook(tx, webhook); err != nil { - l.Error("failed to update webhook", "err", err) - rp.pages.Notice(w, "webhooks-error", "Failed to toggle webhook") + client, err := rp.oauth.SpindleServiceClient(r, f.Spindle, tangled.WebhookToggleWebhookNSID) + if err != nil { + l.Error("failed to build spindle client", "err", err) + rp.pages.Notice(w, "webhooks-error", "Failed to authorize with spindle") return } - - if err := tx.Commit(); err != nil { - l.Error("failed to commit transaction", "err", err) + if _, err := tangled.WebhookToggleWebhook(r.Context(), client, &tangled.WebhookToggleWebhook_Input{ + Id: id, + RepoDid: f.RepoDid, + }); err != nil { + l.Error("failed to toggle webhook", "err", err) rp.pages.Notice(w, "webhooks-error", "Failed to toggle webhook") return } @@ -332,7 +341,7 @@ func (rp *Repo) ToggleWebhook(w http.ResponseWriter, r *http.Request) { rp.pages.HxRefresh(w) } -// WebhookDeliveries returns all deliveries for a webhook (for modal display) +// WebhookDeliveries returns all deliveries for a webhook (for modal display). func (rp *Repo) WebhookDeliveries(w http.ResponseWriter, r *http.Request) { l := rp.logger.With("handler", "WebhookDeliveries") @@ -342,37 +351,62 @@ func (rp *Repo) WebhookDeliveries(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusBadRequest) return } + if f.Spindle == "" { + w.WriteHeader(http.StatusNotFound) + return + } - idStr := chi.URLParam(r, "id") - id, err := strconv.ParseInt(idStr, 10, 64) + id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64) if err != nil { l.Error("invalid webhook id", "err", err) w.WriteHeader(http.StatusBadRequest) return } - webhook, err := db.GetWebhook(rp.db, id) + user := rp.oauth.GetMultiAccountUser(r) + + // look up the webhook (for its URL header) and its deliveries + listClient, err := rp.oauth.SpindleServiceClient(r, f.Spindle, tangled.WebhookListWebhooksNSID) if err != nil { - l.Error("failed to get webhook", "err", err) + l.Error("failed to build spindle client", "err", err) + rp.pages.Notice(w, "webhooks-error", "Failed to authorize with spindle") + return + } + listOut, err := tangled.WebhookListWebhooks(r.Context(), listClient, f.RepoDid) + if err != nil { + l.Error("failed to list webhooks", "err", err) + rp.pages.Notice(w, "webhooks-error", "Failed to load deliveries") + return + } + var webhook *models.Webhook + for _, wh := range listOut.Webhooks { + if wh.Id == id { + m := webhookFromXrpc(wh) + webhook = &m + break + } + } + if webhook == nil { w.WriteHeader(http.StatusNotFound) return } - // Verify webhook belongs to this repo - if string(webhook.RepoDid) != f.RepoDid { - l.Error("webhook does not belong to repo", "webhook_repo", webhook.RepoDid, "current_repo", f.RepoDid) - w.WriteHeader(http.StatusForbidden) + client, err := rp.oauth.SpindleServiceClient(r, f.Spindle, tangled.WebhookListDeliveriesNSID) + if err != nil { + l.Error("failed to build spindle client", "err", err) + rp.pages.Notice(w, "webhooks-error", "Failed to authorize with spindle") return } - - deliveries, err := db.GetWebhookDeliveries(rp.db, webhook.Id, 100) + dout, err := tangled.WebhookListDeliveries(r.Context(), client, id, 100, f.RepoDid) if err != nil { l.Error("failed to get webhook deliveries", "err", err) rp.pages.Notice(w, "webhooks-error", "Failed to load deliveries") return } - - user := rp.oauth.GetMultiAccountUser(r) + deliveries := make([]models.WebhookDelivery, 0, len(dout.Deliveries)) + for _, d := range dout.Deliveries { + deliveries = append(deliveries, deliveryFromXrpc(d)) + } rp.pages.WebhookDeliveriesList(w, pages.WebhookDeliveriesListParams{ BaseParams: pages.BaseParamsFromContext(r.Context()),