public async Task SaveAndGetEventsInChunks() { Random random = new Random(); Guid id = random.NextGuid(); PseudoAggregateRoot aggregateRoot = PseudoAggregateRoot.Create(id, "my name"); Int32 amount = 10_000; for (int i = 0; i < amount; i++) { aggregateRoot.ChangeName($"iteration {i}"); } var settings = EventStoreClientSettings.Create("esdb://127.0.0.1:2113?tls=false"); var client = new EventStoreClient(settings); String prefix = random.GetAlphanumericString(); EventStoreBasedStore store = new(new EventStoreBasedStoreConnenctionOptions(client, prefix)); try { await store.Save(aggregateRoot); var events = await store.GetEvents <PseudoAggregateRoot>(id, 10); Assert.Equal(amount + 1, events.Count()); Assert.Equal($"iteration {amount - 1}", ((PseudoAggregateRootNameChangedEvent)events.Last()).SecondName); } finally { await EventStoreClientDisposer.CleanUp(prefix, settings); } }
public async Task LifeCylce() { Random random = new Random(); String firstname = random.GetAlphanumericString(); String secondName = random.GetAlphanumericString(); Guid id = random.NextGuid(); PseudoAggregateRoot aggregateRoot = PseudoAggregateRoot.Create(id, firstname); aggregateRoot.ChangeName(secondName); var settings = EventStoreClientSettings.Create("esdb://127.0.0.1:2113?tls=false"); var client = new EventStoreClient(settings); String prefix = random.GetAlphanumericString(); EventStoreBasedStore store = new EventStoreBasedStore(new EventStoreBasedStoreConnenctionOptions(client, prefix)); try { Boolean firstExistResult = await store.CheckIfAggrerootExists <PseudoAggregateRoot>(id); Assert.False(firstExistResult); Boolean saveResult = await store.Save(aggregateRoot); Assert.True(saveResult); Boolean secondExistResult = await store.CheckIfAggrerootExists <PseudoAggregateRoot>(id); Assert.True(secondExistResult); var hydratedVersion = new PseudoAggregateRoot(id); await store.HydrateAggragate(hydratedVersion); Assert.Equal(firstname, hydratedVersion.InitialName); Assert.Equal(secondName, hydratedVersion.SecondName); Boolean deleteResult = await store.DeleteAggregateRoot <PseudoAggregateRoot>(id); Assert.True(deleteResult); Boolean thirdExistResult = await store.CheckIfAggrerootExists <PseudoAggregateRoot>(id); Assert.False(thirdExistResult); } finally { await EventStoreClientDisposer.CleanUp(prefix, settings); } }
private async Task ExecuteWithStreamErase(Random random, Func <EventStoreBasedStore, Task> executor) { String prefix = random.GetAlphanumericString(); var settings = EventStoreClientSettings.Create("esdb://127.0.0.1:2113?tls=false"); try { var client = new EventStoreClient(settings); EventStoreBasedStore store = new EventStoreBasedStore(new EventStoreBasedStoreConnenctionOptions(client, prefix)); await executor(store); } finally { await EventStoreClientDisposer.CleanUp(prefix, settings); } }
//[Fact] public async Task SendAndReceive() { Random random = new Random(); String dbName = $"mydb-{random.Next()}"; String prefix = random.GetAlphanumericString(); try { UInt32 enterpriseNumber = (UInt32)random.Next(); StorageContext initicalContext = DatabaseTestingUtility.GetTestDatabaseContext(dbName); await initicalContext.Database.MigrateAsync(); await initicalContext.SaveInitialServerConfiguration(new DHCPv6ServerProperties { ServerDuid = new UUIDDUID(new Guid()) }); initicalContext.Dispose(); IPv6Address expectedAdress = IPv6Address.FromString("fe80::0"); var services = new ServiceCollection(); services.AddScoped <ServiceFactory>(p => p.GetService); services.AddSingleton <DHCPv6RootScope>(sp => { var storageEngine = sp.GetRequiredService <IDHCPv6StorageEngine>(); var scope = storageEngine.GetRootScope().GetAwaiter().GetResult(); return(scope); }); services.AddTransient <IDHCPv6ServerPropertiesResolver, DatabaseDHCPv6ServerPropertiesResolver>(); services.AddSingleton <ISerializer, JSONBasedSerializer>(); services.AddSingleton <IScopeResolverManager <DHCPv6Packet, IPv6Address>, DHCPv6ScopeResolverManager>(); services.AddSingleton <IServiceBus, MediaRBasedServiceBus>(); services.AddSingleton <IDHCPv6PacketFilterEngine, SimpleDHCPv6PacketFilterEngine>(); services.AddSingleton <IDHCPv6InterfaceEngine, DHCPv6InterfaceEngine>(); services.AddSingleton <IDHCPv6LeaseEngine, DHCPv6LeaseEngine>(); services.AddSingleton <IDHCPv6StorageEngine, DHCPv6StorageEngine>(); services.AddSingleton <IDHCPv6ReadStore, StorageContext>(); services.AddSingleton(new EventStoreBasedStoreConnenctionOptions(new EventStoreClient(EventStoreClientSettings.Create("esdb://127.0.0.1:2113?tls=false")), prefix)); services.AddSingleton <IDHCPv6EventStore, EventStoreBasedStore>(); services.AddSingleton(DatabaseTestingUtility.GetTestDbContextOptions(dbName)); services.AddTransient <INotificationHandler <DHCPv6PacketArrivedMessage> >(sp => new DHCPv6PacketArrivedMessageHandler( sp.GetRequiredService <IServiceBus>(), sp.GetRequiredService <IDHCPv6PacketFilterEngine>(), sp.GetService <ILogger <DHCPv6PacketArrivedMessageHandler> >())); services.AddTransient <INotificationHandler <ValidDHCPv6PacketArrivedMessage> >(sp => new ValidDHCPv6PacketArrivedMessageHandler( sp.GetRequiredService <IServiceBus>(), sp.GetRequiredService <IDHCPv6LeaseEngine>(), sp.GetService <ILogger <ValidDHCPv6PacketArrivedMessageHandler> >())); services.AddTransient <INotificationHandler <DHCPv6PacketReadyToSendMessage> >(sp => new DHCPv6PacketReadyToSendMessageHandler( sp.GetRequiredService <IDHCPv6InterfaceEngine>(), sp.GetService <ILogger <DHCPv6PacketReadyToSendMessageHandler> >())); services.AddTransient <DHCPv6RateLimitBasedFilter>(); services.AddTransient <DHCPv6PacketConsistencyFilter>(); services.AddTransient <DHCPv6PacketServerIdentifierFilter>((sp) => new DHCPv6PacketServerIdentifierFilter( new UUIDDUID(new Guid()), sp.GetService <ILogger <DHCPv6PacketServerIdentifierFilter> >())); services.AddLogging(); var provider = services.BuildServiceProvider(); DHCPv6RootScope initialRootScope = provider.GetService <DHCPv6RootScope>(); initialRootScope.AddScope(new DHCPv6ScopeCreateInstruction { AddressProperties = new DHCPv6ScopeAddressProperties( IPv6Address.FromString("fe80::0"), IPv6Address.FromString("fe80::ff"), new List <IPv6Address> { IPv6Address.FromString("fe80::1") }, preferredLifeTime: TimeSpan.FromDays(0.5), validLifeTime: TimeSpan.FromDays(1), rapitCommitEnabled: true, informsAreAllowd: true, supportDirectUnicast: true, reuseAddressIfPossible: false, acceptDecline: true, t1: DHCPv6TimeScale.FromDouble(0.6), t2: DHCPv6TimeScale.FromDouble(0.8), addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next), ScopeProperties = DHCPv6ScopeProperties.Empty, ResolverInformation = new CreateScopeResolverInformation { Typename = nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver), PropertiesAndValues = new Dictionary <String, String> { { nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver.EnterpriseNumber), enterpriseNumber.ToString() }, { nameof(DHCPv6RemoteIdentifierEnterpriseNumberResolver.RelayAgentIndex), 0.ToString() }, } }, Name = "Testscope", Id = Guid.NewGuid(), }); IDHCPv6PacketFilterEngine packetFilterEngine = provider.GetService <IDHCPv6PacketFilterEngine>(); packetFilterEngine.AddFilter(provider.GetService <DHCPv6RateLimitBasedFilter>()); packetFilterEngine.AddFilter(provider.GetService <DHCPv6PacketConsistencyFilter>()); packetFilterEngine.AddFilter(provider.GetService <DHCPv6PacketServerIdentifierFilter>()); IDHCPv6InterfaceEngine interfaceEngine = provider.GetService <IDHCPv6InterfaceEngine>(); var possibleListener = interfaceEngine.GetPossibleListeners(); var listener = possibleListener.First(); interfaceEngine.OpenListener(listener); IPAddress address = new IPAddress(listener.Address.GetBytes()); IPEndPoint ownEndPoint = new IPEndPoint(address, 546); IPEndPoint serverEndPoint = new IPEndPoint(address, 547); UdpClient client = new UdpClient(ownEndPoint); DHCPv6Packet packet = DHCPv6Packet.AsInner(14, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, new UUIDDUID(Guid.NewGuid())), new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(15, TimeSpan.Zero, TimeSpan.Zero, new List <DHCPv6PacketSuboption>()), }); DHCPv6RelayPacket outerPacket = DHCPv6RelayPacket.AsOuterRelay(new IPv6HeaderInformation(listener.Address, listener.Address), true, 0, IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::2"), new DHCPv6PacketOption[] { new DHCPv6PacketRemoteIdentifierOption(enterpriseNumber, new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }), }, packet); byte[] packetStream = outerPacket.GetAsStream(); await client.SendAsync(packetStream, packetStream.Length, serverEndPoint); await Task.Delay(2000); var content = await client.ReceiveAsync(); Byte[] receivedBytes = content.Buffer; DHCPv6Packet response = DHCPv6Packet.FromByteArray(receivedBytes, new IPv6HeaderInformation(listener.Address, listener.Address)); var iaOption = response.GetInnerPacket().GetNonTemporaryIdentiyAssocation(15); Assert.NotNull(iaOption); Assert.Single(iaOption.Suboptions); Assert.IsAssignableFrom <DHCPv6PacketIdentityAssociationAddressSuboption>(iaOption.Suboptions.First()); Assert.Equal(expectedAdress, ((DHCPv6PacketIdentityAssociationAddressSuboption)iaOption.Suboptions.First()).Address); } finally { await DatabaseTestingUtility.DeleteDatabase(dbName); await EventStoreClientDisposer.CleanUp(prefix, null); } }
public async Task FullCycle() { Random random = new Random(); String dbName = $"{random.Next()}"; String eventStorePrefix = random.GetAlphanumericString(); var serviceInteractions = GetTestClient(dbName, eventStorePrefix); Guid scopeId = Guid.Parse("7ec8da2e-73a8-4205-9dd8-9bde4be5434a"); try { var firstResponse = await serviceInteractions.Client.PostAsync("/api/notifications/pipelines/", GetContent(new { name = "my first pipeline", description = "my first pipeline description", triggerName = "PrefixEdgeRouterBindingUpdatedTrigger", condtionName = "DHCPv6ScopeIdNotificationCondition", conditionProperties = new Dictionary <String, String> { { "includesChildren", JsonConvert.SerializeObject(true) }, { "scopeIds", JsonConvert.SerializeObject(new[] { scopeId }) } }, actorName = "NxOsStaticRouteUpdaterNotificationActor", actorProperties = new Dictionary <String, String> { { "url", "https://192.168.1.1" }, { "username", "5353535" }, { "password", "36363636" } }, })); Guid firstId = await IsObjectResult <Guid>(firstResponse); Assert.NotEqual(Guid.Empty, firstId); var secondResponse = await serviceInteractions.Client.PostAsync("/api/notifications/pipelines/", GetContent(new { name = "my second pipeline", description = "my second pipeline description", triggerName = "PrefixEdgeRouterBindingUpdatedTrigger", condtionName = "DHCPv6ScopeIdNotificationCondition", conditionProperties = new Dictionary <String, String> { { "includesChildren", JsonConvert.SerializeObject(true) }, { "scopeIds", JsonConvert.SerializeObject(new[] { scopeId }) } }, actorName = "NxOsStaticRouteUpdaterNotificationActor", actorProperties = new Dictionary <String, String> { { "url", "https://192.168.1.1" }, { "username", "5353535" }, { "password", "36363636" } }, })); Guid secondId = await IsObjectResult <Guid>(secondResponse); Assert.NotEqual(Guid.Empty, secondId); var thirdresponse = await serviceInteractions.Client.DeleteAsync($"/api/notifications/pipelines/{firstId}"); await IsEmptyResult(thirdresponse); serviceInteractions.Client.Dispose(); serviceInteractions = GetTestClient(dbName, eventStorePrefix); var resultResponse = await serviceInteractions.Client.GetAsync("/api/notifications/pipelines/"); var result = await IsObjectResult <IEnumerable <NotificationPipelineReadModel> >(resultResponse); Assert.Single(result); Assert.Equal(secondId, result.First().Id); var newPrefix = new PrefixBinding(IPv6Address.FromString("fe80:1000::"), new IPv6SubnetMaskIdentifier(32), IPv6Address.FromString("fe80::2")); var actorServiceMock = serviceInteractions.ActorServiceMock; Int32 actorFired = 0;; actorServiceMock.Setup(x => x.Connect("https://192.168.1.1", "5353535", "36363636")).ReturnsAsync(true).Verifiable(); actorServiceMock.Setup(x => x.AddIPv6StaticRoute(newPrefix.Prefix, newPrefix.Mask.Identifier, newPrefix.Host)).ReturnsAsync(true).Callback(() => actorFired++).Verifiable(); await serviceInteractions.ServiceBus.Publish(new NewTriggerHappendMessage(new[] { PrefixEdgeRouterBindingUpdatedTrigger.WithNewBinding(scopeId, newPrefix) })); Int32 triesLeft = 10; while (triesLeft-- > 0) { await Task.Delay(1000); if (actorFired > 0) { break; } } actorServiceMock.Verify(); } finally { await EventStoreClientDisposer.CleanUp(eventStorePrefix, null); await DatabaseTestingUtility.DeleteDatabase(dbName); } }
public async Task SendAndReceive() { Random random = new Random(); String dbName = $"{random.Next()}"; String eventStorePrefix = random.GetAlphanumericString(); var serviceInteractions = GetTestClient(dbName, eventStorePrefix); Byte[] opt82Value = random.NextBytes(10); try { //Get and Add Interface var interfacesResult = await serviceInteractions.GetAsync("/api/interfaces/dhcpv4/"); var interfaces = await IsObjectResult <DHCPv4InterfaceOverview>(interfacesResult); DHCPv4InterfaceEntry usedInterface = null; foreach (var item in interfaces.Entries) { try { var createInterfaceResult = await serviceInteractions.PostAsync("/api/interfaces/dhcpv4/", GetContent(new { name = "my test interface", ipv4Address = item.IPv4Address, interfaceId = item.PhysicalInterfaceId })); Guid interfaceDaAPIId = await IsObjectResult <Guid>(createInterfaceResult); Assert.NotEqual(Guid.Empty, interfaceDaAPIId); usedInterface = item; break; } catch (Exception) { continue; } } Assert.NotNull(usedInterface); var interfaceAddress = IPv4Address.FromString(usedInterface.IPv4Address); //Create scope var createScopeResult = await serviceInteractions.PostAsync("/api/scopes/dhcpv4/", GetContent(new { name = "Testscope", id = Guid.NewGuid(), addressProperties = new { start = "192.168.10.1", end = "192.168.10.254", excludedAddresses = new[] { "192.168.10.1" }, preferredLifetime = TimeSpan.FromDays(0.8), leaseTime = TimeSpan.FromDays(1), renewalTime = TimeSpan.FromDays(0.5), maskLength = 24, supportDirectUnicast = true, acceptDecline = true, informsAreAllowd = true, reuseAddressIfPossible = true, addressAllocationStrategy = Beer.DaAPI.Shared.Requests.DHCPv4ScopeRequests.V1.DHCPv4ScopeAddressPropertyReqest.AddressAllocationStrategies.Next }, resolver = new { typename = nameof(DHCPv4Option82Resolver), propertiesAndValues = new Dictionary <String, String> { { nameof(DHCPv4Option82Resolver.Value), System.Text.Json.JsonSerializer.Serialize(opt82Value) }, } } })); Guid scopeId = await IsObjectResult <Guid>(createScopeResult); Assert.NotEqual(Guid.Empty, scopeId); IPAddress address = new IPAddress(interfaceAddress.GetBytes()); IPEndPoint ownEndPoint = new IPEndPoint(address, 68); IPEndPoint serverEndPoint = new IPEndPoint(address, 67); UdpClient client = new UdpClient(ownEndPoint); IPv4HeaderInformation headerInformation = new IPv4HeaderInformation(IPv4Address.FromString(address.ToString()), IPv4Address.Broadcast); DHCPv4Packet discoverPacket = new DHCPv4Packet( headerInformation, random.NextBytes(6), (UInt32)random.Next(), IPv4Address.Empty, IPv4Address.Empty, IPv4Address.Empty, DHCPv4PacketFlags.Broadcast, new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Discover), new DHCPv4PacketRawByteOption(82, opt82Value), new DHCPv4PacketClientIdentifierOption(DHCPv4ClientIdentifier.FromIdentifierValue("my custom client"))); byte[] discoverPacketStream = discoverPacket.GetAsStream(); await client.SendAsync(discoverPacketStream, discoverPacketStream.Length, serverEndPoint); await Task.Delay(2000); var content = await client.ReceiveAsync(); Byte[] receivedBytes = content.Buffer; DHCPv4Packet response = DHCPv4Packet.FromByteArray(receivedBytes, new IPv4HeaderInformation(interfaceAddress, interfaceAddress)); Assert.NotNull(response); Assert.True(response.IsValid); var serverIdentifierOption = response.GetOptionByIdentifier(DHCPv4OptionTypes.ServerIdentifier) as DHCPv4PacketAddressOption; Assert.NotNull(serverIdentifierOption); Assert.Equal(interfaceAddress, serverIdentifierOption.Address); var subnetOption = response.GetOptionByIdentifier(DHCPv4OptionTypes.SubnetMask) as DHCPv4PacketAddressOption; Assert.NotNull(subnetOption); Assert.Equal(IPv4Address.FromString("255.255.255.0"), subnetOption.Address); var clientIdentifierOption = response.GetOptionByIdentifier(DHCPv4OptionTypes.ClientIdentifier) as DHCPv4PacketClientIdentifierOption; Assert.NotNull(clientIdentifierOption); Assert.Equal("my custom client", clientIdentifierOption.Identifier.IdentifierValue); Assert.Equal(DUID.Empty, clientIdentifierOption.Identifier.DUID); Assert.Equal((UInt32)0, clientIdentifierOption.Identifier.IaId); Assert.Empty(clientIdentifierOption.Identifier.HwAddress); var incoming82Option = response.GetOptionByIdentifier(DHCPv4OptionTypes.Option82) as DHCPv4PacketRawByteOption; Assert.NotNull(incoming82Option); Assert.Equal(opt82Value, incoming82Option.OptionData); } finally { await EventStoreClientDisposer.CleanUp(eventStorePrefix, null); await DatabaseTestingUtility.DeleteDatabase(dbName); } }