public VpnTrayTabViewModel(VpnProvider vpnProvider, IVpnTrayConfigurationProvider configurationProvider)
{
_vpnProvider = vpnProvider;
_configurationProvider = configurationProvider;
Settings = new ObservableCollection <VpnTraySettingsEntryViewModel>();
Icons = new ObservableCollection <VpnTrayIconViewModel>();
vpnProvider.VpnEnumerator.Vpns.Clear();
if (!configurationProvider.Configuration.Entries.TryGetValue(vpnProvider.Name, out var entries))
{
configurationProvider.Configuration.Entries[vpnProvider.Name] = entries = new List <VpnTraySettingsEntryConfiguration>();
configurationProvider.Save();
}
foreach (var entry in entries)
{
var vpn = new Vpn(entry.Id, entry.Name);
vpnProvider.VpnEnumerator.Vpns.Add(vpn);
var vm = new VpnTraySettingsEntryViewModel(vpnProvider.VpnManagerFactory.Create(vpn), entry);
vm.PropertyChanged += Entry_PropertyChanged;
Settings.Add(vm);
if (vm.IsSelected)
{
Icons.Add(new VpnTrayIconViewModel(vm.VpnManager));
}
}
vpnProvider.VpnEnumerator.Added += (s, e) => AddManager(e.Vpn);
vpnProvider.VpnEnumerator.Removed += (s, e) => RemoveManager(e.Vpn);
vpnProvider.VpnEnumerator.RefreshInterval = configurationProvider.Configuration.EnumeratorRefreshInterval;
vpnProvider.VpnEnumerator.IsEnabled = true;
}
public async Task Refresh_ShouldCallDriverGetStatus()
{
// ARRANGE
var vpn = new Vpn("ID1", "VPN1");
var driver = Substitute.For <IVpnMonitorDriver>();
driver.GetStatus(default).ReturnsForAnyArgs(Task.FromResult(VpnStatus.Disconnected));
public void Create(Vpn vpn)
{
if (vpn == null)
{
throw new ArgumentNullException(nameof(vpn));
}
_ctx.Vpns.Add(vpn);
SaveChanges();
}
public void Constructor_ShouldNotThrowException_WhenArgumentsAreNotNull()
{
// ARRANGE
var vpn = new Vpn("MockId", "MockName");
var driver = Substitute.For <IVpnConnectorDriver>();
// ACT
Action action = () => new VpnConnector(vpn, driver);
// ASSERT
action.Should().NotThrow();
}
public void Constructor_ShouldThrowArgumentNullException_WhenVpnConnectorDriverIsNull()
{
// ARRANGE
Vpn vpn = new Vpn("MockId", "MockName");
IVpnConnectorDriver driver = null;
// ACT
Action action = () => new VpnConnector(vpn, driver);
// ASSERT
action.Should().Throw <ArgumentNullException>().Where(e => e.ParamName == "vpnConnectorDriver");
}
public void Constructor_ShouldThrowArgumentNullException_WhenVpnIsNull()
{
// ARRANGE
Vpn vpn = null;
IVpnConnectorDriver driver = Substitute.For <IVpnConnectorDriver>();
// ACT
Action action = () => new VpnConnector(vpn, driver);
// ASSERT
action.Should().Throw <ArgumentNullException>().Where(e => e.ParamName == "vpn");
}
public void Constructor_ShouldThrowArgumentNullException_WhenDriverIsNull()
{
// ARRANGE
var vpn = new Vpn("ID1", "VPN1");
IVpnMonitorDriver driver = null;
// ACT
Action action = () => new VpnMonitor(vpn, driver);
// ASSERT
action.Should().Throw <ArgumentNullException>().Where(e => e.ParamName == "vpnMonitorDriver");
}
public async Task Disconnect_ShouldCallDriverDisconnectWithVpnId()
{
// ARRANGE
var vpn = new Vpn("MockId", "MockName");
var driver = Substitute.For <IVpnConnectorDriver>();
var sut = new VpnConnector(vpn, driver);
// ACT
await sut.Disconnect();
// ASSERT
await driver.Received().Disconnect(Arg.Is(vpn.Id));
}
private static bool HasValidAndEnabledRoutes(bool addRoutes, Vpn vpn, out Route[] validAndEnabledRoutes)
{
bool result;
validAndEnabledRoutes = vpn.Routes != null?vpn.Routes.Where(route => route.IsValid && route.IsEnabled).ToArray() : null;
result = validAndEnabledRoutes != null && validAndEnabledRoutes.Any();
if (!result)
{
Logger.Instance.Log(LogLevel.Info, "No routes will be {0} for \"{1}\" because no valid and enabled routes have been configured.", addRoutes ? "added" : "deleted", vpn.Name);
}
return(result);
}
private async Task InitializeAfterFirstPatchAsync()
{
_resourceService.Start();
Targets.Start();
Sources.Start();
SceneEditing.Start();
StreamSettings.Start();
await Vpn.StartAsync();
Streamer.Start();
Settings.Start();
About.Start();
_stateLoggerService.Start();
Audio.Start();
}
private void RemoveManager(Vpn vpn)
{
var settingsEntry = Settings.FirstOrDefault(s => s.VpnManager.Vpn.Id == vpn.Id);
if (settingsEntry == null)
{
return;
}
settingsEntry.IsSelected = false;
settingsEntry.PropertyChanged -= Entry_PropertyChanged;
Settings.Remove(settingsEntry);
_configurationProvider.Configuration.Entries[_vpnProvider.Name].RemoveAll(e => e.Id == vpn.Id);
_configurationProvider.Save();
}
private void AddManager(Vpn vpn)
{
var configuration = new VpnTraySettingsEntryConfiguration
{
Id = vpn.Id,
Name = vpn.Name,
IsSelected = false,
RefreshInterval = _configurationProvider.Configuration.DefaultMonitorRefreshInterval
};
_configurationProvider.Configuration.Entries[_vpnProvider.Name].Add(configuration);
_configurationProvider.Save();
var entry = new VpnTraySettingsEntryViewModel(_vpnProvider.VpnManagerFactory.Create(vpn), configuration);
entry.PropertyChanged += Entry_PropertyChanged;
Settings.Add(entry);
}
private static void ProcessRoutes(bool isConnected, RasConnectionEventArgs connectionEventInfo)
{
if (connectionEventInfo.Connection.Device.DeviceType == RasDeviceType.Vpn)
{
string gatewayIpAddress;
if (isConnected)
{
gatewayIpAddress = ((RasIPInfo)connectionEventInfo.Connection.GetProjectionInfo(RasProjectionType.IP)).IPAddress.ToString();
Logger.Instance.Log(LogLevel.Info, "Connected to \"{0}\". Client IP: {1}.", connectionEventInfo.Connection.EntryName, gatewayIpAddress);
}
else
{
gatewayIpAddress = null;
Logger.Instance.Log(LogLevel.Info, "Disconnected from \"{0}\".", connectionEventInfo.Connection.EntryName);
}
Vpn configuredVpn = ConfigurationManager.Configuration.Vpns.SingleOrDefault(vpn => !vpn.IsOnlyTriggeredManually && vpn.IsValid && vpn.Name.Equals(connectionEventInfo.Connection.EntryName, StringComparison.OrdinalIgnoreCase));
if (configuredVpn != null)
{
if (configuredVpn.IsEnabled)
{
Route[] validAndEnabledRoutes;
if (HasValidAndEnabledRoutes(isConnected, configuredVpn, out validAndEnabledRoutes))
{
ProcessRoutes(isConnected, connectionEventInfo.Connection.EntryName, validAndEnabledRoutes, gatewayIpAddress);
}
}
else
{
Logger.Instance.Log(LogLevel.Info, "No routes will be {0} for \"{1}\" because it is not enabled.", isConnected ? "added" : "deleted", connectionEventInfo.Connection.EntryName);
}
}
else
{
Logger.Instance.Log(LogLevel.Info, "No routes will be {0} for \"{1}\" because it has not been configured.", isConnected ? "added" : "deleted", connectionEventInfo.Connection.EntryName);
}
}
}
private void SetVpnIndicators(bool setOverlay = false)
{
if (Vpn.IsActive())
{
FlashWindow.Start(this);
// this.Icon = Properties.Resources.vpn;
this.label_vpn_status.Text = "Connected to VPN: " + Vpn.Name();
this.disconnect_button.Visible = true;
this.ShowInTaskbar = true;
if (setOverlay)
{
TaskbarManager.Instance.SetOverlayIcon(Properties.Resources.vpn, "VPN");
}
}
else
{
FlashWindow.Stop(this);
this.ShowInTaskbar = false;
this.label_vpn_status.Text = "Not connected to a VPN currently";
this.disconnect_button.Visible = false;
}
}
public async Task ShouldNotDisconnect_WhenDisconnectOnLockEnabledAndNotConnected()
{
// ARRANGE
var id = "vpn1";
var vpn = new Vpn(id, "VPN 1");
var vpnConnectorDriver = Substitute.For <IVpnConnectorDriver>();
var vpnMonitorDriver = Substitute.For <IVpnMonitorDriver>();
vpnMonitorDriver.GetStatus(id).Returns(Task.FromResult(VpnStatus.Disconnected));
var systemEventsProvider = Substitute.For <ISystemEventsProvider>();
var sut = new VpnManager(vpn, vpnConnectorDriver, vpnMonitorDriver, systemEventsProvider)
{
DisconnectOnLock = true
};
await sut.Monitor.Refresh();
// ACT
systemEventsProvider.SessionLock += Raise.Event();
// ASSERT
await vpnConnectorDriver.DidNotReceive().Disconnect(Arg.Is(id));
}
private void disconnect_button_Click(object sender, EventArgs e)
{
Vpn.Disconnect();
}
public void Delete(Vpn vpn)
{
_ctx.Vpns.Remove(vpn);
SaveChanges();
}
public void Update(Vpn vpn)
{
_ctx.Vpns.Update(vpn);
SaveChanges();
}
public void Validate()
{
Provisioner = Provisioner ?? defaultProvisioner;
DrivePrefix = DrivePrefix ?? defaultDrivePrefix;
Setup = Setup ?? new SetupOptions();
Hosting = Hosting ?? new HostingOptions();
Vpn = Vpn ?? new VpnOptions();
HiveNode = HiveNode ?? new HiveNodeOptions();
Docker = Docker ?? new DockerOptions();
Image = Image ?? new ImageOptions();
Network = Network ?? new NetworkOptions();
Consul = Consul ?? new ConsulOptions();
Vault = Vault ?? new VaultOptions();
Log = Log ?? new LogOptions();
Dashboard = Dashboard ?? new DashboardOptions();
HiveFS = HiveFS ?? new HiveFSOptions();
Proxy = Proxy ?? new ProxyOptions();
HiveMQ = HiveMQ ?? new HiveMQOptions();
Setup.Validate(this);
Network.Validate(this);
Hosting.Validate(this);
Vpn.Validate(this);
HiveNode.Validate(this);
Docker.Validate(this);
Image.Validate(this);
Consul.Validate(this);
Vault.Validate(this);
Log.Validate(this);
Dashboard.Validate(this);
HiveFS.Validate(this);
Proxy.Validate(this);
HiveMQ.Validate(this);
new HostingManagerFactory().Validate(this);
if (TimeSources == null || TimeSources.Length == 0 || TimeSources.Count(ts => string.IsNullOrWhiteSpace(ts)) > 0)
{
TimeSources = new string[] { "pool.ntp.org" };
}
if (NodeDefinitions == null || NodeDefinitions.Count == 0)
{
throw new HiveDefinitionException("At least one hive node must be defined.");
}
foreach (var node in NodeDefinitions.Values)
{
node.Validate(this);
}
if (Name == null)
{
throw new HiveDefinitionException($"The [{nameof(HiveDefinition)}.{nameof(Name)}] property is required.");
}
if (!IsValidName(Name))
{
throw new HiveDefinitionException($"The [{nameof(HiveDefinition)}.{nameof(Name)}={Name}] property is not valid. Only letters, numbers, periods, dashes, and underscores are allowed.");
}
if (Datacenter == null)
{
throw new HiveDefinitionException($"The [{nameof(HiveDefinition)}.{nameof(Datacenter)}] property is required.");
}
if (!IsValidName(Datacenter))
{
throw new HiveDefinitionException($"The [{nameof(HiveDefinition)}.{nameof(Datacenter)}={Datacenter}] property is not valid. Only letters, numbers, periods, dashes, and underscores are allowed.");
}
if (!string.IsNullOrEmpty(PackageProxy))
{
var packageCacheUris = PackageProxy.Split(',');
for (int i = 0; i < packageCacheUris.Length; i++)
{
packageCacheUris[i] = packageCacheUris[i].Trim();
if (!Uri.TryCreate(packageCacheUris[i], UriKind.Absolute, out var aptProxyUri))
{
throw new HiveDefinitionException($"The [{nameof(HiveDefinition)}.{nameof(PackageProxy)}={PackageProxy}] includes [{packageCacheUris[i]}] which is not a valid URI.");
}
if (aptProxyUri.Scheme != "http")
{
throw new HiveDefinitionException($"The [{nameof(HiveDefinition)}.{nameof(PackageProxy)}={PackageProxy}] includes [{packageCacheUris[i]}] which does not have the [http] scheme.");
}
}
}
var managementNodeCount = Managers.Count();
if (managementNodeCount == 0)
{
throw new HiveDefinitionException("Hives must have at least one management node.");
}
else if (managementNodeCount > 5)
{
throw new HiveDefinitionException("Hives may not have more than [5] management nodes.");
}
else if (!NeonHelper.IsOdd(managementNodeCount))
{
throw new HiveDefinitionException("Hives must have an odd number of management nodes: [1, 3, or 5]");
}
// Ensure that each node has a valid unique or NULL IP address.
NetworkCidr nodesSubnet = null;
NetworkCidr vpnPoolSubnet = null;
if (Network.NodesSubnet != null)
{
nodesSubnet = NetworkCidr.Parse(Network.NodesSubnet);
}
if (Vpn.Enabled)
{
vpnPoolSubnet = NetworkCidr.Parse(Network.VpnPoolSubnet);
}
var addressToNode = new Dictionary <string, NodeDefinition>();
foreach (var node in SortedNodes)
{
if (node.PrivateAddress != null)
{
NodeDefinition conflictNode;
if (addressToNode.TryGetValue(node.PrivateAddress, out conflictNode))
{
throw new HiveDefinitionException($"Node [name={node.Name}] has invalid private IP address [{node.PrivateAddress}] that conflicts with node [name={conflictNode.Name}].");
}
}
}
foreach (var node in SortedNodes)
{
if (node.PrivateAddress != null)
{
if (!IPAddress.TryParse(node.PrivateAddress, out var address))
{
throw new HiveDefinitionException($"Node [name={node.Name}] has invalid private IP address [{node.PrivateAddress}].");
}
if (vpnPoolSubnet != null && vpnPoolSubnet.Contains(address))
{
throw new HiveDefinitionException($"Node [name={node.Name}] has private IP address [{node.PrivateAddress}] within the hosting [{nameof(Network.VpnPoolSubnet)}={Network.VpnPoolSubnet}].");
}
if (nodesSubnet != null && !nodesSubnet.Contains(address))
{
throw new HiveDefinitionException($"Node [name={node.Name}] has private IP address [{node.PrivateAddress}] that is not within the hosting [{nameof(Network.NodesSubnet)}={Network.NodesSubnet}].");
}
}
else if (!Hosting.IsCloudProvider)
{
throw new HiveDefinitionException($"Node [name={node.Name}] is not assigned a private IP address. This is required when deploying to a [{nameof(Environment)}={Environment}] hosting environment.");
}
}
// Verify that we have nodes identified for persisting log data if logging is enabled.
if (Log.Enabled)
{
if (Nodes.Where(n => n.Labels.LogEsData).Count() == 0)
{
throw new HiveDefinitionException($"At least one node must be configured to store log data by setting [{nameof(NodeDefinition.Labels)}.{nameof(NodeLabels.LogEsData)}=true] when hive logging is enabled.");
}
}
}
private static bool HasValidAndEnabledRoutes(Vpn vpn)
{
return(vpn.Routes != null && vpn.Routes.Any(route => route.IsValid && route.IsEnabled));
}
public IpAddressInputForm(Vpn vpn)
{
_vpn = vpn;
InitializeComponent();
}
public void Init()
{
instance = new Vpn();
}
public VpnViewModel(Vpn vpn, LocationViewModel parentLocation)
: base(parentLocation, false)
{
_vpn = vpn;
}
