Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

3.4 KB
Raw Blame
package scheduler

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"io"
	"log/slog"
	"net"
	"net/http"
	"time"

	internalurls "github.com/pinchtab/pinchtab/internal/urls"
)

var errNoValidatedWebhookIPs = errors.New("no validated callback IPs")

var webhookHTTPTimeout = 10 * time.Second

var dialWebhookAddress = func(ctx context.Context, network, addr string) (net.Conn, error) {
	return (&net.Dialer{}).DialContext(ctx, network, addr)
}

func newPinnedWebhookClient(target *validatedCallbackTarget) *http.Client {
	transport := http.DefaultTransport.(*http.Transport).Clone()
	transport.Proxy = nil
	transport.DialContext = func(ctx context.Context, network, _ string) (net.Conn, error) {
		var lastErr error
		for _, ip := range target.IPs {
			conn, err := dialWebhookAddress(ctx, network, net.JoinHostPort(ip.String(), target.Port))
			if err == nil {
				return conn, nil
			}
			lastErr = err
		}
		if lastErr == nil {
			lastErr = errNoValidatedWebhookIPs
		}
		return nil, lastErr
	}
	return &http.Client{
		Timeout:   webhookHTTPTimeout,
		Transport: transport,
		CheckRedirect: func(_ *http.Request, _ []*http.Request) error {
			return http.ErrUseLastResponse
		},
	}
}

// webhookDispatcher fires terminal-task webhooks asynchronously while bounding
// the number of concurrent deliveries.
type webhookDispatcher struct {
	sem  chan struct{}
	send func(string, *Task)
}

func newWebhookDispatcher(max int) *webhookDispatcher {
	return &webhookDispatcher{
		sem:  make(chan struct{}, max),
		send: sendWebhook,
	}
}

func (d *webhookDispatcher) fire(t *Task) {
	if t.CallbackURL == "" || !t.GetState().IsTerminal() {
		return
	}
	select {
	case d.sem <- struct{}{}:
		go func() {
			defer func() { <-d.sem }()
			d.send(t.CallbackURL, t)
		}()
	default:
		slog.Warn("webhook: too many in-flight deliveries, dropping", "task", t.ID)
	}
}

// sendWebhook delivers a task snapshot to the configured callbackUrl.
// Delivery is best-effort: failures are logged but do not affect task state.
func sendWebhook(callbackURL string, t *Task) {
	if callbackURL == "" {
		return
	}
	logURL := internalurls.RedactForLog(callbackURL)

	target, err := validateCallbackTarget(callbackURL)
	if err != nil {
		slog.Warn("webhook: callback rejected", "task", t.ID, "url", logURL, "err", err)
		return
	}

	snap := t.Snapshot()
	payload, err := json.Marshal(snap)
	if err != nil {
		slog.Warn("webhook: failed to marshal task", "task", t.ID, "err", err)
		return
	}

	req, err := http.NewRequest(http.MethodPost, target.URL.String(), bytes.NewReader(payload))
	if err != nil {
		slog.Warn("webhook: failed to create request", "task", t.ID, "err", err)
		return
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-PinchTab-Event", "task.completed")
	req.Header.Set("X-PinchTab-Task-ID", snap.ID)

	client := newPinnedWebhookClient(target)
	if transport, ok := client.Transport.(*http.Transport); ok {
		defer transport.CloseIdleConnections()
	}

	resp, err := client.Do(req)
	if err != nil {
		slog.Warn("webhook: delivery failed", "task", t.ID, "url", logURL, "err", err)
		return
	}
	// Drain body so the underlying connection can be reused.
	_, _ = io.Copy(io.Discard, resp.Body)
	_ = resp.Body.Close()

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		slog.Warn("webhook: non-success response", "task", t.ID, "url", logURL, "status", resp.StatusCode)
		return
	}

	slog.Info("webhook: delivered", "task", t.ID, "url", logURL, "status", resp.StatusCode)
}