Method HandleWebhook

pkg/public/server.go:1134–1217

(w http.ResponseWriter, r *http.Request)

}

func (s *Server) HandleWebhook(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	webhookIDFromRequest := vars["webhookID"]
	webhookID, err := uuid.Parse(webhookIDFromRequest)
	if err != nil {
		http.Error(w, "webhook not found", http.StatusNotFound)
		return
	}

	_, err = models.FindWebhook(webhookID)
	if err != nil {
		http.Error(w, "webhook not found", http.StatusNotFound)
		return
	}

	r.Body = http.MaxBytesReader(w, r.Body, MaxEventSize)
	defer r.Body.Close()

	body, err := io.ReadAll(r.Body)
	if err != nil {
		if _, ok := err.(*http.MaxBytesError); ok {
			http.Error(
				w,
				fmt.Sprintf("Request body is too large - must be up to %d bytes", MaxEventSize),
				http.StatusRequestEntityTooLarge,
			)

			return
		}

		http.Error(w, "Error reading request body", http.StatusBadRequest)
		return
	}

	nodes, err := models.FindActiveWebhookNodes(webhookID)
	if err != nil || len(nodes) == 0 {
		http.Error(w, "webhook not found", http.StatusNotFound)
		return
	}

	newEvents := []models.CanvasEvent{}
	onNewEvents := func(events []models.CanvasEvent) {
		newEvents = append(newEvents, events...)
	}

	touchedExecutions := map[uuid.UUID]uuid.UUID{}
	recordExecution := func(workflowID, executionID uuid.UUID) {
		touchedExecutions[executionID] = workflowID
	}

	var firstResponse *core.WebhookResponseBody

	for _, node := range nodes {
		code, response, err := s.executeWebhookNode(r.Context(), body, r.Header, node, onNewEvents, recordExecution)
		if err != nil {
			http.Error(w, fmt.Sprintf("error handling webhook: %v", err), code)
			return
		}