Download internal/webhook/webhook.go from abr00kx/levee: direct link, hf CLI and curl.
- Browser
- Download file 2.63 kB
-
https://huggingface.co/abr00kx/levee/resolve/main/internal/webhook/webhook.go
- Command line
-
hf download hf://abr00kx/levee/internal/webhook/webhook.go
-
curl -L -o webhook.go https://huggingface.co/abr00kx/levee/resolve/main/internal/webhook/webhook.go
2.63 kB
| // Package webhook delivers monitoring events to an HTTP endpoint, signed with | |
| // HMAC-SHA256 so receivers can verify they came from this Levee instance. | |
| package webhook | |
| import ( | |
| "bytes" | |
| "context" | |
| "crypto/hmac" | |
| "crypto/sha256" | |
| "encoding/hex" | |
| "encoding/json" | |
| "fmt" | |
| "io" | |
| "net/http" | |
| "strconv" | |
| "time" | |
| "levee/internal/store" | |
| "levee/internal/version" | |
| ) | |
| // MaxAttempts is how many times an event is tried before it is left for manual review. | |
| const MaxAttempts = 10 | |
| // Webhook posts events as JSON. | |
| type Webhook struct { | |
| URL string | |
| Secret string | |
| HTTP *http.Client | |
| } | |
| // New returns a webhook sender. | |
| func New(url, secret string) *Webhook { | |
| return &Webhook{URL: url, Secret: secret, HTTP: &http.Client{Timeout: 20 * time.Second}} | |
| } | |
| // Payload is the JSON body sent for each event. | |
| type Payload struct { | |
| Event store.Event `json:"event"` | |
| SentAt time.Time `json:"sent_at"` | |
| Source string `json:"source"` | |
| } | |
| // Sign returns the X-Levee-Signature header value for body. | |
| func Sign(secret string, body []byte) string { | |
| m := hmac.New(sha256.New, []byte(secret)) | |
| m.Write(body) | |
| return "sha256=" + hex.EncodeToString(m.Sum(nil)) | |
| } | |
| // Send posts one event. | |
| func (w *Webhook) Send(ctx context.Context, e store.Event) error { | |
| body, err := json.Marshal(Payload{Event: e, SentAt: time.Now().UTC(), Source: "levee/" + version.Version}) | |
| if err != nil { | |
| return err | |
| } | |
| req, err := http.NewRequestWithContext(ctx, http.MethodPost, w.URL, bytes.NewReader(body)) | |
| if err != nil { | |
| return err | |
| } | |
| req.Header.Set("Content-Type", "application/json") | |
| req.Header.Set("User-Agent", version.UserAgent()) | |
| req.Header.Set("X-Levee-Event", e.Kind) | |
| req.Header.Set("X-Levee-Delivery", strconv.FormatInt(e.ID, 10)) | |
| if w.Secret != "" { | |
| req.Header.Set("X-Levee-Signature", Sign(w.Secret, body)) | |
| } | |
| res, err := w.HTTP.Do(req) | |
| if err != nil { | |
| return err | |
| } | |
| io.Copy(io.Discard, io.LimitReader(res.Body, 64<<10)) | |
| res.Body.Close() | |
| if res.StatusCode < 200 || res.StatusCode > 299 { | |
| return fmt.Errorf("webhook: HTTP %d", res.StatusCode) | |
| } | |
| return nil | |
| } | |
| // Deliver sends undelivered events in order, stopping at the first failure so | |
| // receivers see events in sequence. It returns the number delivered. | |
| func (w *Webhook) Deliver(ctx context.Context, st *store.Store) (int, error) { | |
| events, err := st.UndeliveredEvents(ctx, MaxAttempts, 500) | |
| if err != nil { | |
| return 0, err | |
| } | |
| n := 0 | |
| for _, e := range events { | |
| if err := w.Send(ctx, e); err != nil { | |
| st.MarkDeliveryFailed(ctx, e.ID, err.Error()) | |
| return n, err | |
| } | |
| if err := st.MarkDelivered(ctx, e.ID); err != nil { | |
| return n, err | |
| } | |
| n++ | |
| } | |
| return n, nil | |
| } | |