realDynDNS/pkg/realDynDns/realDynDns.go

package realDynDns

import (
	"fmt"
	"log/slog"
	"sync"

	"realdnydns/pkg/config"
	"realdnydns/pkg/dnsProvider"
	"realdnydns/pkg/externalIpProvider"
	"realdnydns/pkg/notificationProvider"

	gocron "github.com/go-co-op/gocron/v2"
)

type ChangeDetector struct {
	externalIpProvider   externalIpProvider.ExternalIpProvider
	dnsProvider          dnsProvider.DNSProvider
	notificationProvider notificationProvider.NotificationProvider
	domains              []config.DomainConfig
	logger               *slog.Logger
}

func New(
	externalIpProvider externalIpProvider.ExternalIpProvider,
	dnsProvider dnsProvider.DNSProvider,
	notificationProvider notificationProvider.NotificationProvider,
	domains []config.DomainConfig,
	logger *slog.Logger,
) ChangeDetector {
	return ChangeDetector{
		externalIpProvider:   externalIpProvider,
		dnsProvider:          dnsProvider,
		notificationProvider: notificationProvider,
		domains:              domains,
		logger:               logger,
	}
}

func (c *ChangeDetector) RunWithSchedule(checkInterval string) (gocron.Scheduler, gocron.Job, error) {
	s, err := gocron.NewScheduler()
	if err != nil {
		return nil, nil, err
	}

	job, err := s.NewJob(
		gocron.CronJob(checkInterval, true),
		gocron.NewTask(func(job gocron.Job) {
			numberChanged, err := c.detectAndApplyChanges()
			if err != nil {
				panic(err)
			}
			fmt.Printf("Number of changes: %d\n", numberChanged)
			nextRun, err := job.NextRun()
			if err != nil {
				panic(err)
			}
			fmt.Println("Next run:", nextRun)
		}))
	if err != nil {
		return nil, nil, err
	}

	return s, job, nil
}

func (c *ChangeDetector) RunOnce() (int, error) {
	return c.detectAndApplyChanges()
}

func (c *ChangeDetector) detectAndApplyChanges() (int, error) {
	c.logger.Info("Detecting and applying changes")

	externalIp, err := c.externalIpProvider.GetExternalIp()
	if err != nil {
		c.logger.Error("Failed to retrieve external IP", slog.String("error", err.Error()))
		return 0, err
	}

	var wg sync.WaitGroup

	numberUpdatedChannel := make(chan int)

	for _, domain := range c.domains {
		for _, subdomain := range domain.Subdomains {
			wg.Add(1)

			go func(domain config.DomainConfig, subdomain string) {
				defer wg.Done()

				c.logger.Info("Checking record",
					slog.String("tld", domain.TLD),
					slog.String("subdomain", subdomain),
				)
				currentRecord, err := c.dnsProvider.GetRecord(domain.TLD, subdomain)
				if err != nil {
					c.logger.Error("Failed to retrieve record",
						slog.String("error", err.Error()),
						slog.String("tld", domain.TLD),
						slog.String("subdomain", subdomain),
					)
					return
				}

				if currentRecord.IP != externalIp.String() {
					c.logger.Info("Record has changed",
						slog.String("tld", domain.TLD),
						slog.String("subdomain", subdomain),
						slog.String("current_ip", currentRecord.IP),
						slog.String("external_ip", externalIp.String()),
					)

					err = c.notificationProvider.SendNotification(
						fmt.Sprintf("Update %s.%s", subdomain, domain.TLD),
						fmt.Sprintf("The IP of %s has changed from %s to %s", domain.TLD, currentRecord.IP, externalIp.String()),
					)
					if err != nil {
						c.logger.Warn("Failed to send notification",
							slog.String("error", err.Error()),
						)
						return
					}

					c.logger.Info("Updating record",
						slog.String("tld", domain.TLD),
						slog.String("subdomain", subdomain),
						slog.String("current_ip", currentRecord.IP),
						slog.String("external_ip", externalIp.String()),
					)
					_, err = c.dnsProvider.UpdateRecord(domain.TLD, subdomain, externalIp, currentRecord.TTL, currentRecord.Prio, currentRecord.Disabled)
					if err != nil {
						c.logger.Error("Failed to update record",
							slog.String("error", err.Error()),
							slog.String("tld", domain.TLD),
							slog.String("subdomain", subdomain),
						)
						return
					}

					numberUpdatedChannel <- 1
				}
			}(domain, subdomain)
		}
	}

	go func() {
		wg.Wait()
		close(numberUpdatedChannel)
	}()

	numberUpdated := 0
	for v := range numberUpdatedChannel {
		numberUpdated += v
	}

	c.logger.Info("Run completed", slog.Int("number_of_changes", numberUpdated))
	return numberUpdated, nil
}