#115 refactor: added interface service to manage more specific interf…

…ace stuff the WireguardService was doing until now

+ Added guid to generators
+ Fixed some issues with mocks
+ Removed unused imports

Linguard/Cli.Test/AddInterfaceCommandShould.cs

@@ -1,6 +1,4 @@
-using System.Linq;
-using System.Net.NetworkInformation;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Castle.Core.Internal;
 using Core.Test.Mocks;
 using FluentAssertions;

Linguard/Core.Test/ClientShould.cs

@@ -13,7 +13,9 @@ namespace Core.Test;
 
 public class ClientShould {
     private static readonly Mock<IConfigurationManager> ConfigurationManagerMock = new DefaultConfigurationManager();
-    private static IWireguardService WireguardService => new WireguardService(ConfigurationManagerMock.Object, new CommandRunner());
+    private static IWireguardService WireguardService => 
+        new WireguardService(ConfigurationManagerMock.Object, new CommandRunner(), 
+        new InterfaceService(ConfigurationManagerMock.Object, new CommandRunner()));
     [Fact]
     public void CreateValidWireguardConfig() {
 

Linguard/Core.Test/InterfaceShould.cs

@@ -15,7 +15,9 @@ namespace Core.Test;
 
 public class InterfaceShould {
     private static readonly Mock<IConfigurationManager> ConfigurationManagerMock = new DefaultConfigurationManager();
-    private static IWireguardService WireguardService => new WireguardService(ConfigurationManagerMock.Object, new CommandRunner());
+    private static IWireguardService WireguardService => 
+        new WireguardService(ConfigurationManagerMock.Object, new CommandRunner(), 
+            new InterfaceService(ConfigurationManagerMock.Object, new CommandRunner()));
 
     [Fact]
     public void CreateValidWireguardConfiguration() {

Linguard/Core.Test/Mocks/NetworkInterfaceMock.cs

@@ -1,10 +1,17 @@
 using System.Net.NetworkInformation;
+using Bogus;
 using Moq;
 
 namespace Core.Test.Mocks; 
 
 public class NetworkInterfaceMock : Mock<NetworkInterface> {
-    public NetworkInterfaceMock(string name) {
+    public NetworkInterfaceMock(string name, OperationalStatus status = OperationalStatus.Unknown) {
         SetupGet(i => i.Name).Returns(name);
+        SetupGet(i => i.OperationalStatus).Returns(status);
+        var properties = new Mock<IPInterfaceProperties>();
+        properties.SetupGet(o => o.UnicastAddresses)
+            .Returns(new Mock<UnicastIPAddressInformationCollection>().Object);
+        Setup(o => o.GetIPProperties()).Returns(properties.Object);
+        Setup(o => o.GetPhysicalAddress()).Returns(new PhysicalAddress(new Faker().Random.Bytes(6)));
     }
 }

Linguard/Core.Test/YamlConfigurationSerializerShould.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Net.NetworkInformation;
 using Core.Test.Mocks;
 using FluentAssertions;
 using Linguard.Core;
@@ -10,7 +8,6 @@
 using Linguard.Core.Models;
 using Linguard.Core.Models.Wireguard;
 using Linguard.Log;
-using Moq;
 using Xunit;
 
 namespace Core.Test; 

Linguard/Core/Configuration/Serialization/DefaultYamlConfigurationSerializer.cs

@@ -1,6 +1,4 @@
 using Linguard.Core.Drivers.TrafficStorage;
-using YamlDotNet.Core;
-using YamlDotNet.Serialization;
 using YamlDotNet.Serialization.NamingConventions;
 
 namespace Linguard.Core.Configuration.Serialization; 

Linguard/Core/Services/DefaultClientGenerator.cs

@@ -19,6 +19,14 @@ public DefaultClientGenerator(IWireguardService wireguard, IConfigurationManager
 
     public Client Generate(Interface iface) {
         return new Faker<Client>()
+            .RuleFor(c => c.Id, () => {
+                var clients = Configuration.Interfaces.SelectMany(i => i.Clients).ToList();
+                Guid id = default;
+                while (id == default || clients.Any(c => c.Id == id)) {
+                    id = Guid.NewGuid();
+                }
+                return id;
+            })
             .RuleFor(c => c.Nat, false)
             .RuleFor(c => c.Description, f => f.Lorem.Sentence())
             .RuleFor(c => c.Name, f => f.Person.FullName)

Linguard/Core/Services/DefaultInterfaceGenerator.cs

@@ -20,6 +20,13 @@ public DefaultInterfaceGenerator(IConfigurationManager configurationManager, IWi
 
     public Interface Generate() {
         return new Faker<Interface>()
+            .RuleFor(i => i.Id, () => {
+                Guid id = default;
+                while (id == default || Configuration.Interfaces.Any(iface => iface.Id == id)) {
+                    id = Guid.NewGuid();
+                }
+                return id;
+            })
             .RuleFor(i => i.Auto, true)
             .RuleFor(i => i.Description, f => f.Lorem.Sentence())
             .RuleFor(i => i.Gateway, f => {

Linguard/Core/Services/IInterfaceService.cs

@@ -0,0 +1,13 @@
+using System.Net.NetworkInformation;
+using Linguard.Core.Models.Wireguard;
+
+namespace Linguard.Core.Services; 
+
+public interface IInterfaceService {
+    IEnumerable<NetworkInterface> NetworkInterfaces { get; }
+    Interface? GetInterface(Client client);
+    bool IsInterfaceUp(Interface iface);
+    bool IsInterfaceDown(Interface iface);
+    void StartInterface(Interface @interface);
+    void StopInterface(Interface @interface);
+}

Linguard/Core/Services/IWireguardService.cs

@@ -5,11 +5,6 @@
 namespace Linguard.Core.Services; 
 
 public interface IWireguardService {
-    Interface? GetInterface(Client client);
-    bool IsInterfaceUp(Interface iface);
-    bool IsInterfaceDown(Interface iface);
-    void StartInterface(Interface @interface);
-    void StopInterface(Interface @interface);
     string? GenerateWireguardPrivateKey();
     string? GenerateWireguardPublicKey(string privateKey);
     string[] GenerateOnUpRules(string interfaceName, NetworkInterface gateway);

Linguard/Core/Services/InterfaceService.cs

@@ -0,0 +1,47 @@
+using System.Net.NetworkInformation;
+using Linguard.Core.Configuration;
+using Linguard.Core.Managers;
+using Linguard.Core.Models.Wireguard;
+using Linguard.Core.OS;
+using Linguard.Core.Services.Exceptions;
+
+namespace Linguard.Core.Services; 
+
+public class InterfaceService : IInterfaceService {
+
+    private readonly IConfigurationManager _configurationManager;
+    private readonly ICommandRunner _commandRunner;
+
+    public InterfaceService(IConfigurationManager configurationManager, ICommandRunner commandRunner) {
+        _configurationManager = configurationManager;
+        _commandRunner = commandRunner;
+    }
+
+    private IWireguardConfiguration Configuration => _configurationManager.Configuration.Wireguard;
+
+    public IEnumerable<NetworkInterface> NetworkInterfaces => NetworkInterface.GetAllNetworkInterfaces();
+
+    public Interface? GetInterface(Client client) => Configuration.Interfaces
+        .SingleOrDefault(i => i.Clients.Contains(client));
+
+    public bool IsInterfaceUp(Interface iface) {
+        return NetworkInterfaces
+            .Any(i => i.Name.Equals(iface.Name) && i.OperationalStatus == OperationalStatus.Up);
+    }
+
+    public bool IsInterfaceDown(Interface iface) {
+        return !IsInterfaceUp(iface);
+    }
+
+    public void StartInterface(Interface @interface) {
+        var result = _commandRunner
+            .Run($"sudo {Configuration.WireguardQuickBin} up {@interface.Name}");
+        if (!result.Success) throw new WireguardException(result.Stderr);
+    }
+
+    public void StopInterface(Interface @interface) {
+        var result = _commandRunner
+            .Run($"sudo {Configuration.WireguardQuickBin} down {@interface.Name}");
+        if (!result.Success) throw new WireguardException(result.Stderr);
+    }
+}

Linguard/Core/Services/WireguardService.cs

@@ -13,38 +13,17 @@ namespace Linguard.Core.Services;
 public class WireguardService : IWireguardService {
     private readonly IConfigurationManager _configurationManager;
     private readonly ICommandRunner _commandRunner;
-
-    public WireguardService(IConfigurationManager configurationManager, ICommandRunner commandRunner) {
+    private readonly IInterfaceService _interfaceService;
+
+    public WireguardService(IConfigurationManager configurationManager, ICommandRunner commandRunner,
+        IInterfaceService interfaceService) {
         _configurationManager = configurationManager;
         _commandRunner = commandRunner;
+        _interfaceService = interfaceService;
     }
 
     private IWireguardConfiguration Configuration => _configurationManager.Configuration.Wireguard;
 
-    public Interface? GetInterface(Client client) => Configuration.Interfaces
-        .SingleOrDefault(i => i.Clients.Contains(client));
-
-    public bool IsInterfaceUp(Interface iface) {
-        return NetworkInterface.GetAllNetworkInterfaces()
-            .Any(i => i.Name.Equals(iface.Name) && i.OperationalStatus == OperationalStatus.Up);
-    }
-
-    public bool IsInterfaceDown(Interface iface) {
-        return !IsInterfaceUp(iface);
-    }
-
-    public void StartInterface(Interface @interface) {
-        var result = _commandRunner
-            .Run($"sudo {Configuration.WireguardQuickBin} up {@interface.Name}");
-        if (!result.Success) throw new WireguardException(result.Stderr);
-    }
-
-    public void StopInterface(Interface @interface) {
-        var result = _commandRunner
-            .Run($"sudo {Configuration.WireguardQuickBin} down {@interface.Name}");
-        if (!result.Success) throw new WireguardException(result.Stderr);
-    }
-
     public string? GenerateWireguardPrivateKey() {
         var result = _commandRunner
             .Run($"sudo {Configuration.WireguardBin} genkey");
@@ -87,7 +66,7 @@ public string GenerateWireguardConfiguration(IWireguardPeer peer) {
 
     public DateTime GetLastHandshake(Client client) {
         var rawData = _commandRunner
-            .Run($"{Configuration.WireguardBin} show {GetInterface(client).Name} dump")
+            .Run($"{Configuration.WireguardBin} show {_interfaceService.GetInterface(client).Name} dump")
             .Stdout;
         try {
             return WireguardDumpParser.GetLastHandshake(rawData, client);
@@ -106,7 +85,7 @@ public IEnumerable<TrafficData> GetTrafficData() {
     }
 
     public TrafficData? GetTrafficData(Client client) {
-        var data = GetTrafficData(GetInterface(client));
+        var data = GetTrafficData(_interfaceService.GetInterface(client));
         return data.SingleOrDefault(e => e.Peer.Equals(client));
     }
 

Linguard/Web/Pages/EditInterface.razor

@@ -16,6 +16,7 @@
 @inject NavigationManager _navigationManager
 @inject IJSRuntime _js
 @inject AbstractValidator<Interface> _validator
+@inject IInterfaceService _interfaceService
 
 @code {
     const string Title = "Interface";
@@ -37,7 +38,7 @@
     <div class="col">
         <h1 class="mb-3">
             @Title
-            @if (_wireguardService.IsInterfaceUp(Iface)) {
+            @if (_interfaceService.IsInterfaceUp(Iface)) {
                 <RadzenBadge class="float-end" IsPill="true" Text="up" BadgeStyle="BadgeStyle.Success" />
             }
             else {

Linguard/Web/Pages/Network.razor

@@ -2,6 +2,7 @@
 @using Linguard.Core.Utils
 @using System.Net.NetworkInformation
 @using System.Net.Sockets
+@using Linguard.Core.Services
 
 @code {
     const string Title = "Network";
@@ -34,6 +35,7 @@
     </Columns>
 </RadzenDataGrid>
 
+@inject IInterfaceService _interfaceService
 @code {
 
     class NetworkInterfaceViewModel {
@@ -49,11 +51,11 @@
 
     protected override void OnInitialized() {
         _interfaces = new List<NetworkInterfaceViewModel>();
-        var interfaces = NetworkInterface.GetAllNetworkInterfaces()
+        var interfaces = _interfaceService.NetworkInterfaces
             .OrderBy(i => i.Name)
             .ToList();
         foreach (var iface in interfaces) {
-            var addresses = iface.GetIPProperties().UnicastAddresses;
+            var addresses = iface.GetIPProperties().UnicastAddresses.ToList();
             var ipv4 = addresses.FirstOrDefault(
                 a => a.Address.AddressFamily == AddressFamily.InterNetwork);
             var ipv6 = addresses.FirstOrDefault(

Linguard/Web/Pages/Wireguard.razor

@@ -8,7 +8,7 @@
 @using Linguard.Web.Services
 
 @inject IConfigurationManager _configurationManager
-@inject IWireguardService _wireguardService
+@inject IInterfaceService _interfaceService
 @inject IWebService _webService
 @inject NotificationService _notificationService
 @inject DialogService _dialogService
@@ -39,7 +39,7 @@
         <RadzenDataGridColumn TItem="Interface" Title="Actions" Resizable="false" 
                               Filterable="false" Sortable="false">
             <Template Context="data">
-                @if (_wireguardService.IsInterfaceDown(data)) {
+                @if (_interfaceService.IsInterfaceDown(data)) {
                     <RadzenButton Icon="play_arrow" ButtonStyle="ButtonStyle.Success" title="Start"
                                   Click="() => StartInterface(data)" />
                 }
@@ -92,8 +92,8 @@
         <RadzenDataGridColumn TItem="Client" Property="IPv6Address" Title="IPv6"/>
         <RadzenDataGridColumn TItem="Client" Title="Interface">
             <Template Context="data">
-                <a href="/interface/@(_wireguardService.GetInterface(data)?.Id)">
-                    @(_wireguardService.GetInterface(data)?.Name)
+                <a href="/interface/@(_interfaceService.GetInterface(data)?.Id)">
+                    @(_interfaceService.GetInterface(data)?.Name)
                 </a>
             </Template>
         </RadzenDataGridColumn>
@@ -133,7 +133,7 @@
 
     void StartInterface(Interface iface) {
         try {
-            _wireguardService.StartInterface(iface);
+            _interfaceService.StartInterface(iface);
             _interfacesGrid.Reload();
         }
         catch (Exception e) {
@@ -147,7 +147,7 @@
 
     void StopInterface(Interface @interface) {
         try {
-            _wireguardService.StopInterface(@interface);
+            _interfaceService.StopInterface(@interface);
             _interfacesGrid.Reload();
         }
         catch (Exception e) {

Linguard/Web/Program.cs

@@ -26,6 +26,7 @@
 builder.Services.AddTransient<ILogger, NLogLogger>();
 builder.Services.AddTransient<ICommandRunner, CommandRunner>();
 builder.Services.AddTransient<IWireguardService, WireguardService>();
+builder.Services.AddTransient<IInterfaceService, InterfaceService>();
 builder.Services.AddTransient<IInterfaceGenerator, DefaultInterfaceGenerator>();
 builder.Services.AddTransient<IClientGenerator, DefaultClientGenerator>();
 builder.Services.AddTransient<AbstractValidator<Interface>, InterfaceValidator>();

Linguard/Web/Services/LifetimeService.cs

@@ -15,15 +15,16 @@ public class LifetimeService : ILifetimeService {
     private static readonly string WorkingDirectoryEnvironmentVariable = $"{AssemblyInfo.Product}Workdir";
 
     private readonly Log.ILogger _logger;
-    private readonly IWireguardService _wireguardService;
+    private readonly IInterfaceService _interfaceService;
     private readonly IConfigurationManager _configurationManager;
     private IWireguardConfiguration Configuration => _configurationManager.Configuration.Wireguard;
 
     #endregion
 
-    public LifetimeService(IConfigurationManager configurationManager, IWireguardService wireguardService, Log.ILogger logger) {
+    public LifetimeService(IConfigurationManager configurationManager, IInterfaceService interfaceService, 
+        Log.ILogger logger) {
         _configurationManager = configurationManager;
-        _wireguardService = wireguardService;
+        _interfaceService = interfaceService;
         _logger = logger;
     }
 
@@ -84,7 +85,7 @@ private void StartInterfaces() {
         var started = 0;
         foreach (var iface in interfaces) {
             try {
-                _wireguardService.StartInterface(iface);
+                _interfaceService.StartInterface(iface);
                 started++;
             }
             catch (Exception e) {
@@ -101,7 +102,7 @@ private void StopInterfaces() {
         var stopped = 0;
         foreach (var iface in interfaces) {
             try {
-                _wireguardService.StopInterface(iface);
+                _interfaceService.StopInterface(iface);
                 stopped++;
             }
             catch (Exception e) {