chore(portforward): remove PIA dependency on storage package

internal/vpn/interfaces.go

@@ -53,7 +53,6 @@ type PortForwarder interface {
 
 type Storage interface {
 	FilterServers(provider string, selection settings.ServerSelection) (servers []models.Server, err error)
-	GetServerByName(provider, name string) (server models.Server, ok bool)
 }
 
 type NetLinker interface {

internal/vpn/openvpn.go

@@ -15,37 +15,38 @@ import (
 func setupOpenVPN(ctx context.Context, fw Firewall,
 	openvpnConf OpenVPN, providerConf provider.Provider,
 	settings settings.VPN, ipv6Supported bool, starter command.Starter,
-	logger openvpn.Logger) (runner *openvpn.Runner, serverName string, err error) {
+	logger openvpn.Logger) (runner *openvpn.Runner, serverName string,
+	canPortForward bool, err error) {
 	connection, err := providerConf.GetConnection(settings.Provider.ServerSelection, ipv6Supported)
 	if err != nil {
-		return nil, "", fmt.Errorf("finding a valid server connection: %w", err)
+		return nil, "", false, fmt.Errorf("finding a valid server connection: %w", err)
 	}
 
 	lines := providerConf.OpenVPNConfig(connection, settings.OpenVPN, ipv6Supported)
 
 	if err := openvpnConf.WriteConfig(lines); err != nil {
-		return nil, "", fmt.Errorf("writing configuration to file: %w", err)
+		return nil, "", false, fmt.Errorf("writing configuration to file: %w", err)
 	}
 
 	if *settings.OpenVPN.User != "" {
 		err := openvpnConf.WriteAuthFile(*settings.OpenVPN.User, *settings.OpenVPN.Password)
 		if err != nil {
-			return nil, "", fmt.Errorf("writing auth to file: %w", err)
+			return nil, "", false, fmt.Errorf("writing auth to file: %w", err)
 		}
 	}
 
 	if *settings.OpenVPN.KeyPassphrase != "" {
 		err := openvpnConf.WriteAskPassFile(*settings.OpenVPN.KeyPassphrase)
 		if err != nil {
-			return nil, "", fmt.Errorf("writing askpass file: %w", err)
+			return nil, "", false, fmt.Errorf("writing askpass file: %w", err)
 		}
 	}
 
 	if err := fw.SetVPNConnection(ctx, connection, settings.OpenVPN.Interface); err != nil {
-		return nil, "", fmt.Errorf("allowing VPN connection through firewall: %w", err)
+		return nil, "", false, fmt.Errorf("allowing VPN connection through firewall: %w", err)
 	}
 
 	runner = openvpn.NewRunner(settings.OpenVPN, starter, logger)
 
-	return runner, connection.ServerName, nil
+	return runner, connection.ServerName, connection.PortForward, nil
 }

internal/vpn/portforward.go

@@ -26,9 +26,10 @@ func (l *Loop) startPortForwarding(data tunnelUpData) (err error) {
 	partialUpdate := portforward.Settings{
 		VPNIsUp: ptrTo(true),
 		Service: service.Settings{
-			PortForwarder: data.portForwarder,
-			Interface:     data.vpnIntf,
-			ServerName:    data.serverName,
+			PortForwarder:  data.portForwarder,
+			Interface:      data.vpnIntf,
+			ServerName:     data.serverName,
+			CanPortForward: data.canPortForward,
 		},
 	}
 	return l.portForward.UpdateWith(partialUpdate)

internal/vpn/run.go

@@ -29,15 +29,16 @@ func (l *Loop) Run(ctx context.Context, done chan<- struct{}) {
 			Run(ctx context.Context, waitError chan<- error, tunnelReady chan<- struct{})
 		}
 		var serverName, vpnInterface string
+		var canPortForward bool
 		var err error
 		subLogger := l.logger.New(log.SetComponent(settings.Type))
 		if settings.Type == vpn.OpenVPN {
 			vpnInterface = settings.OpenVPN.Interface
-			vpnRunner, serverName, err = setupOpenVPN(ctx, l.fw,
+			vpnRunner, serverName, canPortForward, err = setupOpenVPN(ctx, l.fw,
 				l.openvpnConf, providerConf, settings, l.ipv6Supported, l.starter, subLogger)
 		} else { // Wireguard
 			vpnInterface = settings.Wireguard.Interface
-			vpnRunner, serverName, err = setupWireguard(ctx, l.netLinker, l.fw,
+			vpnRunner, serverName, canPortForward, err = setupWireguard(ctx, l.netLinker, l.fw,
 				providerConf, settings, l.ipv6Supported, subLogger)
 		}
 		if err != nil {
@@ -45,9 +46,10 @@ func (l *Loop) Run(ctx context.Context, done chan<- struct{}) {
 			continue
 		}
 		tunnelUpData := tunnelUpData{
-			serverName:    serverName,
-			portForwarder: portForwarder,
-			vpnIntf:       vpnInterface,
+			serverName:     serverName,
+			canPortForward: canPortForward,
+			portForwarder:  portForwarder,
+			vpnIntf:        vpnInterface,
 		}
 
 		openvpnCtx, openvpnCancel := context.WithCancel(context.Background())

internal/vpn/tunnelup.go

@@ -9,9 +9,10 @@ import (
 
 type tunnelUpData struct {
 	// Port forwarding
-	vpnIntf       string
-	serverName    string
-	portForwarder PortForwarder
+	vpnIntf        string
+	serverName     string // used for PIA
+	canPortForward bool   // used for PIA
+	portForwarder  PortForwarder
 }
 
 func (l *Loop) onTunnelUp(ctx context.Context, data tunnelUpData) {

internal/vpn/wireguard.go

@@ -16,10 +16,10 @@ import (
 func setupWireguard(ctx context.Context, netlinker NetLinker,
 	fw Firewall, providerConf provider.Provider,
 	settings settings.VPN, ipv6Supported bool, logger wireguard.Logger) (
-	wireguarder *wireguard.Wireguard, serverName string, err error) {
+	wireguarder *wireguard.Wireguard, serverName string, canPortForward bool, err error) {
 	connection, err := providerConf.GetConnection(settings.Provider.ServerSelection, ipv6Supported)
 	if err != nil {
-		return nil, "", fmt.Errorf("finding a VPN server: %w", err)
+		return nil, "", false, fmt.Errorf("finding a VPN server: %w", err)
 	}
 
 	wireguardSettings := utils.BuildWireguardSettings(connection, settings.Wireguard, ipv6Supported)
@@ -30,13 +30,13 @@ func setupWireguard(ctx context.Context, netlinker NetLinker,
 
 	wireguarder, err = wireguard.New(wireguardSettings, netlinker, logger)
 	if err != nil {
-		return nil, "", fmt.Errorf("creating Wireguard: %w", err)
+		return nil, "", false, fmt.Errorf("creating Wireguard: %w", err)
 	}
 
 	err = fw.SetVPNConnection(ctx, connection, settings.Wireguard.Interface)
 	if err != nil {
-		return nil, "", fmt.Errorf("setting firewall: %w", err)
+		return nil, "", false, fmt.Errorf("setting firewall: %w", err)
 	}
 
-	return wireguarder, connection.ServerName, nil
+	return wireguarder, connection.ServerName, connection.PortForward, nil
 }