realDynDNS/main.go

package main

import (
	"fmt"
	"log/slog"
	"os"
	"strings"

	"realdnydns/pkg/config"
	"realdnydns/pkg/dnsProvider"
	ionos "realdnydns/pkg/dnsProvider/ionos"
	"realdnydns/pkg/externalIpProvider"
	plainExternalIpProvider "realdnydns/pkg/externalIpProvider/plain"
	"realdnydns/pkg/notificationProvider"
	notificationProviderConsole "realdnydns/pkg/notificationProvider/console"
	gotify "realdnydns/pkg/notificationProvider/gotify"
	"realdnydns/pkg/realDynDns"
)

func main() {
	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
		Level: slog.LevelInfo,
	}))

	configClient := config.Config{}
	err := configClient.Load("config.yaml")
	if err != nil {
		logger.Error("Failed to load config file", slog.String("error", err.Error()))
		panic(err)
	}

	if configClient.LogLevel != "" {
		logger = slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
			Level: slog.Level(config.LogLevelMap[strings.ToLower(configClient.LogLevel)]),
		}))
	}

	var externalIpProvider externalIpProvider.ExternalIpProvider
	switch configClient.ExternalIPProvider.Type {
	case "plain":
		logger.Info("Using plain external IP provider", slog.String("external_ip_provider", "plain"))

		var plainConfig plainExternalIpProvider.PlainExternalIpProviderConfig
		err := configClient.ExternalIPProvider.ProviderConfig.Decode(&plainConfig)
		if err != nil {
			logger.Error("Failed to create config",
				slog.String("external_ip_provider", "plain"),
				slog.String("error", err.Error()),
			)
			panic(err)
		}

		externalIpProvider, err = plainExternalIpProvider.New(plainConfig)
		if err != nil {
			logger.Error("Failed to create plain external IP provider",
				slog.String("external_ip_provider", "plain"),
				slog.String("error", err.Error()),
			)
			panic(err)
		}
	default:
		logger.Error("Unknown external IP provider", slog.String("external_ip_provider", configClient.ExternalIPProvider.Type))
		panic(fmt.Errorf("unknown external IP provider: %s", configClient.ExternalIPProvider.Type))
	}

	var dnsProvider dnsProvider.DNSProvider
	switch configClient.DNSProvider.Type {
	case "ionos":
		logger.Info("Using IONOS DNS provider", slog.String("dns_provider", "ionos"))

		var ionosConfig ionos.IONOSConfig
		err := configClient.DNSProvider.ProviderConfig.Decode(&ionosConfig)
		if err != nil {
			logger.Error("Failed to create IONOS DNS provider",
				slog.String("dns_provider", "ionos"),
				slog.String("error", err.Error()),
			)
			panic(err)
		}

		dnsProvider, err = ionos.NewIonos(&ionosConfig)
		if err != nil {
			logger.Error("Failed to create IONOS DNS provider",
				slog.String("dns_provider", "ionos"),
				slog.String("error", err.Error()),
			)
			panic(err)
		}
	default:
		logger.Error("Unknown DNS provider", slog.String("dns_provider", configClient.DNSProvider.Type))
		panic(fmt.Errorf("unknown DNS provider: %s", configClient.DNSProvider.Type))
	}

	var notificationProvider notificationProvider.NotificationProvider
	switch configClient.NotificationProvider.Type {
	case "gotify":
		logger.Info("Using Gotify notification provider", slog.String("notification_provider", "gotify"))

		var gotifyConfig gotify.NotificationProviderImplGotifyConfig
		err := configClient.NotificationProvider.ProviderConfig.Decode(&gotifyConfig)
		if err != nil {
			panic(err)
		}

		notificationProvider, err = gotify.New(gotifyConfig)
		if err != nil {
			logger.Error("Failed to create Gotify notification provider",
				slog.String("notification_provider", "gotify"),
				slog.String("error", err.Error()),
			)
			panic(err)
		}
	default:
		logger.Info("Using console notification provider", slog.String("notification_provider", "console"))

		notificationProvider = notificationProviderConsole.New()
	}

	rdd := realDynDns.New(externalIpProvider, dnsProvider, notificationProvider, configClient.Domains, logger.With(slog.String("service", "realDynDns")))

	switch configClient.Mode {
	case config.ScheduledMode:
		logger.Info("Running in scheduled mode", slog.String("interval", configClient.CheckInterval))

		schedule, job, err := rdd.RunWithSchedule(configClient.CheckInterval)
		if err != nil {
			logger.Error("Failed to create scheduler", slog.String("error", err.Error()))
			panic(err)
		}

		logger.Info("Next run:", slog.String("time", job.NextRun().String()))
		schedule.StartBlocking()
	case config.RunOnceMode:
		logger.Info("Running in run once mode")

		_, err := rdd.RunOnce()
		if err != nil {
			logger.Error("Failed to run once", slog.String("error", err.Error()))
			panic(err)
		}
	}
}