protected override void OnSetReceiveHandler(IPartitionReceiveHandler newReceiveHandler) { lock (this.receivePumpLock) { if (this.receiveHandler != null) { // Notify existing handler first (but don't wait). this.receiveHandler.ProcessErrorAsync(new OperationCanceledException("New handler has registered for this receiver.")); // .Fork(); } this.receiveHandler = newReceiveHandler; if (this.receiveHandler != null) { // We have a new receiveHandler, ensure pump is running. if (this.receivePumpTask == null) { this.receivePumpCancellationSource = new CancellationTokenSource(); this.receivePumpTask = this.ReceivePumpAsync(this.receivePumpCancellationSource.Token); } } else { // We have no receiveHandler, ensure pump is shut down. if (this.receivePumpTask != null) { this.receivePumpCancellationSource.Cancel(); this.receivePumpCancellationSource.Dispose(); this.receivePumpCancellationSource = null; this.receivePumpTask = null; } } } }
/// <summary> /// Set a mock receive handler. /// </summary> /// <param name="receiveHandler"></param> /// <param name="invokeWhenNoEvents"></param> public void SetReceiveHandler(IPartitionReceiveHandler receiveHandler, bool invokeWhenNoEvents = false) { EventProcessorEventSource.Current.Message("MOCK IPartitionReceiver.SetReceiveHandler"); this.outerHandler = receiveHandler; this.invokeWhenNoEvents = invokeWhenNoEvents; // TODO mock does not emulate receive timeouts if (this.outerHandler != null) { Task.Run(() => GenerateMessages()); } }
private async void GenerateMessages() { while ((!this.token.IsCancellationRequested) && (this.outerHandler != null)) { EventProcessorEventSource.Current.Message("MOCK Generating messages and sending to handler"); IEnumerable <EventData> events = ReceiveAsync(10, TimeSpan.FromSeconds(10.0)).Result; // TODO get count from somewhere real IPartitionReceiveHandler capturedHandler = this.outerHandler; if (capturedHandler != null) { await capturedHandler.ProcessEventsAsync(events); } } EventProcessorEventSource.Current.Message("MOCK Message generation ending"); }
// Encapsulates taking the receivePumpLock, checking this.receiveHandler for null, // calls this.receiveHandler.CloseAsync (starting this operation inside the receivePumpLock). void ReceiveHandlerClose() { lock (this.receivePumpLock) { if (this.receiveHandler != null) { if (this.receivePumpTask != null) { this.receivePumpCancellationSource.Cancel(); this.receivePumpCancellationSource.Dispose(); this.receivePumpCancellationSource = null; this.receivePumpTask = null; } this.receiveHandler = null; } } }
protected override void OnSetReceiveHandler(IPartitionReceiveHandler newReceiveHandler, bool invokeWhenNoEvents) { lock (this.receivePumpLock) { if (newReceiveHandler != null) { if (this.receiveHandler != null) { // Notify existing handler first (but don't wait). Task.Run(() => this.receiveHandler.ProcessErrorAsync(new OperationCanceledException("New handler has registered for this receiver."))) .ContinueWith(t => t.Exception.Handle(ex => { // We omit any failures from ProcessErrorAsync return(true); }), TaskContinuationOptions.OnlyOnFaulted); } this.receiveHandler = newReceiveHandler; // We have a new receiveHandler, ensure pump is running. if (this.receivePumpTask == null) { this.receivePumpCancellationSource = new CancellationTokenSource(); this.receivePumpTask = this.ReceivePumpAsync(this.receivePumpCancellationSource.Token, invokeWhenNoEvents); } } else { // newReceiveHandler == null, so this is an unregister call, ensure pump is shut down. if (this.receivePumpTask != null) { // Do not wait as could block and would still match the previous behavior this.ReceiveHandlerClose(); } this.receiveHandler = null; } } }
// Encapsulates taking the receivePumpLock, checking this.receiveHandler for null, // calls this.receiveHandler.CloseAsync (starting this operation inside the receivePumpLock). Task ReceiveHandlerClose() { Task task = null; lock (this.receivePumpLock) { if (this.receiveHandler != null) { if (this.receivePumpTask != null) { task = this.receivePumpTask; this.receivePumpCancellationSource.Cancel(); this.receivePumpCancellationSource.Dispose(); this.receivePumpCancellationSource = null; this.receivePumpTask = null; } this.receiveHandler = null; } } return(task ?? Task.CompletedTask); }
// Encapsulates taking the receivePumpLock, checking this.receiveHandler for null, // calls this.receiveHandler.CloseAsync (starting this operation inside the receivePumpLock). private Task ReceiveHandlerClose() { Task task = null; lock (receivePumpLock) { if (receiveHandler != null) { if (receivePumpTask != null) { task = receivePumpTask; receivePumpCancellationSource.Cancel(); receivePumpCancellationSource.Dispose(); receivePumpCancellationSource = null; receivePumpTask = null; } receiveHandler = null; } } return(task ?? Task.CompletedTask); }
protected override void OnSetReceiveHandler(IPartitionReceiveHandler receiveHandler, bool invokeWhenNoEvents) { //TODO: Implement throw new NotImplementedException(); }
/// <summary></summary> /// <param name="receiveHandler"></param> /// <param name="invokeWhenNoEvents"></param> protected abstract void OnSetReceiveHandler(IPartitionReceiveHandler receiveHandler, bool invokeWhenNoEvents);
/// <summary> /// Sets the <see cref="IPartitionReceiveHandler"/> to process events. /// </summary> /// <param name="receiveHandler">The <see cref="IPartitionReceiveHandler"/> used to process events.</param> /// <param name="invokeWhenNoEvents">Flag to indicate whether the handler should be invoked when the receive call times out.</param> public void SetReceiveHandler(IPartitionReceiveHandler receiveHandler, bool invokeWhenNoEvents = false) { EventHubsEventSource.Log.SetReceiveHandlerStart(this.ClientId, receiveHandler != null ? receiveHandler.GetType().ToString() : "null"); this.OnSetReceiveHandler(receiveHandler, invokeWhenNoEvents); EventHubsEventSource.Log.SetReceiveHandlerStop(this.ClientId); }
public void SetReceiveHandler(IPartitionReceiveHandler receiveHandler, bool invokeWhenNoEvents = false) { this.inner.SetReceiveHandler(receiveHandler, invokeWhenNoEvents); }
/// <summary></summary> /// <param name="receiveHandler"></param> protected abstract void OnSetReceiveHandler(IPartitionReceiveHandler receiveHandler);
/// <summary> /// Sets the <see cref="IPartitionReceiveHandler"/> to process events. /// </summary> /// <param name="receiveHandler">The <see cref="IPartitionReceiveHandler"/> used to process events.</param> public void SetReceiveHandler(IPartitionReceiveHandler receiveHandler) { EventHubsEventSource.Log.SetReceiveHandlerStart(this.ClientId, receiveHandler != null ? receiveHandler.GetType().ToString() : "null"); this.OnSetReceiveHandler(receiveHandler); EventHubsEventSource.Log.SetReceiveHandlerStop(this.ClientId); }
/// <inheritdoc /> public BoolResult StartProcessing(OperationContext context, EventSequencePoint sequencePoint, IPartitionReceiveHandler processor) { Tracer.Info(context, $"{Tracer.Name}: Initializing event processing for event hub '{_configuration.EventHubName}' and consumer group '{_configuration.ConsumerGroupName}'."); if (_partitionReceiver == null) { _partitionReceiver = _eventHubClient.CreateReceiver( _configuration.ConsumerGroupName, PartitionId, GetInitialOffset(context, sequencePoint), new ReceiverOptions() { Identifier = _hostName }); _partitionReceiver.SetReceiveHandler(processor); } return(BoolResult.Success); }
private void Dispatch(EventData eventData, IPartitionReceiveHandler processor) { processor.ProcessEventsAsync(new[] { eventData }).GetAwaiter().GetResult(); }
/// <inheritdoc /> public BoolResult StartProcessing(OperationContext context, EventSequencePoint sequencePoint, IPartitionReceiveHandler processor) { using (_lock.AcquireWriteLock()) { _handler = ev => Dispatch(ev, processor); var events = _hub.SubscribeAndGetEventsStartingAtSequencePoint(sequencePoint, _handler); foreach (var eventData in events) { _handler(eventData); } } return(BoolResult.Success); }