public static EventStoreSubscription GetLiveOnlyEventStoreSubscription( this IEventStoreConnection eventStoreConnection, Type typeofDomainObject, Action <EventStoreSubscription, ResolvedEvent> eventAppeared, Action <EventStoreSubscription, SubscriptionDropReason, Exception> subscriptionDropped = null, UserCredentials userCredentials = null, bool resolveLinkTos = true, Guid aggregateId = default(Guid)) { try { var streamName = typeofDomainObject.GetStreamNameBasedOnDomainObjectType( resolveLinkTos, aggregateId); return(eventStoreConnection.SubscribeToStreamAsync( streamName, resolveLinkTos, eventAppeared, subscriptionDropped, userCredentials).Result); } catch (Exception ex) { // Unlike a stream catch-up subscription, a live only subscription will fail if EventStore is not running. Log.Error(ex.Message); throw; } }
protected async Task SubscribeToStream(string streamId, string login, string password) { using (await Connection.SubscribeToStreamAsync(streamId, false, (x, y) => Task.CompletedTask, (x, y, z) => { }, login == null && password == null ? null : new UserCredentials(login, password))) { } }
/// <summary> /// Creates the Subscription with EventStore. /// </summary> /// <param name="streamName">The name of the EventStore Stream we are subscribing to.</param> /// <param name="eventStoreStreamSequenceToken"></param> /// <returns>An EventStoreSubscription or EventStorePersistentSubscription.</returns> private object CreateEventStoreSubscription(string streamName, EventStoreStreamSequenceToken eventStoreStreamSequenceToken) { object subscription = null; if (eventStoreStreamSequenceToken == null || eventStoreStreamSequenceToken.EventNumber == int.MinValue) { var subscribeTask = m_EventStoreConnection.SubscribeToStreamAsync(streamName, true, EventAppeared, SubscriptionDropped); Task.WaitAll(subscribeTask); if (subscribeTask.IsFaulted) { throw subscribeTask.Exception; } subscription = subscribeTask.Result; } else { // If we have been provided with a StreamSequenceToken, we can call SubscribeFrom to get previous messages. subscription = m_EventStoreConnection.SubscribeToStreamFrom(streamName, eventStoreStreamSequenceToken.EventNumber, new CatchUpSubscriptionSettings(100, 20, false, true), EventAppeared); } m_Logger.Info($"Subscribed to Stream {streamName}"); return(subscription); }
protected void SubscribeToStream(string streamId, string login, string password) { using (Connection.SubscribeToStreamAsync(AdjustStreamId(streamId), false, (x, y) => { }, (x, y, z) => { }, login == null && password == null ? null : new UserCredentials(login, password)).Result) { } }
private static void Subscribe(string room, Action <ChatMessage> onRecieved) { _connection.SubscribeToStreamAsync( room, false, OnRecieved(onRecieved)); Console.WriteLine("_connecting to room " + room); }
public static void Subscribe( string room, Action <ChatMessage> onRecieved) { Connection.SubscribeToStreamAsync( room, false, OnRecieved(onRecieved)); }
public void Start() { connection.ConnectAsync() .Wait(); connection.SubscribeToStreamAsync( "Employee", true, (subscription, evt) => processor.ProcessEvent(evt)) .Wait(); }
public static async Task <EventStoreSubscription> SubscribeToStream( this IEventStoreConnection connection, string stream, Action <EventStoreSubscription, ResolvedEvent> processEvent) { return(await connection.SubscribeToStreamAsync( stream, false, processEvent, null, new UserCredentials("admin", "changeit"))); }
public void Start_ProcessesEventsFromStream() { sut.Start(); A.CallTo(() => connection.ConnectAsync()).MustHaveHappened() .Then(A.CallTo(() => connection.SubscribeToStreamAsync( "Employee", true, A <Func <EventStoreSubscription, ResolvedEvent, Task> > ._, null, null)).MustHaveHappened()); }
public EventStoreBusConnector( IGeneralBus bus, IEventStoreConnection es, string stream, string name) { _es = es; _stream = stream; _bus = new BusAdapter(bus); _name = name; _bus.Subscribe(this); _es.SubscribeToStreamAsync(stream, true, EventAppeared, SubscriptionDropped); }
/// <summary> /// Asynchronously subscribes to a single event stream. 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="stream">The stream 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> SubscribeToStreamAsync( this IEventStoreConnection target, string stream, bool resolveLinkTos, Action <EventStoreSubscription, ResolvedEvent> eventAppeared, Action <EventStoreSubscription, SubscriptionDropReason, Exception> subscriptionDropped = null, UserCredentials userCredentials = null) => target.SubscribeToStreamAsync( stream, resolveLinkTos, ToTask(eventAppeared), subscriptionDropped, userCredentials );
public void SubscribeToFutureEvents() { var thread = new Thread(() => { eventStoreConnection.SubscribeToStreamAsync(streamName, true, (sub, evt) => { UpdateOrderState(evt, context); }) .Wait(); }); thread.Start(); }
public async Task SubscribeToOrderTypeStream() { string streamId = "$et-EventSourceDemo.OrderCompleted"; // Subscribe to the OrderCompleted type stream. This requires the event type projection to be running await _connection.SubscribeToStreamAsync(streamId, true, (sub, evnt) => { var @event = (OrderCompleted)Helper.ConstructEvent(evnt); Console.WriteLine($"Received Order for {@event.UserId} {@event.CartId}"); }, (sub, reason, ex) => { Console.WriteLine($"Subscription dropped because {reason}. Exception: {ex}"); }, _credentials); Console.WriteLine($"Subscribed to order type stream {streamId}"); }
private async Task Connect() { _connection = _connectionProvider.GetConnection(); await _connection.ConnectAsync(); Func <EventStoreCatchUpSubscription, ResolvedEvent, Task> processEvent = (subscriptionBase, resolvedEvent) => { return(HandleEvent(resolvedEvent)); }; Func <ESSubscription, ResolvedEvent, Task> processEventAlt = (subscriptionBase, resolvedEvent) => { return(HandleEvent(resolvedEvent)); }; var streamId = _streamId == null ? $"$ce-{_aggregateType.ToUpper()}" : _streamId.Id; if (_startPosition == StreamPosition.End) { _subscriptionBase = await _connection.SubscribeToStreamAsync( streamId, true, processEventAlt, subscriptionDropped : SubscriptionDropped); _connected = true; _status = SubscriptionConnectionStatus.Connected; } else { _catchUpSubscriptionBase = _connection.SubscribeToStreamFrom( streamId, 0, new CatchUpSubscriptionSettings( CatchUpSubscriptionSettings.Default.MaxLiveQueueSize, CatchUpSubscriptionSettings.Default.ReadBatchSize, false, true, CatchUpSubscriptionSettings.Default.SubscriptionName), processEvent, subscriptionDropped: SubscriptionDropped); _connected = true; _status = SubscriptionConnectionStatus.Connected; } }
public void StartListening() { // // This can also be done with competing consumers for load balancing // the workload across many of the same adapter. In order to use // competing consumers you would use ConnectToPersistentSubscription // and first create a named persistent subscription to connect to // // *note that the code from competing branch is not yet merged to master // // Also note that this is currently using an admin user for subscribing // in most systems a specific user would be prefered as opposed to using // an admin user for this behaviour. _subscription = _connection.SubscribeToStreamAsync(_incomingStream, false, EventAppeared, SubscriptionDropped, _credentials).Result; }
/// <summary> /// Start the subscriber. /// </summary> /// <param name="restart">Starting from a restart.</param> public void Start(bool restart = false) { if (_usingHeartbeats) { SendHeartbeat(); _heartbeatTimer.Start(); } lock (_subscriptionLock) { KillSubscription(); if (_liveOnly) { _subscription = _connection.SubscribeToStreamAsync(_streamName, true, (s, e) => EventAppeared(e), SubscriptionDropped).Result; } else { var catchUpSettings = new CatchUpSubscriptionSettings(_maxLiveQueueSize, _catchupPageSize, true, true); _subscription = _connection.SubscribeToStreamFrom(_streamName, _startingPosition, catchUpSettings, (s, e) => EventAppeared(e), LiveProcessingStarted, SubscriptionDropped); } } if (restart) { return; } if (_usingHeartbeats) { _connection.SetStreamMetadataAsync(_heartbeatStreamName, ExpectedVersion.Any, StreamMetadata.Create(2)); } var processor = new Thread(ProcessEvents) { IsBackground = true }; processor.Start(); }
public IDisposable Subscribe(IObserver <T> observer) { _observer = observer; _subscription = _connection.SubscribeToStreamAsync(_streamName, _resolveLinkTos, EventAppeared, SubscriptionDropped).Result; return(Disposable.Create(Stop)); }
public void SubscribeToStream(string streamName, Action <EventstoreEvent> eventHandler) { _connection.SubscribeToStreamAsync(streamName, false, (subscription, resolvedEvent) => eventHandler(MapEventstoreEvent(resolvedEvent)), (subscription, reason, arg3) => SubscriptionDropped(reason, streamName, eventHandler)); }
private void SubscriptionDropped(EventStoreSubscription arg1, SubscriptionDropReason arg2, Exception arg3) { _es.SubscribeToStreamAsync(_stream, true, EventAppeared, SubscriptionDropped); }
private async Task SubscribeService(AppFunc chain, string stream, bool liveOnlySubscriptions, string subscriptionKey, IDictionary <string, object> environment) { environment.Log("Subscribing to stream: {0}", LogLevel.Debug, stream); while (true) { if (!running) { return; } try { if (_serviceSubscriptions.ContainsKey(subscriptionKey)) { _serviceSubscriptions[subscriptionKey].Close(); _serviceSubscriptions.Remove(subscriptionKey); } if (liveOnlySubscriptions) { //TODO:Handle retries on error var eventstoreSubscription = await _eventStoreConnection.SubscribeToStreamAsync(stream, true, async (subscription, evnt) => await PushEventToService(chain, stream, _eventSerialization.DeSerialize(evnt), false, environment, x => environment.Log("Successfully handled event: {0} on stream: {1}", LogLevel.Debug, x.EventId, stream), (x, exception) => environment.Log(exception, "Failed handling event: {0} on stream: {1}", LogLevel.Error, x.EventId, stream)).ConfigureAwait(false), async (subscription, reason, exception) => await SubscriptionDropped(chain, stream, true, subscriptionKey, reason, exception, environment).ConfigureAwait(false)).ConfigureAwait(false); _serviceSubscriptions[subscriptionKey] = new LiveOnlyServiceSubscription(eventstoreSubscription); } else { var eventstoreSubscription = _eventStoreConnection.ConnectToPersistentSubscription(stream, subscriptionKey, async(subscription, evnt) => await PushEventToService(chain, stream, _eventSerialization.DeSerialize(evnt), true, environment, x => { environment.Log("Successfully handled event: {0} on stream: {1}", LogLevel.Debug, x.EventId, stream); subscription.Acknowledge(x.OriginalEvent); }, (x, exception) => { environment.Log(exception, "Failed handling event: {0} on stream: {1}", LogLevel.Error, x.EventId, stream); subscription.Fail(x.OriginalEvent, PersistentSubscriptionNakEventAction.Unknown, exception.Message); }).ConfigureAwait(false), async(subscription, reason, exception) => await SubscriptionDropped(chain, stream, false, subscriptionKey, reason, exception, environment).ConfigureAwait(false), autoAck: false); _serviceSubscriptions[subscriptionKey] = new PersistentServiceSubscription(eventstoreSubscription); } return; } catch (Exception ex) { if (!running) { return; } environment.Log(ex, "Couldn't subscribe to stream: {0}. Retrying in 5 seconds.", LogLevel.Warn, stream); await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(false); } } }