Esempio n. 1
0
        public void Handle(CoreProjectionManagementMessage.CreateAndPrepareSlave message)
        {
            try
            {
                var stateHandler = CreateStateHandler(_timeoutScheduler, _logger, message.HandlerType, message.Query);

                string name                         = message.Name;
                var    sourceDefinition             = ProjectionSourceDefinition.From(stateHandler.GetSourceDefinition());
                var    projectionVersion            = message.Version;
                var    projectionConfig             = message.Config.SetIsSlave();
                var    projectionProcessingStrategy =
                    _processingStrategySelector.CreateSlaveProjectionProcessingStrategy(
                        name,
                        projectionVersion,
                        sourceDefinition,
                        projectionConfig,
                        stateHandler,
                        message.MasterWorkerId,
                        _publisher,
                        message.MasterCoreProjectionId,
                        this);
                CreateCoreProjection(message.ProjectionId, projectionConfig.RunAs, projectionProcessingStrategy);
                _publisher.Publish(
                    new CoreProjectionStatusMessage.Prepared(
                        message.ProjectionId,
                        sourceDefinition));
            }
            catch (Exception ex)
            {
                _publisher.Publish(new CoreProjectionStatusMessage.Faulted(message.ProjectionId, ex.Message));
            }
        }
Esempio n. 2
0
        public void Handle(CoreProjectionManagementMessage.CreatePrepared message)
        {
            try
            {
                var name              = message.Name;
                var sourceDefinition  = ProjectionSourceDefinition.From(message.SourceDefinition);
                var projectionVersion = message.Version;
                var projectionConfig  = message.Config;
                var namesBuilder      = new ProjectionNamesBuilder(name, sourceDefinition);

                var projectionProcessingStrategy = _processingStrategySelector.CreateProjectionProcessingStrategy(
                    name,
                    projectionVersion,
                    namesBuilder,
                    sourceDefinition,
                    projectionConfig,
                    null,
                    message.HandlerType,
                    message.Query);

                CreateCoreProjection(message.ProjectionId, projectionConfig.RunAs, projectionProcessingStrategy);
                _publisher.Publish(
                    new CoreProjectionStatusMessage.Prepared(
                        message.ProjectionId, sourceDefinition));
            }
            catch (Exception ex)
            {
                _publisher.Publish(
                    new CoreProjectionStatusMessage.Faulted(message.ProjectionId, ex.Message));
            }
        }
 public void Handle(CoreProjectionManagementMessage.CreateAndPrepareSlave message)
 {
     try
     {
         //TODO: factory method can throw!
         IProjectionStateHandler stateHandler = message.HandlerFactory();
         string name                         = message.Name;
         var    sourceDefinition             = ProjectionSourceDefinition.From(name, stateHandler.GetSourceDefinition(), null, null);
         var    projectionVersion            = message.Version;
         var    projectionConfig             = message.Config.SetIsSlave();
         var    projectionProcessingStrategy =
             _processingStrategySelector.CreateSlaveProjectionProcessingStrategy(
                 name, projectionVersion, sourceDefinition, projectionConfig, stateHandler,
                 message.ResultsPublisher, message.MasterCoreProjectionId, this);
         CreateCoreProjection(message.ProjectionId, projectionConfig.RunAs, projectionProcessingStrategy);
         message.Envelope.ReplyWith(
             new CoreProjectionManagementMessage.Prepared(
                 message.ProjectionId, sourceDefinition, slaveProjections: null));
     }
     catch (Exception ex)
     {
         message.Envelope.ReplyWith(
             new CoreProjectionManagementMessage.Faulted(message.ProjectionId, ex.Message));
     }
 }
        public void Handle(CoreProjectionManagementMessage.CreatePrepared message)
        {
            try
            {
                var name             = message.Name;
                var sourceDefinition = ProjectionSourceDefinition.From(
                    name, message.SourceDefinition, message.HandlerType, message.Query);
                var projectionVersion = message.Version;
                var projectionConfig  = message.Config;
                var namesBuilder      = new ProjectionNamesBuilder(name, sourceDefinition);

                var projectionProcessingStrategy = _processingStrategySelector.CreateProjectionProcessingStrategy(
                    name, projectionVersion, namesBuilder, sourceDefinition, projectionConfig, null, null);

                var slaveProjections = projectionProcessingStrategy.GetSlaveProjections();
                CreateCoreProjection(message.ProjectionId, projectionConfig.RunAs, projectionProcessingStrategy);
                message.Envelope.ReplyWith(
                    new CoreProjectionManagementMessage.Prepared(
                        message.ProjectionId, sourceDefinition, slaveProjections));
            }
            catch (Exception ex)
            {
                message.Envelope.ReplyWith(
                    new CoreProjectionManagementMessage.Faulted(message.ProjectionId, ex.Message));
            }
        }
        public void Handle(CoreProjectionManagementMessage.CreateAndPrepare message)
        {
            try
            {
                //TODO: factory method can throw
                IProjectionStateHandler stateHandler = message.HandlerFactory();
                string name             = message.Name;
                var    sourceDefinition = ProjectionSourceDefinition.From(
                    name, stateHandler.GetSourceDefinition(), message.HandlerType, message.Query);
                var projectionVersion = message.Version;
                var projectionConfig  = message.Config;
                var namesBuilder      = new ProjectionNamesBuilder(name, sourceDefinition);

                var projectionProcessingStrategy = _processingStrategySelector.CreateProjectionProcessingStrategy(
                    name, projectionVersion, namesBuilder,
                    sourceDefinition, projectionConfig, message.HandlerFactory, stateHandler);

                var slaveProjections = projectionProcessingStrategy.GetSlaveProjections();
                CreateCoreProjection(message.ProjectionId, projectionConfig.RunAs, projectionProcessingStrategy);
                message.Envelope.ReplyWith(
                    new CoreProjectionManagementMessage.Prepared(
                        message.ProjectionId, sourceDefinition, slaveProjections));
            }
            catch (Exception ex)
            {
                message.Envelope.ReplyWith(
                    new CoreProjectionManagementMessage.Faulted(message.ProjectionId, ex.Message));
            }
        }
Esempio n. 6
0
        public void Handle(CoreProjectionManagementMessage.CreateAndPrepare message)
        {
            try
            {
                //TODO: factory method can throw
                var stateHandler = CreateStateHandler(
                    _timeoutScheduler,
                    _logger,
                    message.HandlerType,
                    message.Query);

                string name             = message.Name;
                var    sourceDefinition = ProjectionSourceDefinition.From(stateHandler.GetSourceDefinition());

                var projectionVersion = message.Version;
                var projectionConfig  = message.Config;
                var namesBuilder      = new ProjectionNamesBuilder(name, sourceDefinition);

                var projectionProcessingStrategy = _processingStrategySelector.CreateProjectionProcessingStrategy(
                    name,
                    projectionVersion,
                    namesBuilder,
                    sourceDefinition,
                    projectionConfig,
                    stateHandler,
                    message.HandlerType,
                    message.Query);

                CreateCoreProjection(message.ProjectionId, projectionConfig.RunAs, projectionProcessingStrategy);
                _publisher.Publish(
                    new CoreProjectionStatusMessage.Prepared(
                        message.ProjectionId, sourceDefinition));
            }
            catch (Exception ex)
            {
                _publisher.Publish(
                    new CoreProjectionStatusMessage.Faulted(message.ProjectionId, ex.Message));
            }
        }