private void CreateSubscription()
{
var settings = ConnectionSettings
.Create()
.KeepReconnecting()
.KeepRetrying()
//.EnableVerboseLogging()
.UseConsoleLogger();
// PersistentSubscriptionSettings settings = PersistentSubscriptionSettings.Create()
// .DoNotResolveLinkTos()
// .StartFromCurrent();
try
{
_eventStoreConnection.SubscribeToAllAsync(false, EventAppeared, SubscriptionDropped, User).Wait();
// foreach (var ev in _subscriptionConfiguration.SubscribedEvents)
// {
// _eventStoreConnection.SubscribeToStreamAsync(ev.Key ,false , EventAppeared , SubscriptionDropped , User ).Wait();
// }
}
catch (AggregateException ex)
{
if (ex.InnerException != null && (ex.InnerException.GetType() != typeof(InvalidOperationException) &&
ex.InnerException?.Message !=
$"Subscription group on stream already exists"))
{
//throw;
}
}
}
private async void ConnectToSubscription()
{
try
{
_subscription = await _conn.SubscribeToAllAsync(false, EventAppeared, SubscriptionDropped, User);
}
catch
{
_conn.ConnectAsync().Wait();
_subscription = await _conn.SubscribeToAllAsync(false, EventAppeared, SubscriptionDropped, User);
}
}
private async void ConnectToSubscription()
{
var bufferSize = 10;
var autoAck = true;
try
{
_subscription = await _conn.SubscribeToAllAsync(false, EventAppeared, SubscriptionDropped, User);
}
catch
{
_conn.ConnectAsync().Wait();
_subscription = await _conn.SubscribeToAllAsync(false, EventAppeared, SubscriptionDropped, User);
}
}
protected void SubscribeToAll(string login, string password)
{
using (Connection.SubscribeToAllAsync(false, (x, y) => { }, (x, y, z) => { },
login == null && password == null ? null : new UserCredentials(login, password)).Result)
{
}
}
public async Task Load()
{
var readEvents = await _storeConnection.ReadAllEventsForwardAsync(new Position(0, 0), 4000, false);
foreach (var resolvedEvent in readEvents.Events)
{
Console.WriteLine("Processing event", resolvedEvent.Event.EventType);
ProcessEvent(resolvedEvent);
}
_storeConnection.SubscribeToAllAsync(false, EventAppeared);
}
/// <summary>
/// Asynchronously subscribes to all events in the Event Store. New
/// events written to the stream while the subscription is active
/// will be pushed to the client.
/// </summary>
/// <param name="target">The connection to subscribe to</param>
/// <param name="resolveLinkTos">Whether to resolve Link events automatically</param>
/// <param name="eventAppeared">An action invoked when a new event is received over the subscription</param>
/// <param name="subscriptionDropped">An action invoked if the subscription is dropped</param>
/// <param name="userCredentials">User credentials to use for the operation</param>
/// <returns>An <see cref="EventStoreSubscription"/> representing the subscription</returns>
public static Task <EventStoreSubscription> SubscribeToAllAsync(
this IEventStoreConnection target,
bool resolveLinkTos,
Action <EventStoreSubscription, ResolvedEvent> eventAppeared,
Action <EventStoreSubscription, SubscriptionDropReason, Exception> subscriptionDropped = null,
UserCredentials userCredentials = null) =>
target.SubscribeToAllAsync(
resolveLinkTos,
ToTask(eventAppeared),
subscriptionDropped,
userCredentials
);
public async Task RegisterAsync(Type eventType)
{
if (_subscribedEventTypes.Contains(eventType))
{
return;
}
if (_subscription == null)
{
//TODO: lock etc?
_subscription = await _connection.SubscribeToAllAsync(true, OnEventDelivered, OnSubscriptionDropped, new UserCredentials("admin", "changeit"));
}
_subscribedEventTypes.Add(eventType);
}
private Task <EventStoreSubscription> SubscribeToAll()
{
//TODO: Before trying to resubscribe - how to ensure that store is active and ready to accept.
//AN: EventStoreConnection automatically tries to connect (if not already connected) to EventStore,
//so you don't have to do something manually
//Though in case of errors, you need to do some actions (if EventStore server is down or not yet up, etc)
var task = eventStoreConnection.SubscribeToAllAsync(false, EventAppeared, SubscriptionDropped);
if (!task.Wait(ReconnectTimeoutMillisec))
{
throw new TimeoutException("ReconnectedAfterSubscriptionException");
}
return(Task.FromResult(task.GetAwaiter().GetResult()));
//return await eventStoreConnection.SubscribeToAllAsync(false, EventAppeared, SubscriptionDropped);
}
public Task Start()
{
if (_started)
{
return(Task.CompletedTask);
}
Log.Info("Starting realtime subscription for meta updates");
_started = true;
return(_connection.SubscribeToAllAsync(
false,
(_, re) => HandleEvent(re),
HandleDrop
));
}
private async Task <EventStoreSubscription> SubscribeToAllEvents(Action <IEvent> pumpEvent, Action <Exception> pumpError)
{
return(await _connection.SubscribeToAllAsync(
true,
(subscription, ev) =>
{
try
{
ProcessReceivedEvent(ev, pumpEvent);
}
catch (Exception ex)
{
pumpError(ex);
}
},
(subscription, reason, ex) => OnSubscriptionDropped(reason, ex, pumpError, pumpEvent)));
}
public async Task <ISubscription> SubscribeToAll(Func <ISubscription, IEventData, Task> onEventAppeared,
Action <ISubscription, string, Exception> onSubscriptionDropped = null,
IUserCredentials userCredentials = null)
{
var subscriptionId = Guid.NewGuid().ToString();
var creds = userCredentials != null
? new global::EventStore.ClientAPI.SystemData.UserCredentials(userCredentials.Username,
userCredentials.Password)
: null;
var esSubscription = await _connection.SubscribeToAllAsync(true,
async (_, ev) => await HandleEvent(onEventAppeared, _subscriptions[subscriptionId], ev),
(_, reason, ex) => onSubscriptionDropped(_subscriptions[subscriptionId], reason.ToString(), ex),
creds);
var subscription = _subscriptions[subscriptionId] = new Subscription(esSubscription);
return(subscription);
}
public async Task SubscribeToOrdersFromAll()
{
await _connection.SubscribeToAllAsync(false, (sub, evnt) =>
{
// Subscribe to OrderCompleted events and write to console
Console.WriteLine($"Received Event {evnt.Event.EventNumber}@{evnt.Event.EventStreamId} - {evnt.Event.EventType}");
if (evnt.Event.EventType == typeof(OrderCompleted).FullName)
{
var @event = (OrderCompleted)Helper.ConstructEvent(evnt);
Console.WriteLine($"Received Order for {@event.UserId} {@event.CartId}");
Console.WriteLine();
}
},
(sub, reason, ex) => {
Console.WriteLine($"Subscription dropped because {reason}. Exception: {ex}");
}, _credentials);
Console.WriteLine("Subscribed to all events");
}
protected virtual void ListenForNotificationsOnConnection(IEventStoreConnection connection)
{
connection.SubscribeToAllAsync(true, DisplayNotificationArrival, DisplaySubscriptionDropped).RunSynchronously();
}
protected async Task SubscribeToAll(string login, string password)
{
using (await Connection.SubscribeToAllAsync(false, (x, y) => Task.CompletedTask, (x, y, z) => { },
login == null && password == null ? null : new UserCredentials(login, password))) {
}
}
public IDisposable Subscribe(IObserver <T> observer)
{
_observer = observer;
_subscription = _connection.SubscribeToAllAsync(_resolveLinkTos, EventAppeared, SubscriptionDropped).Result;
return(Disposable.Create(Stop));
}
public bool Start()
{
_connection.SubscribeToAllAsync(false, EventAppeared).Wait();
Log.Info("AssociateAccount EndPoint started");
return(true);
}