public static async Task WithEventStore()
{
var connectionString = "esdb://localhost:2113?tls=true&tlsVerifyCert=false";
var settings = EventStoreClientSettings.Create(connectionString);
settings.DefaultCredentials = new UserCredentials("admin", "changeit");
var esClient = new EventStoreClient(settings);
var esPersistenSubscriptionClient = new EventStorePersistentSubscriptionsClient(settings);
var projection = await CreateProjection(settings, persistent : true);
Console.ReadLine();
repository = new EventStoreRepository <Counter>(esClient);
for (int i = 0; i < 10; i++)
{
var counterId = Guid.NewGuid(); // Guid.Parse("fbb0f16b-646a-45d3-a1ee-596217897b61");
await CreateAndSaveCounter(counterId);
await LoadAndUpdateCounter(counterId);
}
Console.ReadLine();
projection.Unsubscribe();
}
public StreamPersistentSubscription(
EventStoreClient eventStoreClient,
StreamPersistentSubscriptionOptions options,
IEnumerable <IEventHandler> eventHandlers,
IEventSerializer?eventSerializer = null,
ILoggerFactory?loggerFactory = null,
ISubscriptionGapMeasure?measure = null
) : base(
eventStoreClient,
options,
new NoOpCheckpointStore(),
eventHandlers,
eventSerializer,
loggerFactory,
measure
)
{
Ensure.NotEmptyString(options.Stream, nameof(options.Stream));
var settings = eventStoreClient.GetSettings().Copy();
var opSettings = settings.OperationOptions.Clone();
options.ConfigureOperation?.Invoke(opSettings);
settings.OperationOptions = opSettings;
_subscriptionClient = new EventStorePersistentSubscriptionsClient(settings);
_handleEventProcessingFailure = options.FailureHandler ?? DefaultEventProcessingFailureHandler;
_options = options;
}
public EventStoreService(IOptions <EventStoreSettings> config)
{
var cnn = string.IsNullOrWhiteSpace(config?.Value?.Connection) ? "esdb://localhost:2113?tls=false" : config.Value.Connection;
var settings = EventStoreClientSettings.Create(cnn);
Client = new EventStoreClient(settings);
PersistentSubscription = new EventStorePersistentSubscriptionsClient(settings);
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionWorker"/> class.
/// </summary>
/// <param name="loggerFactory">The logger factory.</param>
/// <param name="env">The env.</param>
/// <param name="domainEventHandlerResolver">The domain event handler resolver.</param>
/// <param name="persistentSubscriptionsClient">The persistent subscriptions client.</param>
/// <param name="httpClient">The HTTP client.</param>
public SubscriptionWorker(IDomainEventHandlerResolver domainEventHandlerResolver,
EventStorePersistentSubscriptionsClient persistentSubscriptionsClient,
HttpClient httpClient)
{
this.DomainEventHandlerResolver = domainEventHandlerResolver;
this.PersistentSubscriptionsClient = persistentSubscriptionsClient;
this.HttpClient = httpClient;
}
public EventStoreFixture()
{
var settings = EventStoreClientSettings
.Create("esdb://localhost:2113?tls=false");
Client = new EventStoreClient(settings);
PersistentSubscription = new EventStorePersistentSubscriptionsClient(settings);
}
public async Task PopulateSubscriptionServiceConfiguration(String estateName)
{
EventStorePersistentSubscriptionsClient client = new EventStorePersistentSubscriptionsClient(ConfigureEventStoreSettings(this.EventStoreHttpPort));
PersistentSubscriptionSettings settings = new PersistentSubscriptionSettings(resolveLinkTos: true, StreamPosition.Start);
await client.CreateAsync(estateName.Replace(" ", ""), "Reporting", settings);
await client.CreateAsync($"EstateManagementSubscriptionStream_{estateName.Replace(" ", "")}", "Estate Management", settings);
}
/// <summary>
/// Initializes a new instance of the <see cref="PersistentSubscription"/> class.
/// </summary>
/// <param name="persistentSubscriptionsClient">The persistent subscriptions client.</param>
/// <param name="persistentSubscriptionDetails">The persistent subscription details.</param>
/// <param name="domainEventHandlerResolver">The domain event handler resolver.</param>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
private PersistentSubscription(EventStorePersistentSubscriptionsClient persistentSubscriptionsClient,
PersistentSubscriptionDetails persistentSubscriptionDetails,
IDomainEventHandlerResolver domainEventHandlerResolver,
String username,
String password)
{
this.PersistentSubscriptionDetails = persistentSubscriptionDetails;
this.PersistentSubscriptionsClient = persistentSubscriptionsClient;
this.DomainEventHandlerResolver = domainEventHandlerResolver;
this.UserCredentials = new UserCredentials(username, password);
}
static async Task DeletePersistentSubscription(EventStorePersistentSubscriptionsClient client)
{
#region delete-persistent-subscription
var userCredentials = new UserCredentials("admin", "changeit");
await client.DeleteAsync(
"test-stream",
"subscription-group",
userCredentials);
#endregion delete-persistent-subscription
}
static async Task Main(string[] args)
{
using var client = new EventStorePersistentSubscriptionsClient(
EventStoreClientSettings.Create("esdb://*****:*****@localhost:2113?TlsVerifyCert=false")
);
await CreatePersistentSubscription(client);
await ConnectToPersistentSubscriptionToStream(client);
await CreatePersistentSubscriptionToAll(client);
await ConnectToPersistentSubscriptionToAll(client);
await ConnectToPersistentSubscriptionWithManualAcks(client);
await UpdatePersistentSubscription(client);
await DeletePersistentSubscription(client);
}
protected async Task PopulateSubscriptionServiceConfiguration()
{
EventStorePersistentSubscriptionsClient client = new EventStorePersistentSubscriptionsClient(ConfigureEventStoreSettings(this.EventStoreHttpPort));
PersistentSubscriptionSettings settings = new PersistentSubscriptionSettings(resolveLinkTos: true);
await client.CreateAsync("$ce-EstateAggregate", "Reporting", settings);
await client.CreateAsync("$ce-MerchantAggregate", "Reporting", settings);
await client.CreateAsync("$ce-ContractAggregate", "Reporting", settings);
await client.CreateAsync("$ce-MerchantBalanceHistory", "Reporting", settings);
}
static async Task ConnectToPersistentSubscriptionToAll(EventStorePersistentSubscriptionsClient client)
{
#region subscribe-to-persistent-subscription-to-all
await client.SubscribeToAllAsync(
"subscription-group",
async (subscription, evnt, retryCount, cancellationToken) => {
await HandleEvent(evnt);
}, (subscription, dropReason, exception) => {
Console.WriteLine($"Subscription was dropped due to {dropReason}. {exception}");
});
#endregion subscribe-to-persistent-subscription-to-all
}
static async Task CreatePersistentSubscription(EventStorePersistentSubscriptionsClient client)
{
#region create-persistent-subscription-to-stream
var userCredentials = new UserCredentials("admin", "changeit");
var settings = new PersistentSubscriptionSettings();
await client.CreateAsync(
"test-stream",
"subscription-group",
settings,
userCredentials);
#endregion create-persistent-subscription-to-stream
}
static async Task CreatePersistentSubscriptionToAll(EventStorePersistentSubscriptionsClient client)
{
#region create-persistent-subscription-to-all
var userCredentials = new UserCredentials("admin", "changeit");
var filter = StreamFilter.Prefix("test");
var settings = new PersistentSubscriptionSettings();
await client.CreateToAllAsync(
"subscription-group",
filter,
settings,
userCredentials);
#endregion create-persistent-subscription-to-all
}
protected PersistentSubscriptionBase(EventStoreClient eventStoreClient, T options, ConsumePipe consumePipe)
: base(eventStoreClient, options, consumePipe)
{
var settings = eventStoreClient.GetSettings().Copy();
var opSettings = settings.OperationOptions.Clone();
settings.OperationOptions = opSettings;
SubscriptionClient = new EventStorePersistentSubscriptionsClient(settings);
_handleEventProcessingFailure = options.FailureHandler ?? DefaultEventProcessingFailureHandler;
if (options.FailureHandler != null && !options.ThrowOnError)
{
Log.ThrowOnErrorIncompatible(SubscriptionId);
}
}
static async Task UpdatePersistentSubscription(EventStorePersistentSubscriptionsClient client)
{
#region update-persistent-subscription
var userCredentials = new UserCredentials("admin", "changeit");
var settings = new PersistentSubscriptionSettings(
resolveLinkTos: true,
minCheckPointCount: 20);
await client.UpdateAsync(
"test-stream",
"subscription-group",
settings,
userCredentials);
#endregion update-persistent-subscription
}
private static EventStorePersistentSubscriptionsClient CreateEventStorePersistentSubscriptionsClient(UserCredentials userCredentials)
{
var settings = new EventStoreClientSettings
{
ConnectivitySettings = new EventStoreClientConnectivitySettings
{
/*
* Note: gRPC uses the https and thus needs to use port 2113 (same as admin UI),
* instead of 1113 as the tcp client uses.
*/
Address = new Uri("https://localhost:2113/")
},
DefaultCredentials = userCredentials
};
var client = new EventStorePersistentSubscriptionsClient(settings);
return(client);
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
Console.Title = "Messaging Service";
//At this stage, we only need our hosting file for ip and ports
IConfigurationRoot config = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("hosting.json", optional: true)
.AddJsonFile("hosting.development.json", optional: true)
.AddEnvironmentVariables().Build();
IHostBuilder hostBuilder = Host.CreateDefaultBuilder(args);
hostBuilder.ConfigureLogging(logging =>
{
logging.AddConsole();
}).ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
webBuilder.UseConfiguration(config);
webBuilder.UseKestrel();
})
.ConfigureServices(services =>
{
RequestSentToEmailProviderEvent e = new RequestSentToEmailProviderEvent(Guid.Parse("2AA2D43B-5E24-4327-8029-1135B20F35CE"), "", new List <String>(),
"", "", true);
RequestSentToSMSProviderEvent s = new RequestSentToSMSProviderEvent(Guid.NewGuid(), "", "", "");
TypeProvider.LoadDomainEventsTypeDynamically();
services.AddHostedService <SubscriptionWorker>(provider =>
{
IDomainEventHandlerResolver r =
provider.GetRequiredService <IDomainEventHandlerResolver>();
EventStorePersistentSubscriptionsClient p = provider.GetRequiredService <EventStorePersistentSubscriptionsClient>();
HttpClient h = provider.GetRequiredService <HttpClient>();
SubscriptionWorker worker = new SubscriptionWorker(r, p, h);
worker.TraceGenerated += Worker_TraceGenerated;
return(worker);
});
});
return(hostBuilder);
}
static async Task ConnectToPersistentSubscriptionWithManualAcks(EventStorePersistentSubscriptionsClient client)
{
#region subscribe-to-persistent-subscription-with-manual-acks
var subscription = await client.SubscribeAsync(
"test-stream",
"subscription-group",
async (subscription, evnt, retryCount, cancellationToken) => {
try {
await HandleEvent(evnt);
await subscription.Ack(evnt);
} catch (UnrecoverableException ex) {
await subscription.Nack(PersistentSubscriptionNakEventAction.Park, ex.Message, evnt);
}
}, (subscription, dropReason, exception) => {
Console.WriteLine($"Subscription was dropped due to {dropReason}. {exception}");
}, autoAck : false);
#endregion subscribe-to-persistent-subscription-with-manual-acks
}
private static async Task <IProjectionHost> CreateProjection(EventStoreClientSettings settings, bool persistent)
{
IProjectionHost projectionHost;
var currentCounterValuesReadModelBuilder = new CurrentCounterValuesReadModelBuilder();
if (persistent)
{
var esPersistenSubscriptionClient = new EventStorePersistentSubscriptionsClient(settings);
projectionHost = new EsPersistentSubscriptionProjectionHost(currentCounterValuesReadModelBuilder, esPersistenSubscriptionClient);
}
else
{
var esClient = new EventStoreClient(settings);
projectionHost = new EsVolatileSubscriptionProjecctionHost(currentCounterValuesReadModelBuilder, esClient, new NoCheckpoinProvider());
}
await projectionHost.Subscribe();
return(projectionHost);
}
/// <summary>
/// Creates EventStoreDB persistent subscription service for a given stream
/// </summary>
/// <param name="eventStoreClient">EventStoreDB gRPC client instance</param>
/// <param name="subscriptionId">Subscription ID</param>
/// <param name="eventSerializer">Event serializer instance</param>
/// <param name="eventHandlers">Collection of event handlers</param>
/// <param name="loggerFactory">Optional: logger factory</param>
/// <param name="measure">Optional: gap measurement for metrics</param>
public StreamPersistentSubscription(
EventStoreClient eventStoreClient,
EventStorePersistentSubscriptionsClient persistentSubscriptionsClient,
string streamName,
string subscriptionId,
IEventSerializer eventSerializer,
IEnumerable <IEventHandler> eventHandlers,
ILoggerFactory?loggerFactory = null,
SubscriptionGapMeasure?measure = null
) : base(
eventStoreClient,
subscriptionId,
new NoOpCheckpointStore(),
eventSerializer,
eventHandlers,
loggerFactory,
measure
)
{
_persistentSubscriptionsClient = persistentSubscriptionsClient;
_stream = streamName;
}
public App(EventStorePersistentSubscriptionsClient client, IServiceScopeFactory serviceScopeFactory)
{
_client = client;
_serviceScopeFactory = serviceScopeFactory;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="factory">factory logger</param>
/// <param name="client">event store client</param>
/// <param name="persist">event store persistent subscription client</param>
public PrimeGrain(ILoggerFactory factory, IESService <int> es_service, IRXService <int> rx_service, [PersistentState("primes", GrainConst.Storage)] IPersistentState <PrimeAggregate> aggregate, EventStorePersistentSubscriptionsClient persist)
{
_logger = factory.CreateLogger <PrimeGrain>();
_es_service = es_service;
_rx_service = rx_service;
_aggregate = aggregate;
PrimeGrain_Persist(persist);
PrimeGrain_Stream(factory);
}
public EsPersistentSubscriptionProjectionHost(IProjection projection, EventStorePersistentSubscriptionsClient client)
{
this.projection = projection;
this.client = client;
}
static async Task Main(string[] args)
{
var connectionString = "esdb://localhost:2113?Tls=false";
var settings = EventStoreClientSettings
.Create(connectionString);
// Write some events to a random stream
var writeClient = new EventStoreClient(settings);
var eventStoreStreamName = $"Test-{Uuid.NewUuid()}";
const string eventStoreGroupName = "EventStoreSubscriptionDrop";
for (var i = 0; i < 1000; i++)
{
await writeClient.AppendToStreamAsync(
eventStoreStreamName,
StreamState.Any,
new []
{
new EventData(Uuid.NewUuid(), "DummyEvent", new byte[] {})
});
}
// create a subscription to the stream
var subscriptionSettings = new PersistentSubscriptionSettings(
messageTimeout: TimeSpan.FromSeconds(30),
namedConsumerStrategy: SystemConsumerStrategies.RoundRobin,
resolveLinkTos: true,
startFrom: StreamPosition.Start);
var subscriptionsClient = new EventStorePersistentSubscriptionsClient(settings);
try
{
if (!subscriptionsClient.CreateAsync(
eventStoreStreamName,
eventStoreGroupName,
subscriptionSettings).Wait(TimeSpan.FromSeconds(10)))
{
throw new Exception(
"Event Store subscription creation timed out.");
}
}
catch (AggregateException e)
{
if (!(e.InnerException is InvalidOperationException oe))
{
throw;
}
if (!Regex.IsMatch(oe.Message, "AlreadyExists"))
{
throw;
}
}
await subscriptionsClient.SubscribeAsync(
eventStoreStreamName,
eventStoreGroupName,
(sub, @event, _, token) =>
{
sub.Ack(@event);
return(Task.CompletedTask);
},
(sub, reason, e) =>
{
Console.WriteLine($"Sub dropped with {reason}. {e}");
},
autoAck : false);
while (true)
{
await Task.Delay(1000);
}
}
static async Task Main(string[] args)
{
var subs = new EventStorePersistentSubscriptionsClient(new EventStoreClientSettings
{
DefaultCredentials = new UserCredentials("admin", "changeit"),
CreateHttpMessageHandler = () => new SocketsHttpHandler
{
SslOptions = new SslClientAuthenticationOptions
{
RemoteCertificateValidationCallback = delegate { return true; }
}
}
});
try
{
await subs.CreateAsync("$ce-Order", "consoleapp2", new PersistentSubscriptionSettings());
}
catch { }
await subs.SubscribeAsync("$ce-Order", "consoleapp2", (sub, evt, pos, canc) =>
{
Console.WriteLine("event arrived: " + System.Text.Json.JsonSerializer.Serialize(evt.Event));
return Task.CompletedTask;
});
var client = new EventStoreClient(new EventStoreClientSettings
{
OperationOptions = {
TimeoutAfter = Debugger.IsAttached
? new TimeSpan?()
: TimeSpan.FromSeconds(30)
},
CreateHttpMessageHandler = () => new SocketsHttpHandler
{
SslOptions = new SslClientAuthenticationOptions
{
RemoteCertificateValidationCallback = delegate { return true; }
}
}
});
var services = new ServiceCollection();
services.AddTransient<IRepository, Repository>();
services.AddSingleton<EventTypeResolver>(fact => new EventTypeResolver(typeof(Program).Assembly));
services.AddSingleton<EventStoreClient>(fact => client);
var provider = services.BuildServiceProvider();
//// trans 1
using (var scope = provider.CreateScope())
{
//var order1 = new Order(order1Id, customer1Id);
//var order2 = new Order(order2Id, customer2Id);
//var repo = scope.ServiceProvider.GetRequiredService<IRepository>();
//await repo.SaveAsync(order1);
//await repo.SaveAsync(order2);
}
// trans 2
using (var scope = provider.CreateScope())
{
var repo = scope.ServiceProvider.GetRequiredService<IRepository>();
var order = await repo.GetByIdAsync<Order>(order1Id);
//order.AddItem(item1Id, 2);
//order.AddItem(item2Id, 3);
await repo.SaveAsync(order);
}
//// trans 3
using (var scope = provider.CreateScope())
{
var repo = scope.ServiceProvider.GetRequiredService<IRepository>();
var order = await repo.GetByIdAsync<Order>(order1Id);
order.RemoveItem(item1Id);
order.AddItem(item3Id, 4);
await repo.SaveAsync(order);
}
//// trans 4
using (var scope = provider.CreateScope())
{
var repo = scope.ServiceProvider.GetRequiredService<IRepository>();
var order = await repo.GetByIdAsync<Order>(order1Id);
}
//// trans 5
using (var scope = provider.CreateScope())
{
//var repo = scope.ServiceProvider.GetRequiredService<IRepository>();
//var orderInst1 = await repo.GetByIdAsync<Order>(order1Id);
//var orderInst2 = await repo.GetByIdAsync<Order>(order1Id);
//orderInst1.AddItem(item4Id, 2);
//await repo.SaveAsync(orderInst1);
//orderInst2.AddItem(item3Id, 5);
//await repo.SaveAsync(orderInst2);
}
do
{
Thread.Sleep(1000);
} while (true);
}
/// <summary>
/// Constructor
/// </summary>
public void PrimeGrain_Persist(EventStorePersistentSubscriptionsClient persist)
{
_persist = persist;
}
public PersistSubsGrpcTests(EventStoreFixture fixture)
{
_client = fixture.Client;
_persist = fixture.PersistentSubscription;
}
/// <summary>
/// Creates the specified persistent subscriptions client.
/// </summary>
/// <param name="persistentSubscriptionsClient">The persistent subscriptions client.</param>
/// <param name="persistentSubscriptionDetails">The persistent subscription details.</param>
/// <param name="domainEventHandlerResolver">The domain event handler resolver.</param>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
/// <returns></returns>
public static PersistentSubscription Create(EventStorePersistentSubscriptionsClient persistentSubscriptionsClient,
PersistentSubscriptionDetails persistentSubscriptionDetails,
IDomainEventHandlerResolver domainEventHandlerResolver,
String username = "******",
String password = "******") =>
