Maint: use VPN settings instead of OpenVPN in loop

cmd/gluetun/main.go

@@ -356,7 +356,7 @@ func _main(ctx context.Context, buildInfo models.BuildInformation,
 	tickersGroupHandler.Add(pubIPTickerHandler)
 
 	openvpnLogger := logger.NewChild(logging.Settings{Prefix: "openvpn: "})
-	openvpnLooper := openvpn.NewLoop(allSettings.VPN.OpenVPN, allSettings.VPN.Provider,
+	openvpnLooper := openvpn.NewLoop(allSettings.VPN, allSettings.VPN.Provider,
 		allServers, ovpnConf, firewallConf, routingConf, portForwardLooper,
 		publicIPLooper, unboundLooper, openvpnLogger, httpClient,
 		buildInfo, allSettings.VersionInformation)

internal/openvpn/loop.go

@@ -63,7 +63,7 @@ const (
 	defaultBackoffTime = 15 * time.Second
 )
 
-func NewLoop(openVPNSettings configuration.OpenVPN,
+func NewLoop(vpnSettings configuration.VPN,
 	providerSettings configuration.Provider,
 	allServers models.AllServers, openvpnConf config.Interface,
 	fw firewallConfigurer, routing routing.VPNGetter,
@@ -77,7 +77,7 @@ func NewLoop(openVPNSettings configuration.OpenVPN,
 	stopped := make(chan struct{})
 
 	statusManager := loopstate.New(constants.Stopped, start, running, stop, stopped)
-	state := state.New(statusManager, openVPNSettings, providerSettings, allServers)
+	state := state.New(statusManager, vpnSettings, providerSettings, allServers)
 
 	return &Loop{
 		statusManager: statusManager,

internal/openvpn/run.go

@@ -22,11 +22,11 @@ func (l *Loop) Run(ctx context.Context, done chan<- struct{}) {
 	}
 
 	for ctx.Err() == nil {
-		openVPNSettings, providerSettings, allServers := l.state.GetSettingsAndServers()
+		VPNSettings, providerSettings, allServers := l.state.GetSettingsAndServers()
 
 		providerConf := provider.New(providerSettings.Name, allServers, time.Now)
 
-		serverName, err := setup(ctx, l.fw, l.openvpnConf, providerConf, openVPNSettings, providerSettings)
+		serverName, err := setup(ctx, l.fw, l.openvpnConf, providerConf, VPNSettings.OpenVPN, providerSettings)
 		if err != nil {
 			l.crashed(ctx, err)
 			continue
@@ -42,7 +42,7 @@ func (l *Loop) Run(ctx context.Context, done chan<- struct{}) {
 		tunnelReady := make(chan struct{})
 
 		go l.openvpnConf.Run(openvpnCtx, waitError, tunnelReady,
-			l.logger, openVPNSettings)
+			l.logger, VPNSettings.OpenVPN)
 
 		if err := l.waitForError(ctx, waitError); err != nil {
 			openvpnCancel()

internal/openvpn/settings.go

@@ -10,12 +10,12 @@ import (
 type SettingsGetSetter = state.SettingsGetSetter
 
 func (l *Loop) GetSettings() (
-	openvpn configuration.OpenVPN, provider configuration.Provider) {
+	vpn configuration.VPN, provider configuration.Provider) {
 	return l.state.GetSettings()
 }
 
 func (l *Loop) SetSettings(ctx context.Context,
-	openvpn configuration.OpenVPN, provider configuration.Provider) (
+	vpn configuration.VPN, provider configuration.Provider) (
 	outcome string) {
-	return l.state.SetSettings(ctx, openvpn, provider)
+	return l.state.SetSettings(ctx, vpn, provider)
 }

internal/openvpn/state/openvpn.go

@@ -9,32 +9,32 @@ import (
 )
 
 type SettingsGetSetter interface {
-	GetSettings() (openvpn configuration.OpenVPN,
+	GetSettings() (vpn configuration.VPN,
 		provider configuration.Provider)
-	SetSettings(ctx context.Context, openvpn configuration.OpenVPN,
+	SetSettings(ctx context.Context, vpn configuration.VPN,
 		provider configuration.Provider) (outcome string)
 }
 
-func (s *State) GetSettings() (openvpn configuration.OpenVPN,
+func (s *State) GetSettings() (vpn configuration.VPN,
 	provider configuration.Provider) {
 	s.settingsMu.RLock()
-	openvpn = s.openvpn
+	vpn = s.vpn
 	provider = s.provider
 	s.settingsMu.RUnlock()
-	return openvpn, provider
+	return vpn, provider
 }
 
 func (s *State) SetSettings(ctx context.Context,
-	openvpn configuration.OpenVPN, provider configuration.Provider) (
+	vpn configuration.VPN, provider configuration.Provider) (
 	outcome string) {
 	s.settingsMu.Lock()
-	settingsUnchanged := reflect.DeepEqual(s.openvpn, openvpn) &&
+	settingsUnchanged := reflect.DeepEqual(s.vpn, vpn) &&
 		reflect.DeepEqual(s.provider, provider)
 	if settingsUnchanged {
 		s.settingsMu.Unlock()
 		return "settings left unchanged"
 	}
-	s.openvpn = openvpn
+	s.vpn = vpn
 	s.provider = provider
 	s.settingsMu.Unlock()
 	_, _ = s.statusApplier.ApplyStatus(ctx, constants.Stopped)

internal/openvpn/state/state.go

@@ -13,16 +13,16 @@ var _ Manager = (*State)(nil)
 type Manager interface {
 	SettingsGetSetter
 	ServersGetterSetter
-	GetSettingsAndServers() (openvpn configuration.OpenVPN,
+	GetSettingsAndServers() (vpn configuration.VPN,
 		provider configuration.Provider, allServers models.AllServers)
 }
 
 func New(statusApplier loopstate.Applier,
-	openvpn configuration.OpenVPN, provider configuration.Provider,
+	vpn configuration.VPN, provider configuration.Provider,
 	allServers models.AllServers) *State {
 	return &State{
 		statusApplier: statusApplier,
-		openvpn:       openvpn,
+		vpn:           vpn,
 		provider:      provider,
 		allServers:    allServers,
 	}
@@ -31,7 +31,7 @@ func New(statusApplier loopstate.Applier,
 type State struct {
 	statusApplier loopstate.Applier
 
-	openvpn    configuration.OpenVPN
+	vpn        configuration.VPN
 	provider   configuration.Provider
 	settingsMu sync.RWMutex
 
@@ -39,14 +39,14 @@ type State struct {
 	allServersMu sync.RWMutex
 }
 
-func (s *State) GetSettingsAndServers() (openvpn configuration.OpenVPN,
+func (s *State) GetSettingsAndServers() (vpn configuration.VPN,
 	provider configuration.Provider, allServers models.AllServers) {
 	s.settingsMu.RLock()
 	s.allServersMu.RLock()
-	openvpn = s.openvpn
+	vpn = s.vpn
 	provider = s.provider
 	allServers = s.allServers
 	s.settingsMu.RUnlock()
 	s.allServersMu.RUnlock()
-	return openvpn, provider, allServers
+	return vpn, provider, allServers
 }

internal/server/openvpn.go

@@ -96,7 +96,8 @@ func (h *openvpnHandler) setStatus(w http.ResponseWriter, r *http.Request) {
 }
 
 func (h *openvpnHandler) getSettings(w http.ResponseWriter) {
-	settings, _ := h.looper.GetSettings()
+	vpnSettings, _ := h.looper.GetSettings()
+	settings := vpnSettings.OpenVPN
 	settings.User = "redacted"
 	settings.Password = "redacted"
 	encoder := json.NewEncoder(w)