Exemplo n.º 1
0
        //object _syncLock=new object();

        public ProcessWatchDog(ILogger logger, IStateManager stateManager,
                               IBatchEngineSubscribers batchEngineSubscribers, ICacheAside cacheAside,
                               ISerializersFactory serializersFactory, IEntityFactory entityFactory, IEventAggregator eventAggregator,
                               IProcessDataStorage storage, IPubSubFactory pubSubFactory, IResolver resolver,
                               IBatchLoggerFactory loggerFactory, IProcessRepository registeredProcesses,
                               ProcessVolumePipeline volumePipeline) : base("WatchDog", logger)
        {
            _stateManager           = stateManager;
            _batchEngineSubscribers = batchEngineSubscribers;
            _cacheAside             = cacheAside;
            _eventAggregator        = eventAggregator;
            _storage             = storage;
            _pubSubFactory       = pubSubFactory;
            _resolver            = resolver;
            _loggerFactory       = loggerFactory;
            _registeredProcesses = registeredProcesses;
            _volumePipeline      = volumePipeline;
            _groupsHandler       = new GroupsHandler(logger, batchEngineSubscribers, stateManager, serializersFactory, entityFactory, resolver, loggerFactory);
            Interval             = TimeSpan.FromMinutes(3);

            _subGroupRemoved = eventAggregator.Subscribe4Broadcast <ProcessGroupRemovedMessage>(RemoveGroup);
            _subRem          = eventAggregator.Subscribe <TextMessage>(ProcessRemoved, Constants.EventProcessFinished);

            _serializer = SerializersFactory.Instance.GetSerializer(typeof(GroupMessage));

            this._volumeGenSub = eventAggregator.Subscribe <TextMessage>(OnVolumeGenerated, Constants.EventProcessVolumeGenerated);
            _checkGroupSub     =
                eventAggregator.Subscribe <TextMessage>(CheckProcessGroup, Constants.EventCheckGroupCommand);
            _retrySub     = eventAggregator.Subscribe <TextMessage>(OnVolumeGenerated, Constants.EventProcessRetry);
            _healthSub    = eventAggregator.Subscribe4Broadcast <HealthMessage>(PublishHealth);
            _systemLogger = _loggerFactory.GetSystemLogger();

            this._processAddedSub = eventAggregator.Subscribe <TextMessage>(OnProcessGroupAdded, Constants.EventProcessGroupAdded);
            _volErrorSub          = eventAggregator.Subscribe <VolumeErrorMessage>(OnProcessVolumeError);
        }
Exemplo n.º 2
0
        public Bus(IEntityFactory entityFactory, IVolumeHandler volumeHandler, IPubSubFactory pubSubFactory, IStateManager stateManager, IProcessDataStorage storage,
                   IDistributedMutexFactory distributedMutexFactory, IResolver resolver, IBatchLoggerFactory batchLoggerFactory)
        {
            EntityFactory           = entityFactory;
            VolumeHandler           = volumeHandler;
            PubSubFactory           = pubSubFactory;
            _stateManager           = stateManager;
            _storage                = storage;
            DistributedMutexFactory = distributedMutexFactory;
            _resolver               = resolver;
            _batchLoggerFactory     = batchLoggerFactory;
            _cts = new CancellationTokenSource();
            _cancellationToken = _cts.Token;
            HookExceptionEvents();

            _logger         = batchLoggerFactory.GetSystemLogger();
            EventAggregator = new TinyEventAggregator();

            var wrapper = new BusStateManager(_stateManager, _logger, resolver);

            _stateManager = wrapper;

            var originalStorage = _storage;

            _storage = new CacheBusWrapper(_logger, originalStorage, resolver);
            _cacheCommandPipeline = new CacheStoragePipeline(_logger, _cancellationToken, originalStorage);


            _cacheAside = new CacheAside(_stateManager, _storage, EventAggregator, _logger, batchLoggerFactory);

            _processRepository = _resolver.Resolve <IProcessRepository>();
            //var taskListener = resolver.Resolve<ITaskListener>();
            //if (!ReferenceEquals(taskListener, _processRepository))
            //{
            //    Console.WriteLine("ALERT");
            //}

            _taskExecutorsRepo = new TaskExecutorsPool(_logger, _cacheAside, _cancellationToken, _stateManager, _processRepository, EventAggregator, resolver, _logger);


            //BuildCommandHandlerPipeline();
            _statePersistencePipeline = new StatePersistencePipeline(_logger, _cancellationToken);
            this._databasePipeline    = new DatabasePipeline(_logger, _cancellationToken, 0);//todo 500

            _taskProcessorPipeline = GetTaskProcessorPipeLine();
            //_grouPipeline=new GroupHandlerPipeline(_stateManager, _logger, _branchEngineSubscriber);

            //_volumePipeline = new ProcessVolumePipeline(_cancellationToken, _logger, _stateManager, _cacheAside, _processRepository, VolumeHandler, resolver, EventAggregator, _branchEngineSubscriber);
            _branchEngineSubscriber = new BatchEngineSubscribers();

            //_watchDog = new ProcessWatchDog(_logger, StateManager, _branchEngineSubscriber, _cacheAside, SerializersFactory.Instance, EntityFactory, EventAggregator, Storage);
            //watchDog.Start(_cancellationToken);//todo
            // _grouPipeline = new Pipeline<GroupMessage>(_watchDog);
            //_watchDogPipeline = new Pipeline<IWatchDogMessage>(_watchDog);

            _taskProducer = new TaskProducerWorker(_logger, _cacheAside, VolumeHandler, resolver, batchLoggerFactory);

            _leaderManager = DistributedMutexFactory.CreateDistributedMutex(NodeSettings.Instance.LockKey, RunLocalWatchDog, () => SwitchToPubSubWatchDog(null), batchLoggerFactory.GetSystemLogger());
        }
Exemplo n.º 3
0
 public GroupsHandler(ILogger logger, IBatchEngineSubscribers batchEngineSubscribers, IStateManager stateManager,
                      ISerializersFactory serializersFactory, IEntityFactory entityFactory, IResolver resolver, IBatchLoggerFactory loggerFactory)
 {
     _logger = logger;
     _batchEngineSubscribers = batchEngineSubscribers;
     _stateManager           = stateManager;
     _serializersFactory     = serializersFactory;
     _entityFactory          = entityFactory;
     _resolver      = resolver;
     _loggerFactory = loggerFactory;
 }
Exemplo n.º 4
0
            //private readonly Action<ProcessExecutionContext, bool> _invokeProcessCompletion;


            public VolumeGenerator(IBaseProcess process, IStateManager stateManager, IVolumeHandler volumeHandler,
                                   IResolver resolver, CancellationToken cancellationToken, IProcessRepository registeredProcesses,
                                   IBatchEngineSubscribers batchEngineSubscribers, IFrameworkLogger logger)
            {
                _process                = process;
                _stateManager           = stateManager;
                this._volumeHandler     = volumeHandler;
                _resolver               = resolver;
                _cancellationToken      = cancellationToken;
                _registeredProcesses    = registeredProcesses;
                _batchEngineSubscribers = batchEngineSubscribers;
                _logger = logger;
            }
Exemplo n.º 5
0
 public ProcessVolumeRequestHandler(IFrameworkLogger logger, IStateManager stateManager, ICacheAside cacheAside,
                                    IProcessRepository registeredProcesses, IVolumeHandler volumeHandler, CancellationToken token,
                                    IResolver resolver, IEventAggregator eventAggregator, IBatchEngineSubscribers batchEngineSubscribers)
 {
     _logger              = logger;
     _stateManager        = stateManager;
     _cacheAside          = cacheAside;
     _registeredProcesses = registeredProcesses;
     _volumeHandler       = volumeHandler;
     _token                  = token;
     _resolver               = resolver;
     _eventAggregator        = eventAggregator;
     _batchEngineSubscribers = batchEngineSubscribers;
 }
Exemplo n.º 6
0
        internal static bool CanRetryProcess(this IReadWritableProcessState state,
                                             IProcessExecutionContext executionContext,
                                             ILogger processLogger, IProcessRepository registeredProcesses,
                                             IBatchEngineSubscribers batchEngineSubscribers, IStateManager stateManager, IFrameworkLogger fLogger,
                                             out bool stop, out string stopMessage)
        {
            stop        = false;
            stopMessage = string.Empty;

            var process = registeredProcesses.GetRegisteredProcesses().FirstOrDefault(p => p.ProcessKey == executionContext.Configuration.ProcessKey);

            ProcessRetryContext context = new ProcessRetryContext(state.Id, state.ProcessId, processLogger, executionContext);

            process?.InvokeProcessRetry(context);

            if (context.StopFlag)
            {
                processLogger.Warn("Retry stopped by process class {processType}", process?.GetType());

                //state.MarkProcessStatus(CompletionStatus.Finished, ResultStatus.Error,
                //    "Retry stopped by process class", stateManager, registeredProcesses, executionContext, batchEngineSubscribers, fLogger);
                stopMessage = "Retry stopped by process class";
                stop        = true;
                return(false);
            }

            foreach (var processSubscriber in batchEngineSubscribers.GetProcessSubscribers().Where(s => s.ProcessKey == context.Configuration.ProcessKey))
            {
                Robustness.Instance.SafeCall(() => processSubscriber.OnProcessRetry(context),
                                             executionContext.Logger);
                if (context.StopFlag)
                {
                    processLogger.Warn($"Retry stopped by extension {processSubscriber.GetType()}");
                    stop        = true;
                    stopMessage = $"Retry stopped by extension {processSubscriber.GetType()}";

                    //state.MarkProcessStatus(CompletionStatus.Finished, ResultStatus.Error,
                    //    $"Retry stopped by extension {processSubscriber.GetType()}", stateManager, registeredProcesses, executionContext, batchEngineSubscribers, fLogger);

                    //_eventAggregator.Publish(this, Constants.EventProcessStop,
                    //    processId.ToString());

                    return(false);
                }
            }

            return(true);
        }
Exemplo n.º 7
0
 public GroupCommandHandler(ILogger logger, IBatchEngineSubscribers batchEngineSubscribers, IStateManager stateManager)
 {
     _logger = logger;
     this._batchEngineSubscribers = batchEngineSubscribers;
     _stateManager = stateManager;
 }
Exemplo n.º 8
0
 public ProcessVolumePipeline(CancellationToken token, IFrameworkLogger logger, IStateManager stateManager,
                              ICacheAside cacheAside, IProcessRepository processRepository, IVolumeHandler volumeHandler,
                              IResolver resolver, IEventAggregator eventAggregator, IBatchEngineSubscribers batchEngineSubscribers)
     : base(new ProcessVolumeRequestHandler(logger, stateManager, cacheAside, processRepository, volumeHandler,
                                            token, resolver, eventAggregator, batchEngineSubscribers))
 {
     RegisterFeatureDecorator(new ConsumerFilter <ProcessExecutionContext>(token, logger, "VolumeGeneratorConsumer"));
 }
Exemplo n.º 9
0
        public static void MarkAsError(this ProcessExecutionContext context, IStateManager stateManager,
                                       string errorMessage, IProcessRepository registeredProcesses, IBatchEngineSubscribers batchEngineSubscribers,
                                       IFrameworkLogger fLogger)
        {
            context.Logger.Error(errorMessage);
            context.WritableProcessState.Status       = CompletionStatus.Finished;
            context.WritableProcessState.Result       = ResultStatus.Error;
            context.WritableProcessState.CompleteTime = DateTime.UtcNow;
            stateManager.SaveProcess(context.WritableProcessState);

            context.WritableProcessState.TriggerProcessEvents(registeredProcesses, context, true, context.ProcessState.IsStopped, batchEngineSubscribers, fLogger, errorMessage);
        }
Exemplo n.º 10
0
        static void TriggerProcessEvents(this IReadWritableProcessState state, IProcessRepository registeredProcesses, IProcessExecutionContext context,
                                         bool isFailed, bool isStopped, IBatchEngineSubscribers batchEngineSubscribers, IFrameworkLogger fLogger, string reason)
        {
            var process = registeredProcesses.GetRegisteredProcesses().FirstOrDefault(p => p.ProcessKey == context.Configuration.ProcessKey);
            //var context = _cacheAside.GetProcessExecutionContext(state.Id);
            //process?.InvokeProcessCompeteEvent(context, isFailed);

            var subscribers = batchEngineSubscribers.GetProcessSubscribers().Where(p => p.ProcessKey == context.Configuration.ProcessKey);
            //ProcessRetryContext ct =new ProcessRetryContext(context.ProcessState.Id, context.ProcessState.ProcessKey, context.Logger);
            ProcessCompleteContext ct = new ProcessCompleteContext(context.ProcessState.Id, context.ProcessState.ProcessId, false, false, context.Logger);

            //IProcessCompleteContext ctx=new proccom
            ProcessStoppedContext processStoppedContext = null;

            foreach (var subscriber in subscribers)
            {
                if (isFailed)
                {
                    Robustness.Instance.SafeCall(() =>
                                                 subscriber.ProcessFailed(ct)
                                                 , fLogger);
                }
                else if (isStopped)
                {
                    if (processStoppedContext == null)
                    {
                        processStoppedContext = new ProcessStoppedContext(state.Id, state.ProcessId, context.Configuration.ProcessKey, reason, context.Logger);
                    }

                    var stoppedContext = processStoppedContext;//access to modified closure
                    Robustness.Instance.SafeCall(() =>
                                                 subscriber.OnProcessStop(stoppedContext)
                                                 , fLogger);
                }
                else
                {
                    Robustness.Instance.SafeCall(() =>
                                                 subscriber.OnProcessComplete(ct)
                                                 , fLogger);
                }
            }

            if (isStopped)
            {
                Robustness.Instance.SafeCall(() =>
                {
                    if (processStoppedContext == null)
                    {
                        processStoppedContext = new ProcessStoppedContext(state.Id, state.ProcessId, context.Configuration.ProcessKey, reason, context.Logger);
                    }

                    process?.ProcessStopped(processStoppedContext);
                });
            }
            else if (isFailed)
            {
                Robustness.Instance.SafeCall(() =>
                {
                    process?.ProcessFailed(context);
                });
            }
            else
            {
                Robustness.Instance.SafeCall(() =>
                {
                    process?.ProcessCompleted(context);
                });
            }

            Robustness.Instance.SafeCall(() =>
            {
                process?.ProcessFinalizer(context);
            });
        }
Exemplo n.º 11
0
        public static void MarkProcessStatus(this IReadWritableProcessState state, CompletionStatus completionStatus,
                                             ResultStatus result, string reason, IStateManager stateManager, IProcessRepository registeredProcesses,
                                             IProcessExecutionContext executionContext, IBatchEngineSubscribers batchEngineSubscribers,
                                             IFrameworkLogger fLogger)
        {
            state.Status = completionStatus;
            state.Result = result;
            if (completionStatus.IsDone())
            {
                state.CompleteTime = DateTime.UtcNow;
            }
            state.IsFinished = completionStatus.Id == CompletionStatus.Finished.Id;
            state.IsStopped  = completionStatus.Id == CompletionStatus.Stopped.Id;

            stateManager.SaveProcess(state);

            state.TriggerProcessEvents(registeredProcesses, executionContext, result.Id == ResultStatus.Error.Id, state.IsStopped,
                                       batchEngineSubscribers, fLogger, reason);
        }