Loops and HTTP control server rework (#308)

- CRUD REST HTTP server
- `/v1` HTTP server prefix
- Retrocompatible with older routes (redirects to v1 or handles the requests directly)
- DNS, Updater and Openvpn refactored to have a REST-like state with new methods to change their states synchronously
- Openvpn, Unbound and Updater status, see #287

internal/updater/loop.go

@@ -6,7 +6,9 @@ import (
 	"sync"
 	"time"
 
+	"github.com/qdm12/gluetun/internal/constants"
 	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/settings"
 	"github.com/qdm12/gluetun/internal/storage"
 	"github.com/qdm12/golibs/logging"
 )
@@ -14,60 +16,54 @@ import (
 type Looper interface {
 	Run(ctx context.Context, wg *sync.WaitGroup)
 	RunRestartTicker(ctx context.Context, wg *sync.WaitGroup)
-	Restart()
-	Stop()
-	GetPeriod() (period time.Duration)
-	SetPeriod(period time.Duration)
+	GetStatus() (status models.LoopStatus)
+	SetStatus(status models.LoopStatus) (outcome string, err error)
+	GetSettings() (settings settings.Updater)
+	SetSettings(settings settings.Updater) (outcome string)
 }
 
 type looper struct {
-	period        time.Duration
-	periodMutex   sync.RWMutex
+	state state
+	// Objects
 	updater       Updater
 	storage       storage.Storage
 	setAllServers func(allServers models.AllServers)
 	logger        logging.Logger
-	restart       chan struct{}
-	stop          chan struct{}
-	updateTicker  chan struct{}
-	timeNow       func() time.Time
-	timeSince     func(time.Time) time.Duration
+	// Internal channels and locks
+	loopLock     sync.Mutex
+	start        chan struct{}
+	running      chan models.LoopStatus
+	stop         chan struct{}
+	stopped      chan struct{}
+	updateTicker chan struct{}
+	// Mock functions
+	timeNow   func() time.Time
+	timeSince func(time.Time) time.Duration
 }
 
-func NewLooper(options Options, period time.Duration, currentServers models.AllServers,
+func NewLooper(settings settings.Updater, currentServers models.AllServers,
 	storage storage.Storage, setAllServers func(allServers models.AllServers),
 	client *http.Client, logger logging.Logger) Looper {
 	loggerWithPrefix := logger.WithPrefix("updater: ")
 	return &looper{
-		period:        period,
-		updater:       New(options, client, currentServers, loggerWithPrefix),
+		state: state{
+			status:   constants.Stopped,
+			settings: settings,
+		},
+		updater:       New(settings, client, currentServers, loggerWithPrefix),
 		storage:       storage,
 		setAllServers: setAllServers,
 		logger:        loggerWithPrefix,
-		restart:       make(chan struct{}),
+		start:         make(chan struct{}),
+		running:       make(chan models.LoopStatus),
 		stop:          make(chan struct{}),
+		stopped:       make(chan struct{}),
 		updateTicker:  make(chan struct{}),
 		timeNow:       time.Now,
 		timeSince:     time.Since,
 	}
 }
 
-func (l *looper) Restart() { l.restart <- struct{}{} }
-func (l *looper) Stop()    { l.stop <- struct{}{} }
-
-func (l *looper) GetPeriod() (period time.Duration) {
-	l.periodMutex.RLock()
-	defer l.periodMutex.RUnlock()
-	return l.period
-}
-
-func (l *looper) SetPeriod(period time.Duration) {
-	l.periodMutex.Lock()
-	l.period = period
-	l.periodMutex.Unlock()
-	l.updateTicker <- struct{}{}
-}
-
 func (l *looper) logAndWait(ctx context.Context, err error) {
 	l.logger.Error(err)
 	const waitTime = 5 * time.Minute
@@ -84,52 +80,71 @@ func (l *looper) logAndWait(ctx context.Context, err error) {
 
 func (l *looper) Run(ctx context.Context, wg *sync.WaitGroup) {
 	defer wg.Done()
+	crashed := false
 	select {
-	case <-l.restart:
-		l.logger.Info("starting...")
+	case <-l.start:
 	case <-ctx.Done():
 		return
 	}
 	defer l.logger.Warn("loop exited")
 
-	enabled := true
-
 	for ctx.Err() == nil {
-		for !enabled {
-			// wait for a signal to re-enable
+		updateCtx, updateCancel := context.WithCancel(ctx)
+		defer updateCancel()
+		serversCh := make(chan models.AllServers)
+		errorCh := make(chan error)
+		go func() {
+			servers, err := l.updater.UpdateServers(updateCtx)
+			if err != nil {
+				errorCh <- err
+				return
+			}
+			serversCh <- servers
+		}()
+
+		if !crashed {
+			l.running <- constants.Running
+			crashed = false
+		} else {
+			l.state.setStatusWithLock(constants.Running)
+		}
+
+		stayHere := true
+		for stayHere {
 			select {
-			case <-l.stop:
-				l.logger.Info("already disabled")
-			case <-l.restart:
-				enabled = true
 			case <-ctx.Done():
+				l.logger.Warn("context canceled: exiting loop")
+				updateCancel()
+				close(errorCh)
 				return
+			case <-l.start:
+				l.logger.Info("starting")
+				updateCancel()
+				stayHere = false
+			case <-l.stop:
+				l.logger.Info("stopping")
+				updateCancel()
+				<-errorCh
+				l.stopped <- struct{}{}
+			case servers := <-serversCh:
+				updateCancel()
+				close(serversCh)
+				l.setAllServers(servers)
+				if err := l.storage.FlushToFile(servers); err != nil {
+					l.logger.Error(err)
+				}
+				l.state.setStatusWithLock(constants.Completed)
+				l.logger.Info("Updated servers information")
+			case err := <-errorCh:
+				updateCancel()
+				close(serversCh)
+				l.state.setStatusWithLock(constants.Crashed)
+				l.logAndWait(ctx, err)
+				crashed = true
+				stayHere = false
 			}
 		}
-
-		// Enabled and has a period set
-
-		servers, err := l.updater.UpdateServers(ctx)
-		if err != nil {
-			if ctx.Err() != nil {
-				return
-			}
-			l.logAndWait(ctx, err)
-			continue
-		}
-		l.setAllServers(servers)
-		if err := l.storage.FlushToFile(servers); err != nil {
-			l.logger.Error(err)
-		}
-		l.logger.Info("Updated servers information")
-
-		select {
-		case <-l.restart: // triggered restart
-		case <-l.stop:
-			enabled = false
-		case <-ctx.Done():
-			return
-		}
+		close(errorCh)
 	}
 }
 
@@ -138,7 +153,7 @@ func (l *looper) RunRestartTicker(ctx context.Context, wg *sync.WaitGroup) {
 	timer := time.NewTimer(time.Hour)
 	timer.Stop()
 	timerIsStopped := true
-	if period := l.GetPeriod(); period > 0 {
+	if period := l.GetSettings().Period; period > 0 {
 		timerIsStopped = false
 		timer.Reset(period)
 	}
@@ -152,14 +167,14 @@ func (l *looper) RunRestartTicker(ctx context.Context, wg *sync.WaitGroup) {
 			return
 		case <-timer.C:
 			lastTick = l.timeNow()
-			l.restart <- struct{}{}
-			timer.Reset(l.GetPeriod())
+			l.start <- struct{}{}
+			timer.Reset(l.GetSettings().Period)
 		case <-l.updateTicker:
 			if !timerIsStopped && !timer.Stop() {
 				<-timer.C
 			}
 			timerIsStopped = true
-			period := l.GetPeriod()
+			period := l.GetSettings().Period
 			if period == 0 {
 				continue
 			}

internal/updater/options.go

@@ -1,32 +0,0 @@
-package updater
-
-type Options struct {
-	Cyberghost bool
-	Mullvad    bool
-	Nordvpn    bool
-	PIA        bool
-	Privado    bool
-	Purevpn    bool
-	Surfshark  bool
-	Vyprvpn    bool
-	Windscribe bool
-	Stdout     bool // in order to update constants file (maintainer side)
-	CLI        bool
-	DNSAddress string
-}
-
-func NewOptions(dnsAddress string) Options {
-	return Options{
-		Cyberghost: true,
-		Mullvad:    true,
-		Nordvpn:    true,
-		PIA:        true,
-		Purevpn:    true,
-		Surfshark:  true,
-		Vyprvpn:    true,
-		Windscribe: true,
-		Stdout:     false,
-		CLI:        false,
-		DNSAddress: dnsAddress,
-	}
-}

internal/updater/state.go

@@ -0,0 +1,88 @@
+package updater
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/settings"
+)
+
+type state struct {
+	status   models.LoopStatus
+	settings settings.Updater
+	statusMu sync.RWMutex
+	periodMu sync.RWMutex
+}
+
+func (s *state) setStatusWithLock(status models.LoopStatus) {
+	s.statusMu.Lock()
+	defer s.statusMu.Unlock()
+	s.status = status
+}
+
+func (l *looper) GetStatus() (status models.LoopStatus) {
+	l.state.statusMu.RLock()
+	defer l.state.statusMu.RUnlock()
+	return l.state.status
+}
+
+func (l *looper) SetStatus(status models.LoopStatus) (outcome string, err error) {
+	l.state.statusMu.Lock()
+	defer l.state.statusMu.Unlock()
+	existingStatus := l.state.status
+
+	switch status {
+	case constants.Running:
+		switch existingStatus {
+		case constants.Starting, constants.Running, constants.Stopping, constants.Crashed:
+			return fmt.Sprintf("already %s", existingStatus), nil
+		}
+		l.loopLock.Lock()
+		defer l.loopLock.Unlock()
+		l.state.status = constants.Starting
+		l.state.statusMu.Unlock()
+		l.start <- struct{}{}
+		newStatus := <-l.running
+		l.state.statusMu.Lock()
+		l.state.status = newStatus
+		return newStatus.String(), nil
+	case constants.Stopped:
+		switch existingStatus {
+		case constants.Stopped, constants.Stopping, constants.Starting, constants.Crashed:
+			return fmt.Sprintf("already %s", existingStatus), nil
+		}
+		l.loopLock.Lock()
+		defer l.loopLock.Unlock()
+		l.state.status = constants.Stopping
+		l.state.statusMu.Unlock()
+		l.stop <- struct{}{}
+		<-l.stopped
+		l.state.statusMu.Lock()
+		l.state.status = status
+		return status.String(), nil
+	default:
+		return "", fmt.Errorf("status %q can only be %q or %q",
+			status, constants.Running, constants.Stopped)
+	}
+}
+
+func (l *looper) GetSettings() (settings settings.Updater) {
+	l.state.periodMu.RLock()
+	defer l.state.periodMu.RUnlock()
+	return l.state.settings
+}
+
+func (l *looper) SetSettings(settings settings.Updater) (outcome string) {
+	l.state.periodMu.Lock()
+	defer l.state.periodMu.Unlock()
+	settingsUnchanged := reflect.DeepEqual(settings, l.state.settings)
+	if settingsUnchanged {
+		return "settings left unchanged"
+	}
+	l.state.settings = settings
+	l.updateTicker <- struct{}{}
+	return "settings updated"
+}

internal/updater/updater.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/settings"
 	"github.com/qdm12/golibs/logging"
 	"github.com/qdm12/golibs/network"
 )
@@ -17,7 +18,7 @@ type Updater interface {
 
 type updater struct {
 	// configuration
-	options Options
+	options settings.Updater
 
 	// state
 	servers models.AllServers
@@ -30,11 +31,12 @@ type updater struct {
 	client   network.Client
 }
 
-func New(options Options, httpClient *http.Client, currentServers models.AllServers, logger logging.Logger) Updater {
-	if len(options.DNSAddress) == 0 {
-		options.DNSAddress = "1.1.1.1"
+func New(settings settings.Updater, httpClient *http.Client,
+	currentServers models.AllServers, logger logging.Logger) Updater {
+	if len(settings.DNSAddress) == 0 {
+		settings.DNSAddress = "1.1.1.1"
 	}
-	resolver := newResolver(options.DNSAddress)
+	resolver := newResolver(settings.DNSAddress)
 	const clientTimeout = 10 * time.Second
 	return &updater{
 		logger:   logger,
@@ -42,7 +44,7 @@ func New(options Options, httpClient *http.Client, currentServers models.AllServ
 		println:  func(s string) { fmt.Println(s) },
 		lookupIP: newLookupIP(resolver),
 		client:   network.NewClient(clientTimeout),
-		options:  options,
+		options:  settings,
 		servers:  currentServers,
 	}
 }