//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); }
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()); }
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; }
//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; }
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; }
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); }
public GroupCommandHandler(ILogger logger, IBatchEngineSubscribers batchEngineSubscribers, IStateManager stateManager) { _logger = logger; this._batchEngineSubscribers = batchEngineSubscribers; _stateManager = stateManager; }
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")); }
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); }
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); }); }
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); }