feat(webhooks): add support for service update webhooks (#2161)

* Initial pass at adding webhook controller and routes

* Moving some objects around

* Cleaning up comments

* Fixing syntax, switching to using the docker sdk over building an http client

* Adding delete and list functionality

* Updating the handler to use the correct permissions. Updating some comments

* Fixing some comments

* Code cleanup per pull request comments

* Cleanup per PR feedback. Syntax error fix

* Initial creation of webhook app code

* Moving ClientFactory creation out of handler code and instead using the one created by the main process. Removing webhookInspect method and updating the list function to use json filters

* Delete now works on the webhook ID vs service ID

* WIP - Service creates a webhook. Display will show an existing webhook URL.

* Adding the webhook field to the service view. There is now the ability to add or remove a webhook from a service

* Moving all api calls to be webhooks vs webhook

* Code cleanup. Moving all api calls to be webhooks vs webhook

* More conversion of webhook to webhooks?

* Moving UI elements around. Starting function for copying to clipboard

* Finalizing function for copying to clipboard. Adding button that calls function and copies webhook to clipboard.

* Fixing UI issues. Hiding field entirely when there is no webhook

* Moving URL crafting to a helper method. The edit pane for service now creates/deletes webhooks immidiately.

* style(service-details): update webhook line

* feat(api): strip sha when updating an image via the update webhook

* Fixing up some copy. Only displying the port if it is not http or https

* Fixing tooltip copy. Setting the forceupdate to be true to require an update to occur

* Fixing code climate errors

* Adding WebhookType field and setting to ServiceWebhook for new webhooks. Renaming ServiceID to resourceID so future work can add new types of webhooks in other resource areas.

* Adding the webhook type to the payload to support more types of webhooks in the future. Setting the type correctly when creating one for a service

* feat(webhooks): changes related to webhook management

* API code cleanup, removing unneeded functions, and updating validation logic

* Incorrectly ignoring the error that the webhook did not exist

* Re-adding missing error handling. Changing error response to be a 404 vs 500 when token can't find an object

* fix(webhooks): close Docker client after service webhook execution

api/http/handler/webhooks/handler.go

@@ -0,0 +1,35 @@
+package webhooks
+
+import (
+	"net/http"
+
+	"github.com/gorilla/mux"
+	portainer "github.com/portainer/portainer"
+	"github.com/portainer/portainer/docker"
+	httperror "github.com/portainer/portainer/http/error"
+	"github.com/portainer/portainer/http/security"
+)
+
+// Handler is the HTTP handler used to handle webhook operations.
+type Handler struct {
+	*mux.Router
+	WebhookService      portainer.WebhookService
+	EndpointService     portainer.EndpointService
+	DockerClientFactory *docker.ClientFactory
+}
+
+// NewHandler creates a handler to manage settings operations.
+func NewHandler(bouncer *security.RequestBouncer) *Handler {
+	h := &Handler{
+		Router: mux.NewRouter(),
+	}
+	h.Handle("/webhooks",
+		bouncer.AuthenticatedAccess(httperror.LoggerHandler(h.webhookCreate))).Methods(http.MethodPost)
+	h.Handle("/webhooks",
+		bouncer.AuthenticatedAccess(httperror.LoggerHandler(h.webhookList))).Methods(http.MethodGet)
+	h.Handle("/webhooks/{id}",
+		bouncer.AuthenticatedAccess(httperror.LoggerHandler(h.webhookDelete))).Methods(http.MethodDelete)
+	h.Handle("/webhooks/{token}",
+		bouncer.PublicAccess(httperror.LoggerHandler(h.webhookExecute))).Methods(http.MethodPost)
+	return h
+}

api/http/handler/webhooks/webhook_create.go

@@ -0,0 +1,66 @@
+package webhooks
+
+import (
+	"net/http"
+
+	"github.com/asaskevich/govalidator"
+	"github.com/portainer/portainer"
+	httperror "github.com/portainer/portainer/http/error"
+	"github.com/portainer/portainer/http/request"
+	"github.com/portainer/portainer/http/response"
+	"github.com/satori/go.uuid"
+)
+
+type webhookCreatePayload struct {
+	ResourceID  string
+	EndpointID  int
+	WebhookType int
+}
+
+func (payload *webhookCreatePayload) Validate(r *http.Request) error {
+	if govalidator.IsNull(payload.ResourceID) {
+		return portainer.Error("Invalid ResourceID")
+	}
+	if payload.EndpointID == 0 {
+		return portainer.Error("Invalid EndpointID")
+	}
+	if payload.WebhookType != 1 {
+		return portainer.Error("Invalid WebhookType")
+	}
+	return nil
+}
+
+func (handler *Handler) webhookCreate(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	var payload webhookCreatePayload
+	err := request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{http.StatusBadRequest, "Invalid request payload", err}
+	}
+
+	webhook, err := handler.WebhookService.WebhookByResourceID(payload.ResourceID)
+	if err != nil && err != portainer.ErrObjectNotFound {
+		return &httperror.HandlerError{http.StatusInternalServerError, "An error occurred retrieving webhooks from the database", err}
+	}
+	if webhook != nil {
+		return &httperror.HandlerError{http.StatusConflict, "A webhook for this resource already exists", portainer.ErrWebhookAlreadyExists}
+	}
+
+	token, err := uuid.NewV4()
+	if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Error creating unique token", err}
+	}
+
+	webhook = &portainer.Webhook{
+		Token:       token.String(),
+		ResourceID:  payload.ResourceID,
+		EndpointID:  portainer.EndpointID(payload.EndpointID),
+		WebhookType: portainer.WebhookType(payload.WebhookType),
+	}
+
+	err = handler.WebhookService.CreateWebhook(webhook)
+	if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist the webhook inside the database", err}
+	}
+
+	return response.JSON(w, webhook)
+}

api/http/handler/webhooks/webhook_delete.go

@@ -0,0 +1,25 @@
+package webhooks
+
+import (
+	"net/http"
+
+	"github.com/portainer/portainer"
+	httperror "github.com/portainer/portainer/http/error"
+	"github.com/portainer/portainer/http/request"
+	"github.com/portainer/portainer/http/response"
+)
+
+// DELETE request on /api/webhook/:serviceID
+func (handler *Handler) webhookDelete(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	id, err := request.RetrieveNumericRouteVariableValue(r, "id")
+	if err != nil {
+		return &httperror.HandlerError{http.StatusBadRequest, "Invalid webhook id", err}
+	}
+
+	err = handler.WebhookService.DeleteWebhook(portainer.WebhookID(id))
+	if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to remove the webhook from the database", err}
+	}
+
+	return response.Empty(w)
+}

api/http/handler/webhooks/webhook_execute.go

@@ -0,0 +1,71 @@
+package webhooks
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	dockertypes "github.com/docker/docker/api/types"
+	"github.com/portainer/portainer"
+	httperror "github.com/portainer/portainer/http/error"
+	"github.com/portainer/portainer/http/request"
+	"github.com/portainer/portainer/http/response"
+)
+
+// Acts on a passed in token UUID to restart the docker service
+func (handler *Handler) webhookExecute(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+
+	webhookToken, err := request.RetrieveRouteVariableValue(r, "token")
+
+	if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Invalid service id parameter", err}
+	}
+
+	webhook, err := handler.WebhookService.WebhookByToken(webhookToken)
+
+	if err == portainer.ErrObjectNotFound {
+		return &httperror.HandlerError{http.StatusNotFound, "Unable to find a webhook with this token", err}
+	} else if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve webhook from the database", err}
+	}
+
+	resourceID := webhook.ResourceID
+	endpointID := webhook.EndpointID
+	webhookType := webhook.WebhookType
+
+	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
+	if err == portainer.ErrObjectNotFound {
+		return &httperror.HandlerError{http.StatusNotFound, "Unable to find an endpoint with the specified identifier inside the database", err}
+	} else if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find an endpoint with the specified identifier inside the database", err}
+	}
+	switch webhookType {
+	case portainer.ServiceWebhook:
+		return handler.executeServiceWebhook(w, endpoint, resourceID)
+	default:
+		return &httperror.HandlerError{http.StatusInternalServerError, "Unsupported webhook type", portainer.ErrUnsupportedWebhookType}
+	}
+
+}
+
+func (handler *Handler) executeServiceWebhook(w http.ResponseWriter, endpoint *portainer.Endpoint, resourceID string) *httperror.HandlerError {
+	dockerClient, err := handler.DockerClientFactory.CreateClient(endpoint)
+	if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Error creating docker client", err}
+	}
+	defer dockerClient.Close()
+
+	service, _, err := dockerClient.ServiceInspectWithRaw(context.Background(), resourceID, dockertypes.ServiceInspectOptions{InsertDefaults: true})
+	if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Error looking up service", err}
+	}
+
+	service.Spec.TaskTemplate.ForceUpdate++
+
+	service.Spec.TaskTemplate.ContainerSpec.Image = strings.Split(service.Spec.TaskTemplate.ContainerSpec.Image, "@sha")[0]
+	_, err = dockerClient.ServiceUpdate(context.Background(), resourceID, service.Version, service.Spec, dockertypes.ServiceUpdateOptions{QueryRegistry: true})
+	if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Error updating service", err}
+	}
+	return response.Empty(w)
+}

api/http/handler/webhooks/webhook_list.go

@@ -0,0 +1,47 @@
+package webhooks
+
+import (
+	"net/http"
+
+	"github.com/portainer/portainer"
+	httperror "github.com/portainer/portainer/http/error"
+	"github.com/portainer/portainer/http/request"
+	"github.com/portainer/portainer/http/response"
+)
+
+type webhookListOperationFilters struct {
+	ResourceID string `json:"ResourceID"`
+	EndpointID int    `json:"EndpointID"`
+}
+
+// GET request on /api/webhooks?(filters=<filters>)
+func (handler *Handler) webhookList(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	var filters webhookListOperationFilters
+	err := request.RetrieveJSONQueryParameter(r, "filters", &filters, true)
+	if err != nil {
+		return &httperror.HandlerError{http.StatusBadRequest, "Invalid query parameter: filters", err}
+	}
+
+	webhooks, err := handler.WebhookService.Webhooks()
+	webhooks = filterWebhooks(webhooks, &filters)
+	if err != nil {
+		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve webhooks from the database", err}
+	}
+
+	return response.JSON(w, webhooks)
+}
+
+func filterWebhooks(webhooks []portainer.Webhook, filters *webhookListOperationFilters) []portainer.Webhook {
+	if filters.EndpointID == 0 && filters.ResourceID == "" {
+		return webhooks
+	}
+
+	filteredWebhooks := make([]portainer.Webhook, 0, len(webhooks))
+	for _, webhook := range webhooks {
+		if webhook.EndpointID == portainer.EndpointID(filters.EndpointID) && webhook.ResourceID == string(filters.ResourceID) {
+			filteredWebhooks = append(filteredWebhooks, webhook)
+		}
+	}
+
+	return filteredWebhooks
+}