public IEnumerable <DHCPv6Listener> GetPossibleListeners()
{
List <DHCPv6Listener> result = new List <DHCPv6Listener>();
foreach (var nic in NetworkInterface.GetAllNetworkInterfaces())
{
var properites = nic.GetIPProperties();
if (properites == null)
{
continue;
}
foreach (var ipAddress in properites.UnicastAddresses)
{
if (ipAddress.Address.AddressFamily != System.Net.Sockets.AddressFamily.InterNetworkV6)
{
continue;
}
if (ipAddress.Address.IsIPv6LinkLocal == true)
{
continue;
}
DHCPv6Listener listener = DHCPv6Listener.FromNIC(nic, ipAddress.Address);
result.Add(listener);
}
}
return(result);
}
public async Task <Guid?> Handle(CreateDHCPv6InterfaceListenerCommand request, CancellationToken cancellationToken)
{
_logger.LogDebug("Handle started");
DHCPv6Listener listener = DHCPv6Listener.Create(
request.NicId,
DHCPListenerName.FromString(request.Name),
IPv6Address.FromString(request.IPv6Addres));
var possibleListeners = _interfaceEngine.GetPossibleListeners();
if (possibleListeners.Count(x => x.Address == listener.Address && x.PhysicalInterfaceId == listener.PhysicalInterfaceId) == 0)
{
return(null);
}
var activeListeners = await _interfaceEngine.GetActiveListeners();
if (activeListeners.Count(x => x.Address == listener.Address && x.PhysicalInterfaceId == listener.PhysicalInterfaceId) > 0)
{
return(null);
}
if (await _storageEngine.Save(listener) == false)
{
return(null);
}
_interfaceEngine.OpenListener(listener);
return(listener.Id);
}
public void FromNIC()
{
foreach (var nic in NetworkInterface.GetAllNetworkInterfaces())
{
var properites = nic.GetIPProperties();
if (properites == null)
{
continue;
}
foreach (var ipAddress in properites.UnicastAddresses)
{
if (ipAddress.Address.AddressFamily != System.Net.Sockets.AddressFamily.InterNetworkV6)
{
continue;
}
if (ipAddress.Address.IsIPv6LinkLocal == true)
{
continue;
}
DHCPv6Listener listener = DHCPv6Listener.FromNIC(nic, ipAddress.Address);
Assert.NotNull(listener);
Assert.Equal(nic.GetPhysicalAddress().GetAddressBytes(), listener.PhysicalAddress);
Assert.Equal(nic.Description, listener.Interfacename);
Assert.Equal(nic.Id, listener.PhysicalInterfaceId);
Assert.Equal(ipAddress.Address.GetAddressBytes(), listener.Address.GetBytes());
Assert.True(String.IsNullOrEmpty(listener.Name));
}
}
}
public void Delete()
{
Random random = new Random();
Guid id = random.NextGuid();
DHCPv6Listener listener = new DHCPv6Listener();
listener.Load(new DomainEvent[] {
new DHCPv6ListenerCreatedEvent
{
Id = id,
Address = random.GetIPv6Address().ToString(),
}
});
Assert.False(listener.IsDeleted);
listener.Delete();
Assert.True(listener.IsDeleted);
var @event = GetFirstEvent <DHCPListenerDeletedEvent>(listener);
Assert.Equal(id, @event.Id);
}
public async Task <IEnumerable <DHCPv6Listener> > GetDHCPv6Listener()
{
var result = await DHCPv6Interfaces.AsQueryable()
.OrderBy(x => x.Name).ToListAsync();
List <DHCPv6Listener> listeners = new List <DHCPv6Listener>(result.Count);
foreach (var item in result)
{
DHCPv6Listener listener = new DHCPv6Listener();
listener.Load(new DomainEvent[]
{
new DHCPv6ListenerCreatedEvent {
Id = item.Id,
Name = item.Name,
InterfaceId = item.InterfaceId,
Address = item.IPv6Address,
}
});
listeners.Add(listener);
}
return(listeners);
}
public async Task Handle_Failed_NotSaved()
{
Random random = new Random();
Guid id = random.NextGuid();
DHCPv6Listener listener = new DHCPv6Listener();
listener.Load(new DomainEvent[] {
new DHCPv6ListenerCreatedEvent
{
Id = id,
Address = random.GetIPv6Address().ToString(),
}
});
var command = new DeleteDHCPv6InterfaceListenerCommand(id);
Mock <IDHCPv6StorageEngine> storageMock = new Mock <IDHCPv6StorageEngine>(MockBehavior.Strict);
storageMock.Setup(x => x.CheckIfAggrerootExists <DHCPv6Listener>(id)).ReturnsAsync(true).Verifiable();
storageMock.Setup(x => x.GetAggregateRoot <DHCPv6Listener>(id)).ReturnsAsync(listener).Verifiable();
storageMock.Setup(x => x.Save(listener)).ReturnsAsync(false).Verifiable();
var handler = new DeleteDHCPv6InterfaceListenerCommandHandler(
Mock.Of <IDHCPv6InterfaceEngine>(MockBehavior.Strict), storageMock.Object, Mock.Of <ILogger <DeleteDHCPv6InterfaceListenerCommandHandler> >());
Boolean actual = await handler.Handle(command, CancellationToken.None);
Assert.False(actual);
storageMock.Verify();
}
public async Task <Boolean> Handle(DeleteDHCPv6InterfaceListenerCommand request, CancellationToken cancellationToken)
{
_logger.LogDebug("Handle started");
if (await _storageEngine.CheckIfAggrerootExists <DHCPv6Listener>(request.Id) == false)
{
return(false);
}
DHCPv6Listener listener = await _storageEngine.GetAggregateRoot <DHCPv6Listener>(request.Id);
listener.Delete();
if (await _storageEngine.Save(listener) == false)
{
return(false);
}
_interfaceEngine.CloseListener(listener);
return(true);
}
public void Create()
{
Random random = new Random();
String interfaceId = random.NextGuid().ToString();
IPv6Address address = random.GetIPv6Address();
String interfaceName = random.GetAlphanumericString();
DHCPv6Listener listener = DHCPv6Listener.Create(interfaceId, DHCPListenerName.FromString(interfaceName), address);
Assert.NotNull(listener);
Assert.NotEqual(Guid.Empty, listener.Id);
Assert.Equal(address, listener.Address);
Assert.Equal(interfaceName, listener.Name);
Assert.Equal(interfaceId, listener.PhysicalInterfaceId);
var @event = GetFirstEvent <DHCPListenerCreatedEvent>(listener);
Assert.Equal(address.ToString(), @event.Address);
Assert.Equal(listener.Id, @event.Id);
Assert.Equal(interfaceId, @event.InterfaceId);
Assert.Equal(interfaceName, @event.Name);
}
