refactor

app/app.go

@@ -6,13 +6,12 @@ import (
 	"net"
 	"time"
 
-	"dnsupdater/provider/manager"
-
+	dnsservice "dnsupdater/dns/service"
 	"dnsupdater/ip"
 	"dnsupdater/ip/resolver"
 )
 
-// Constant name for the virtual WAN interface
+// WAN_IFACE Name for the virtual WAN interface
 const WAN_IFACE = "wan"
 
 type App struct {
@@ -20,8 +19,8 @@ type App struct {
 
 	cacheDefaultCallback ip.CacheDefaultCallback
 
-	// Updater manager
-	ProviderManager *manager.Manager
+	// DNS service manager
+	DnsServiceMgr *dnsservice.Manager
 }
 
 func makeCacheCallback(service resolver.Service) ip.CacheDefaultCallback {
@@ -36,23 +35,22 @@ func makeCacheCallback(service resolver.Service) ip.CacheDefaultCallback {
 }
 
 func NewApp(config *Config) (*App, error) {
-	providerMgr := manager.New()
-	// providerMgr.Register("digitalocean", digitalocean.New(config.Services.DigitalOcean.Token))
-	err := providerMgr.RegisterFromConfig(config.Providers)
+	dnsServiceMgr := dnsservice.NewManager()
+	err := dnsServiceMgr.RegisterFromConfig(config.Providers)
 	if err != nil {
 		return nil, err
 	}
 
-	service := resolver.Get(config.Services.IPLookup)
+	ipService := resolver.Get(config.Services.IPLookup)
 
-	if service == nil {
-		return nil, fmt.Errorf("Failed to load lookup service: %s", config.Services.IPLookup)
+	if ipService == nil {
+		return nil, fmt.Errorf("failed to load lookup service: %s", config.Services.IPLookup)
 	}
 
 	return &App{
-		ProviderManager:      providerMgr,
+		DnsServiceMgr:        dnsServiceMgr,
 		cache:                ip.NewCache(),
-		cacheDefaultCallback: makeCacheCallback(service),
+		cacheDefaultCallback: makeCacheCallback(ipService),
 	}, nil
 }
 

app/updater.go

@@ -0,0 +1,45 @@
+package app
+
+import (
+	"fmt"
+	"net"
+
+	"dnsupdater/dns"
+	"dnsupdater/dns/service"
+)
+
+type Updater struct {
+	service service.Service
+	// cache   map[string][]dns.Record
+	cache dns.DomainRecordCache
+}
+
+func NewUpdater(service service.Service) *Updater {
+	return &Updater{
+		service: service,
+		cache:   *dns.NewDomainRecordCache(service.List),
+	}
+}
+
+func (u Updater) find(domain string, record_name string) (*dns.Record, error) {
+	records, err := u.cache.Get(domain)
+	if err != nil {
+		return nil, err
+	}
+	if rec, found := records.FindByName(record_name); found {
+		return &rec, nil
+	}
+	return nil, fmt.Errorf("could not find record %s", record_name)
+}
+
+func (u Updater) Update(domain, record string, ip net.IP) error {
+	var err error
+	var r *dns.Record
+	if r, err = u.find(domain, record); err == nil {
+		// Update if needed.
+		if r.Ip == nil || !r.Ip.Equal(ip) {
+			return u.service.Update(domain, r.Id, ip.String())
+		}
+	}
+	return err
+}