Better abstraction around daemon

Author: mattolenik

ddns/ddns.go

@@ -16,6 +16,30 @@ type DDNSProvider interface {
 	Update(domain, record, ip string) error
 }
 
+type IPProvider interface {
+	Get() (ip string, err error)
+}
+
+type ConfigProvider interface {
+	Get() (domain, record string, err error)
+}
+
+type ipProvider struct{}
+
+func (p *ipProvider) Get() (string, error) {
+	ip, err := ip.GetPublicIPWithRetry(10, 5*time.Second)
+	if err != nil {
+		return "", errors.Trace(err)
+	}
+	return ip, nil
+}
+
+type configProvider struct{}
+
+func (p *configProvider) Get() (domain, record string, err error) {
+	return conf.Domain.Get(), conf.Record.Get(), nil
+}
+
 type Daemon interface {
 	Update(provider DDNSProvider) error
 	Start(provider DDNSProvider, updatePeriod, failureRetryDelay time.Duration) error
@@ -24,37 +48,67 @@ type Daemon interface {
 
 type DDNSDaemon struct {
 	Daemon
-	shouldRun bool
+	shouldRun      bool
+	ddnsProvider   DDNSProvider
+	ipProvider     IPProvider
+	configProvider ConfigProvider
+}
+
+// NewDDNSDaemon creates a new DDNSDaemon
+func NewDDNSDaemon(ddnsProvider DDNSProvider, ipProvider IPProvider, configProvider ConfigProvider) *DDNSDaemon {
+	if ddnsProvider == nil {
+		panic("ddnsProvider must not be nil")
+	}
+	if ipProvider == nil {
+		panic("ipProvider must not be nil")
+	}
+	if configProvider == nil {
+		panic("configProvider must not be nil")
+	}
+	return &DDNSDaemon{
+		shouldRun:      true,
+		ddnsProvider:   ddnsProvider,
+		ipProvider:     ipProvider,
+		configProvider: configProvider,
+	}
 }
 
 // Update performs a one time DDNS update.
-func (d *DDNSDaemon) Update(provider DDNSProvider) error {
-	ip, err := ip.GetPublicIPWithRetry(10, 5*time.Second)
+func (d *DDNSDaemon) Update() error {
+	ip, err := d.ipProvider.Get()
 	if err != nil {
 		return errors.Annotate(err, "unable to retrieve public IP")
 	}
 	log.Info().Msgf("Found public IP '%s'", ip)
-	err = provider.Update(conf.Domain.Get(), conf.Record.Get(), ip)
+	domain, record, err := d.configProvider.Get()
+	if err != nil {
+		return errors.Annotate(err, "unable to find domain or record in configuration")
+	}
+	err = d.ddnsProvider.Update(domain, record, ip)
 	return errors.Annotatef(err, "failed to update DNS")
 }
 
 // Start continually keeps DDNS up to date.
 // updatePeriod      - how often to check for updates
 // failureRetryDelay - how long to wait until retry after a failure
-func (d *DDNSDaemon) Start(provider DDNSProvider, updatePeriod, failureRetryDelay time.Duration) error {
+func (d *DDNSDaemon) Start(updatePeriod, failureRetryDelay time.Duration) error {
 	var lastIP string
 	var lastIPUpdate time.Time
 
 	log.Info().Msgf("Daemon running, will now monitor for IP updates every %d seconds", int(updatePeriod.Seconds()))
 
 	for d.shouldRun {
-		dnsRecordIP, err := provider.Get(conf.Domain.Get(), conf.Record.Get())
+		domain, record, err := d.configProvider.Get()
+		if err != nil {
+			return errors.Annotate(err, "unable to find domain or record in configuration")
+		}
+		dnsRecordIP, err := d.ddnsProvider.Get(domain, record)
 		if err != nil {
 			log.Error().Msgf("Unable to look up current DNS record, will retry in %d seconds. Error was:\n%v", int(updatePeriod.Seconds()), err)
 			time.Sleep(failureRetryDelay)
 			continue
 		}
-		newIP, err := ip.GetPublicIPWithRetry(10, 5*time.Second)
+		newIP, err := d.ipProvider.Get()
 		if err != nil {
 			log.Error().Msgf("Unable to retrieve public IP, will retry in %d seconds. Error was:\n%v", int(updatePeriod.Seconds()), err)
 			time.Sleep(failureRetryDelay)
@@ -81,7 +135,7 @@ func (d *DDNSDaemon) Start(provider DDNSProvider, updatePeriod, failureRetryDela
 		lastIP = newIP
 		lastIPUpdate = time.Now()
 
-		err = provider.Update(conf.Domain.Get(), conf.Record.Get(), lastIP)
+		err = d.ddnsProvider.Update(domain, record, lastIP)
 		if err != nil {
 			log.Error().Msgf("Unable to update DNS, will retry in %d seconds. Erorr was:\n%v", updatePeriod/time.Second, err)
 			time.Sleep(failureRetryDelay)
@@ -98,7 +152,7 @@ func (d *DDNSDaemon) Start(provider DDNSProvider, updatePeriod, failureRetryDela
 // StartWithDefaults calls Start but with default values
 func (d *DDNSDaemon) StartWithDefaults(provider DDNSProvider) error {
 	t := 10 * time.Second
-	return errors.Trace(d.Start(provider, t, t))
+	return errors.Trace(d.Start(t, t))
 }
 
 func (d *DDNSDaemon) Stop() {

ddns/ddns_test.go

@@ -2,43 +2,24 @@ package ddns
 
 import (
 	"testing"
-	"time"
 
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 )
 
-// mockDaemon is a mock DDNSDaemon
-type mockDaemon struct {
-	DDNSDaemon
-	domain, record, ip string
-}
-
-func (p *mockDaemon) Update(provider DDNSProvider) error {
-	return provider.Update(p.domain, p.record, p.ip)
-}
-
-func (p *mockDaemon) Start(provider DDNSProvider, updatePeriod, failureRetryDelay time.Duration) error {
-	return nil
-}
-
-func (p *mockDaemon) Stop() error {
-	return nil
-}
-
 func TestDDNSDaemon(t *testing.T) {
 	assert := assert.New(t)
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
-	d := mockDaemon{}
+	d := NewMockDaemon(ctrl)
 	p := NewMockDDNSProvider(ctrl)
-	d.domain = "abc.com"
-	d.record = "xyz.abc.com"
-	d.ip = "1.1.1.1"
-	p.EXPECT().Update(d.domain, d.record, d.ip).Return(nil).Times(1)
-	p.EXPECT().Get(d.domain, d.record).Return(d.ip, nil).Times(1)
+	domain := "abc.com"
+	record := "xyz.abc.com"
+	ip := "1.1.1.1"
+	p.EXPECT().Update(gomock.Eq(domain), gomock.Eq(record), gomock.Eq(ip)).Return(nil).Times(1)
+	p.EXPECT().Get(domain, record).Return(ip, nil).Times(1)
 	assert.NoError(d.Update(p))
-	ip, err := p.Get(d.domain, d.record)
+	ip, err := p.Get(domain)
 	assert.NoError(err)
-	assert.Equal(d.ip, ip)
+	assert.Equal(ip, ip)
 }