Refactor: Moved all under internal.

FEAT: Directadmin provider is now working

internal/notifications/types.go

@@ -0,0 +1,81 @@
+package notifications
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+)
+
+const (
+	configDelimiter = "@"
+)
+
+type Doer interface {
+	Do(*http.Request) (*http.Response, error)
+}
+
+type Notifiers []Notifier
+
+func (n Notifiers) NotifyWithLog(ctx context.Context, notification Notification) error {
+	var outErr error
+	for _, notifier := range n {
+		if err := notifier.Notify(ctx, notification); err != nil {
+			outErr = errors.Join(outErr, err)
+			continue
+		}
+		log.Printf("Notification sent via %s\n", notifier.Tag())
+	}
+	return outErr
+}
+
+type Notification struct {
+	OldIp        net.IP    `json:"old_ip,omitempty"`
+	NewIp        net.IP    `json:"new_ip"`
+	CheckedAt    time.Time `json:"checked_at"`
+	ResolverTag  string    `json:"resolver_tag"`
+	Domain       string    `json:"domain"`
+	WebhookToken string    `json:"token,omitempty"`
+}
+
+func (n Notification) ToSlice() []string {
+	return []string{n.OldIp.String(), n.NewIp.String(), n.CheckedAt.Format(time.RFC3339), n.ResolverTag, n.Domain}
+}
+
+var Available = map[string]func(string) (Notifier, error){
+	webhookTag: func(config string) (Notifier, error) {
+		parts := strings.Split(config, configDelimiter)
+
+		if len(parts) < 2 {
+			return nil, fmt.Errorf("wrong webhook config, missing url part")
+		}
+
+		return NewWebhookNotification(WebhookConfig{Url: parts[1]}, &http.Client{
+			Timeout: 10 * time.Second,
+		}), nil
+	},
+}
+
+type Notifier interface {
+	Tag() string
+	Notify(ctx context.Context, notification Notification) error
+}
+
+func GetNotifiers(tags []string) Notifiers {
+	out := Notifiers{}
+	for _, t := range tags {
+		if initFn, ok := Available[strings.Split(t, configDelimiter)[0]]; ok {
+			notifier, err := initFn(t)
+			if err != nil {
+				log.Println(err)
+				continue
+			}
+			out = append(out, notifier)
+		}
+	}
+	return out
+}

internal/notifications/webhook.go

@@ -0,0 +1,64 @@
+package notifications
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+)
+
+const (
+	webhookTag = "webhook"
+)
+
+type WebhookConfig struct {
+	Url string
+}
+
+type WebhookNotification struct {
+	config WebhookConfig
+	client Doer
+}
+
+func (w WebhookNotification) Tag() string {
+	return webhookTag
+}
+
+func NewWebhookNotification(config WebhookConfig, client Doer) *WebhookNotification {
+	return &WebhookNotification{config: config, client: client}
+}
+
+func (w WebhookNotification) getRequestBody(notification Notification) (io.Reader, error) {
+	out := bytes.NewBuffer(nil)
+	if err := json.NewEncoder(out).Encode(notification); err != nil {
+		return nil, fmt.Errorf("error encoding json notification body: %w", err)
+	}
+	return out, nil
+}
+
+func (w WebhookNotification) Notify(ctx context.Context, notification Notification) error {
+	body, err := w.getRequestBody(notification)
+	if err != nil {
+		return fmt.Errorf("WebhookNotification::NotifyWithLog error: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, w.config.Url, body)
+	if err != nil {
+		return fmt.Errorf("WebhookNotification::NotifyWithLog error creating request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := w.client.Do(req)
+	if err != nil {
+		return fmt.Errorf("WebhookNotification::NotifyWithLog error while sending notification: %w", err)
+	}
+	_ = resp.Body.Close()
+
+	if resp.StatusCode >= 300 {
+		return fmt.Errorf("WebhookNotification::NotifyWithLog unexpected non 2xx code %d returned", resp.StatusCode)
+	}
+	return nil
+}