Example #1
0
 internal void ProcessCommittedEvent(
     CommittedEventWorkItem committedEventWorkItem, ProjectionSubscriptionMessage.CommittedEventReceived message,
     string partition)
 {
     EnsureState(State.Running);
     InternalProcessCommittedEvent(committedEventWorkItem, partition, message);
 }
Example #2
0
        public void Handle(ProjectionSubscriptionMessage.CommittedEventReceived message)
        {
            if (IsOutOfOrderSubscriptionMessage(message))
            {
                return;
            }
            RegisterSubscriptionMessage(message);

            EnsureState(
                State.Running | State.Paused | State.Stopping | State.Stopped | State.FaultedStopping | State.Faulted);
            try
            {
                if (_state == State.Running || _state == State.Paused)
                {
                    CheckpointTag eventTag  = message.CheckpointTag;
                    string        partition = _checkpointStrategy.StatePartitionSelector.GetStatePartition(message);
                    var           committedEventWorkItem = new CommittedEventWorkItem(this, message, partition);
                    _processingQueue.EnqueueTask(committedEventWorkItem, eventTag);
                }
                _processingQueue.ProcessEvent();
            }
            catch (Exception ex)
            {
                SetFaulted(ex);
            }
        }
Example #3
0
 private void EmitStateUpdated(CommittedEventWorkItem committedEventWorkItem, string partition, string newState)
 {
     committedEventWorkItem.ScheduleEmitEvents(
         new[]
     {
         new EmittedEvent(MakePartitionStateStreamName(partition), Guid.NewGuid(), "StateUpdated", newState)
     });
 }
Example #4
0
 private void EmitStateUpdated(CommittedEventWorkItem committedEventWorkItem, string partition, string newState, CheckpointTag eventTag, CheckpointTag expectedTag)
 {
     committedEventWorkItem.ScheduleEmitEvents(
         new[]
     {
         new EmittedEvent(MakePartitionStateStreamName(partition), Guid.NewGuid(), "StateUpdated", newState, eventTag, expectedTag)
     });
 }
Example #5
0
        private void EmitEmittedEvents(CommittedEventWorkItem committedEventWorkItem, EmittedEvent[] emittedEvents)
        {
            bool result = emittedEvents != null && emittedEvents.Length > 0;

            if (result)
            {
                committedEventWorkItem.ScheduleEmitEvents(emittedEvents);
            }
        }
Example #6
0
        private void ProcessCommittedEvent(
            CommittedEventWorkItem committedEventWorkItem, ProjectionMessage.Projections.CommittedEventReceived message,
            string partition)
        {
            if (message.Data == null)
            {
                throw new NotSupportedException();
            }

            EnsureState(State.Running);
            InternalProcessCommittedEvent(committedEventWorkItem, partition, message);
        }
Example #7
0
 private bool ProcessEmittedEvents(CommittedEventWorkItem committedEventWorkItem, EmittedEvent[] emittedEvents)
 {
     if (_projectionConfig.EmitEventEnabled)
     {
         EmitEmittedEvents(committedEventWorkItem, emittedEvents);
     }
     else if (emittedEvents != null && emittedEvents.Length > 0)
     {
         ProcessEventFaulted("emit_event is not enabled by the projection configuration/mode");
         return(false);
     }
     return(true);
 }
Example #8
0
 private bool ProcessEmittedEvents(CommittedEventWorkItem committedEventWorkItem, EmittedEvent[] emittedEvents)
 {
     if (_projectionConfig.EmitEventEnabled && _checkpointStrategy.IsEmiEnabled())
     {
         EmitEmittedEvents(committedEventWorkItem, emittedEvents);
     }
     else if (emittedEvents != null && emittedEvents.Length > 0)
     {
         ProcessEventFaulted("'emit' is not allowed by the projection/configuration/mode");
         return(false);
     }
     return(true);
 }
Example #9
0
        private void InternalProcessCommittedEvent(
            CommittedEventWorkItem committedEventWorkItem, string partition,
            ProjectionSubscriptionMessage.CommittedEventReceived message)
        {
            string newState = null;

            EmittedEvent[] emittedEvents = null;

            //TODO: not emitting (optimized) projection handlers can skip serializing state on each processed event
            bool hasBeenProcessed;

            try
            {
                hasBeenProcessed = ProcessEventByHandler(partition, message, out newState, out emittedEvents);
            }
            catch (Exception ex)
            {
                ProcessEventFaulted(
                    string.Format(
                        "The {0} projection failed to process an event.\r\nHandler: {1}\r\nEvent Position: {2}\r\n\r\nMessage:\r\n\r\n{3}",
                        _name, GetHandlerTypeName(), message.Position, ex.Message), ex);
                newState         = null;
                emittedEvents    = null;
                hasBeenProcessed = false;
            }
            newState = newState ?? "";
            if (hasBeenProcessed)
            {
                if (!ProcessEmittedEvents(committedEventWorkItem, emittedEvents))
                {
                    return;
                }

                var oldState = _partitionStateCache.GetLockedPartitionState(partition);
                if (oldState.Data != newState)
                // ensure state actually changed
                {
                    var lockPartitionStateAt = partition != "" ? message.CheckpointTag : null;
                    _partitionStateCache.CacheAndLockPartitionState(partition, new PartitionStateCache.State(newState, message.CheckpointTag), lockPartitionStateAt);
                    if (_projectionConfig.PublishStateUpdates)
                    {
                        EmitStateUpdated(committedEventWorkItem, partition, newState, message.CheckpointTag, oldState.CausedBy);
                    }
                }
            }
        }
Example #10
0
        private void InternalProcessCommittedEvent(
            CommittedEventWorkItem committedEventWorkItem, string partition,
            ProjectionMessage.Projections.CommittedEventReceived message)
        {
            string newState = null;

            EmittedEvent[] emittedEvents = null;

            //TODO: not emitting (optimized) projection handlers can skip serializing state on each processed event
            bool hasBeenProcessed;

            try
            {
                bool passedFilter = EventPassesFilter(message);
                hasBeenProcessed = passedFilter &&
                                   ProcessEventByHandler(partition, message, out newState, out emittedEvents);
            }
            catch (Exception ex)
            {
                ProcessEventFaulted(message, ex);
                newState         = null;
                emittedEvents    = null;
                hasBeenProcessed = false;
            }
            newState = newState ?? "";
            if (hasBeenProcessed)
            {
                if (_projectionConfig.EmitEventEnabled)
                {
                    EmitEmittedEvents(committedEventWorkItem, emittedEvents);
                }
                if (_partitionStateCache.GetLockedPartitionState(partition) != newState)
                // ensure state actually changed
                {
                    var lockPartitionStateAt = partition != ""
                                                   ? _checkpointStrategy.PositionTagger.MakeCheckpointTag(message)
                                                   : null;
                    _partitionStateCache.CacheAndLockPartitionState(partition, newState, lockPartitionStateAt);
                    if (_projectionConfig.PublishStateUpdates)
                    {
                        EmitStateUpdated(committedEventWorkItem, partition, newState);
                    }
                }
            }
        }
 public void Handle(EventReaderSubscriptionMessage.CommittedEventReceived message)
 {
     //TODO:  make sure this is no longer required : if (_state != State.StateLoaded)
     if (IsOutOfOrderSubscriptionMessage(message))
     {
         return;
     }
     RegisterSubscriptionMessage(message);
     try {
         CheckpointTag eventTag = message.CheckpointTag;
         var           committedEventWorkItem = new CommittedEventWorkItem(this, message, _statePartitionSelector);
         _processingQueue.EnqueueTask(committedEventWorkItem, eventTag);
         if (_state == PhaseState.Running)                 // prevent processing mostly one projection
         {
             EnsureTickPending();
         }
     } catch (Exception ex) {
         _coreProjection.SetFaulted(ex);
     }
 }