void Application_Start(object sender, EventArgs e) { RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); var cancellationToken = new CancellationToken(); var scheduledTaskDeamon = new Task(token => { var taskList = new IPeriodicTask[] { new SendEmailPeriodicTask(), new CheckDatabasePeriodicTask() }; foreach (var scheduledTask in taskList) { var timer = new System.Timers.Timer(scheduledTask.RunInterval); timer.Elapsed += (o, args) => { scheduledTask.TaskStart(); timer.Start(); }; timer.AutoReset = false; timer.Start(); } }, cancellationToken); scheduledTaskDeamon.Start(); }
/// <summary> /// Initializes this text log file. /// </summary> /// <param name="taskScheduler"></param> /// <param name="fileName"></param> /// <param name="format"></param> /// <param name="encoding"></param> internal StreamingTextLogSource(ITaskScheduler taskScheduler, string fileName, ILogFileFormat format, Encoding encoding) { _taskScheduler = taskScheduler; _encoding = encoding; _listeners = new LogSourceListenerCollection(this); _sourceDoesNotExist = new SourceDoesNotExist(fileName); _sourceCannotBeAccessed = new SourceCannotBeAccessed(fileName); _fileName = fileName ?? throw new ArgumentNullException(nameof(fileName)); _index = new LogBufferList(StreamingTextLogSource.LineOffsetInBytes); _propertiesBuffer = new PropertiesBufferList(); _propertiesBuffer.SetValue(Core.Properties.Name, _fileName); _propertiesBuffer.SetValue(Core.Properties.Format, format); _propertiesBuffer.SetValue(TextProperties.RequiresBuffer, true); _propertiesBuffer.SetValue(TextProperties.LineCount, 0); _properties = new ConcurrentPropertiesList(Core.Properties.Minimum); SynchronizeProperties(); _cancellationTokenSource = new CancellationTokenSource(); _columns = new IColumnDescriptor[] { Core.Columns.Index, StreamingTextLogSource.LineOffsetInBytes, Core.Columns.RawContent }; _pendingReadRequests = new ConcurrentQueue <IReadRequest>(); _fileScanTask = _taskScheduler.StartPeriodic(() => RunFileScan(_cancellationTokenSource.Token)); _fileReadTask = _taskScheduler.StartPeriodic(() => RunFileRead(_cancellationTokenSource.Token)); }
public LogSourceSearch(ITaskScheduler taskScheduler, ILogSource logSource, string searchTerm, TimeSpan maximumWaitTime) { if (taskScheduler == null) { throw new ArgumentNullException(nameof(taskScheduler)); } if (logSource == null) { throw new ArgumentNullException(nameof(logSource)); } if (string.IsNullOrEmpty(searchTerm)) { throw new ArgumentException("searchTerm may not be empty"); } _logSource = logSource; _filter = new SubstringFilter(searchTerm, true); _matches = new List <LogMatch>(); _syncRoot = new object(); _listeners = new LogFileSearchListenerCollection(this); _pendingModifications = new ConcurrentQueue <LogSourceModification>(); _scheduler = taskScheduler; const int maximumLineCount = 1000; _maximumWaitTime = maximumWaitTime; _logLinesArray = new LogBufferArray(maximumLineCount, Columns.Index, Columns.RawContent); _matchesBuffer = new List <LogLineMatch>(); _logSource.AddListener(this, _maximumWaitTime, maximumLineCount); _task = _scheduler.StartPeriodic(FilterAllPending, TimeSpan.FromMilliseconds(100), string.Format("Search {0}", logSource)); }
public LogFileSearch(ITaskScheduler taskScheduler, ILogFile logFile, string searchTerm, TimeSpan maximumWaitTime) { if (taskScheduler == null) throw new ArgumentNullException("taskScheduler"); if (logFile == null) throw new ArgumentNullException("logFile"); if (string.IsNullOrEmpty(searchTerm)) throw new ArgumentException("searchTerm may not be empty"); _logFile = logFile; _filter = new SubstringFilter(searchTerm, true); _matches = new List<LogMatch>(); _syncRoot = new object(); _listeners = new LogFileSearchListenerCollection(this); _pendingModifications = new ConcurrentQueue<LogFileSection>(); _scheduler = taskScheduler; const int maximumLineCount = 1000; _maximumWaitTime = maximumWaitTime; _logLinesBuffer = new LogLine[maximumLineCount]; _matchesBuffer = new List<LogLineMatch>(); _logFile.AddListener(this, _maximumWaitTime, maximumLineCount); _task = _scheduler.StartPeriodic(FilterAllPending, TimeSpan.FromMilliseconds(100), string.Format("Search {0}", logFile)); }
public EventsLogAnalyser(ITaskScheduler scheduler, ILogFile source, TimeSpan maximumWaitTime, EventsLogAnalyserConfiguration configuration) { if (scheduler == null) { throw new ArgumentNullException(nameof(scheduler)); } if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } _scheduler = scheduler; _source = source; _buffer = new LogLine[MaximumLineCount]; _events = new InMemoryLogTable(); _indices = new List <LogLineIndex>(); _eventDefinitions = new List <LogEventDefinition>(configuration.Events.Count); _eventDefinitions.AddRange(configuration.Events.Select(TryCreateDefinition).Where(x => x != null)); _modifications = new ConcurrentQueue <LogFileSection>(); _source.AddListener(this, maximumWaitTime, MaximumLineCount); _task = _scheduler.StartPeriodic(DoWork, TimeSpan.FromMilliseconds(100)); }
public async Task Start(ParseMessage parseMessage) { _source = new CancellationTokenSource(); PeriodicTaskAction <object, CancellationToken> keepChannel = (async(object o, CancellationToken t) => { if (_webSocketClient == null) { _webSocketClient = new ClientWebSocket(); _webSocketClient.Options.KeepAliveInterval = new TimeSpan(keepAliveSocketInterval * TimeSpan.TicksPerSecond); await SocketConnect(parseMessage); } else if (_webSocketClient.State != WebSocketState.Open && _webSocketClient.State != WebSocketState.Connecting) { _webSocketClient.Dispose(); _webSocketClient = new ClientWebSocket(); _webSocketClient.Options.KeepAliveInterval = new TimeSpan(keepAliveSocketInterval * TimeSpan.TicksPerSecond); await SocketConnect(parseMessage); } } ); tickerchnl = new PeriodicTaskWrapper(_logger, _name); await tickerchnl.Start(keepChannel, new PeriodicTaskParams { period = (int)keepAliveSecs * 1000 }, _source.Token); }
private static IDisposable SyncRepeatObservable(IPeriodicTask schedule) { return(Observable .FromAsync(schedule.StartJob) .Delay(schedule.Interval) .Repeat() .TakeWhile(e => e) .Subscribe()); }
public PeriodicCacheCleaner(InProcSessionsConfiguration configuration, IInProcSessionCache sessionCache, IPeriodicTaskFactory periodicTaskFactory, ICancellationTokenSourceFactory cancellationTokenSourceFactory) { if (configuration == null) throw new ArgumentNullException("configuration"); if (sessionCache == null) throw new ArgumentNullException("sessionCache"); if (periodicTaskFactory == null) throw new ArgumentNullException("periodicTaskFactory"); if (cancellationTokenSourceFactory == null) throw new ArgumentNullException("cancellationTokenSourceFactory"); _configuration = configuration; _cancellationTokenSourceFactory = cancellationTokenSourceFactory; _periodicTask = periodicTaskFactory.Create(sessionCache.Trim); }
/// <summary> /// Construtor da classe, que recebe a tarefa a ser controlada e seus parâmetros de execução. /// Adicionalmente recebe o intervalo de execução da tarefa e o mecanismo de acesso ao banco. /// </summary> public JobController(IPeriodicTask task, NameValueCollection taskParams, DataAccess dataAccess, double interval) { this.taskList = new List <IPeriodicTask>(); this.taskList.Add(task); this.taskParams = taskParams; this.dataAccess = dataAccess; jobTrigger = new Timer(interval); jobTrigger.Elapsed += new ElapsedEventHandler(OnTimerEvent); jobTrigger.Enabled = false; }
/// <summary> /// </summary> /// <param name="scheduler"></param> /// <param name="fileName"></param> internal EventLogSource(ITaskScheduler scheduler, string fileName) { _scheduler = scheduler; _fileName = fileName; _buffer = new InMemoryLogSource(); _buffer.SetValue(Core.Properties.Created, DateTime.Now); _cancellationTokenSource = new CancellationTokenSource(); _readTask = _scheduler.StartPeriodic(RunOnce, ToString()); }
public LogFileProxy(ITaskScheduler taskScheduler, TimeSpan maximumWaitTime) { if (taskScheduler == null) throw new ArgumentNullException("taskScheduler"); _taskScheduler = taskScheduler; _pendingSections = new ConcurrentQueue<KeyValuePair<ILogFile, LogFileSection>>(); _listeners = new LogFileListenerCollection(this); _task = _taskScheduler.StartPeriodic(RunOnce, "Log File Proxy"); _maximumWaitTime = maximumWaitTime; }
public PeriodicCacheCleanerFixture() { _fakeSessionCache = A.Fake<IInProcSessionCache>(); _fakePeriodicTaskFactory = A.Fake<IPeriodicTaskFactory>(); _fakePeriodicTask = A.Fake<IPeriodicTask>(); _fakeCancellationTokenSourceFactory = A.Fake<ICancellationTokenSourceFactory>(); _validConfiguration = new InProcSessionsConfiguration(); _cancellationTokenSource = new CancellationTokenSource(); A.CallTo(() => _fakeCancellationTokenSourceFactory.Create()).Returns(_cancellationTokenSource); A.CallTo(() => _fakePeriodicTaskFactory.Create(A<Action>._)).Returns(_fakePeriodicTask); _periodicCacheCleaner = new PeriodicCacheCleaner(_validConfiguration, _fakeSessionCache, _fakePeriodicTaskFactory, _fakeCancellationTokenSourceFactory); }
public void Register(IPeriodicTask task, TimeSpan period) { lock (lockObject) { if (tasks.ContainsKey(task.Id)) { return; } var executor = new ThreadBasedPeriodicTaskExecutor(task, period, logger); executor.Start(); tasks.Add(task.Id, executor); } }
public PeriodicCacheCleanerFixture() { _fakeSessionCache = A.Fake <IInProcSessionCache>(); _fakePeriodicTaskFactory = A.Fake <IPeriodicTaskFactory>(); _fakePeriodicTask = A.Fake <IPeriodicTask>(); _fakeCancellationTokenSourceFactory = A.Fake <ICancellationTokenSourceFactory>(); _validConfiguration = new InProcSessionsConfiguration(); _cancellationTokenSource = new CancellationTokenSource(); A.CallTo(() => _fakeCancellationTokenSourceFactory.Create()).Returns(_cancellationTokenSource); A.CallTo(() => _fakePeriodicTaskFactory.Create(A <Action> ._)).Returns(_fakePeriodicTask); _periodicCacheCleaner = new PeriodicCacheCleaner(_validConfiguration, _fakeSessionCache, _fakePeriodicTaskFactory, _fakeCancellationTokenSourceFactory); }
public void Start() { lock (_syncRoot) { if (_isDisposed) { Log.WarnFormat("Ignoring Start(): This analysis has already been disposed of"); return; } _analyser = TryCreateAnalyser(); _task = _scheduler.StartPeriodic(OnUpdate, TimeSpan.FromSeconds(0.5), ""); } }
/// <summary> /// Initializes this object. /// </summary> /// <param name="taskScheduler"></param> /// <param name="maximumWaitTime"></param> public LogFileProxy(ITaskScheduler taskScheduler, TimeSpan maximumWaitTime) { if (taskScheduler == null) { throw new ArgumentNullException(nameof(taskScheduler)); } _taskScheduler = taskScheduler; _pendingSections = new ConcurrentQueue <KeyValuePair <ILogFile, LogFileSection> >(); _listeners = new LogFileListenerCollection(this); _task = _taskScheduler.StartPeriodic(RunOnce, "Log File Proxy"); _maximumWaitTime = maximumWaitTime; }
public Generator(ITaskScheduler taskScheduler, ILog log) { if (taskScheduler == null) throw new ArgumentNullException("taskScheduler"); if (log == null) throw new ArgumentNullException("log"); _random = new Random(); _taskScheduler = taskScheduler; _log = log; _messages = CreateMessages(); _task = _taskScheduler.StartPeriodic(Update); }
public PageBufferedLogSource(ITaskScheduler taskScheduler, ILogSource source, TimeSpan maximumWaitTime, IReadOnlyList <IColumnDescriptor> nonCachedColumns, int pageSize = DefaultPageSize, int maxNumPages = DefaultMaxPageCount) { _syncRoot = new object(); _taskScheduler = taskScheduler; _source = source; _maxNumPages = maxNumPages; _listeners = new ProxyLogListenerCollection(source, this); _cachedColumns = source.Columns.Except(nonCachedColumns).ToList(); _buffer = new PagedLogBuffer(pageSize, maxNumPages, _cachedColumns); _fetchQueue = new ConcurrentQueue <LogSourceSection>(); _source.AddListener(this, maximumWaitTime, pageSize); _fetchBuffer = new LogBufferArray(pageSize, _cachedColumns); _fetchTask = _taskScheduler.StartPeriodic(FetchPagesFromSource, maximumWaitTime); }
public LogFileSearchProxy(ITaskScheduler taskScheduler, ILogFile logFile, TimeSpan maximumWaitTime) { if (taskScheduler == null) throw new ArgumentNullException("taskScheduler"); if (logFile == null) throw new ArgumentNullException("logFile"); _pendingMatches = new ConcurrentQueue<KeyValuePair<ILogFileSearch, List<LogMatch>>>(); _logFile = logFile; _listeners = new List<ILogFileSearchListener>(); _taskScheduler = taskScheduler; _syncRoot = new object(); _matches = new List<LogMatch>(); _maximumWaitTime = maximumWaitTime; _task = _taskScheduler.StartPeriodic(RunOnce, _maximumWaitTime, "Search Proxy"); }
private void UpdateFolderScan() { // Folder scans shall only be performed when the panel is selected (and thus visible to the user). // If the user doesn't see the panel then we don't really need to know what happened inside // the folder... if (IsSelected) { _snapshotScanTask = _taskScheduler.StartPeriodic(ScanSnapshotsFolder, TimeSpan.FromSeconds(value: 5), "Snapshot Scan"); } else { _taskScheduler.StopPeriodic(_snapshotScanTask); _snapshotScanTask = null; } }
public Generator(ITaskScheduler taskScheduler, ILog log) { if (taskScheduler == null) { throw new ArgumentNullException(nameof(taskScheduler)); } if (log == null) { throw new ArgumentNullException(nameof(log)); } _random = new Random(); _taskScheduler = taskScheduler; _log = log; _messages = CreateMessages(); _task = _taskScheduler.StartPeriodic(Update); }
private void RunThread(object state) { IPeriodicTask task = (IPeriodicTask)state; while (!_quitting) { task.RunCycle(); Interlocked.Increment(ref _totalCycles); try { Thread.Sleep(_interval); } catch (ThreadInterruptedException) { return; } _mre.WaitOne(); } }
/// <summary> /// Initializes this object. /// </summary> /// <param name="taskScheduler"></param> /// <param name="maximumWaitTime"></param> /// <param name="maxEntryCount"></param> public LogSourceProxy(ITaskScheduler taskScheduler, TimeSpan maximumWaitTime, int maxEntryCount = DefaultMaxEntryCount) { if (taskScheduler == null) { throw new ArgumentNullException(nameof(taskScheduler)); } _taskScheduler = taskScheduler; _properties = new ConcurrentPropertiesList(Core.Properties.Minimum); _properties.SetValue(Core.Properties.EmptyReason, null); _sourceProperties = new PropertiesBufferList(); _pendingSections = new ConcurrentQueue <KeyValuePair <ILogSource, LogSourceModification> >(); _listeners = new LogSourceListenerCollection(this); _task = _taskScheduler.StartPeriodic(RunOnce, "Log File Proxy"); _maximumWaitTime = maximumWaitTime; _maxEntryCount = maxEntryCount; }
public SQLiteLogTable(ITaskScheduler scheduler, LogDataCache cache, string fileName) { if (scheduler == null) throw new ArgumentNullException("scheduler"); if (cache == null) throw new ArgumentNullException("cache"); if (fileName == null) throw new ArgumentNullException("fileName"); _scheduler = scheduler; _cache = cache; _fileName = fileName; _listeners = new LogTableListenerCollection(this); _accessQueue = new LogDataAccessQueue<LogEntryIndex, LogEntry>(); _schema = new SQLiteSchema(string.Empty); _task = _scheduler.StartPeriodic(Update, ToString()); }
public LogSourceSearchProxy(ITaskScheduler taskScheduler, ILogSource logSource, TimeSpan maximumWaitTime) { if (taskScheduler == null) { throw new ArgumentNullException(nameof(taskScheduler)); } if (logSource == null) { throw new ArgumentNullException(nameof(logSource)); } _pendingMatches = new ConcurrentQueue <KeyValuePair <ILogSourceSearch, List <LogMatch> > >(); _logSource = logSource; _listeners = new List <ILogFileSearchListener>(); _taskScheduler = taskScheduler; _syncRoot = new object(); _matches = new List <LogMatch>(); _maximumWaitTime = maximumWaitTime; _task = _taskScheduler.StartPeriodic(RunOnce, _maximumWaitTime, "Search Proxy"); }
public PeriodicCacheCleaner(InProcSessionsConfiguration configuration, IInProcSessionCache sessionCache, IPeriodicTaskFactory periodicTaskFactory, ICancellationTokenSourceFactory cancellationTokenSourceFactory) { if (configuration == null) { throw new ArgumentNullException("configuration"); } if (sessionCache == null) { throw new ArgumentNullException("sessionCache"); } if (periodicTaskFactory == null) { throw new ArgumentNullException("periodicTaskFactory"); } if (cancellationTokenSourceFactory == null) { throw new ArgumentNullException("cancellationTokenSourceFactory"); } _configuration = configuration; _cancellationTokenSourceFactory = cancellationTokenSourceFactory; _periodicTask = periodicTaskFactory.Create(sessionCache.Trim); }
public QuickInfoAnalyser(ITaskScheduler scheduler, ILogFile source, TimeSpan maximumWaitTime, QuickInfoAnalyserConfiguration configuration) { if (scheduler == null) { throw new ArgumentNullException(nameof(scheduler)); } if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } _scheduler = scheduler; _pendingChanges = new ConcurrentQueue <PendingChange>(); _lastMatchingLines = new Dictionary <Guid, LogLine?>(); var logFiles = new Dictionary <ILogFile, Guid>(); _logFiles = logFiles; try { foreach (var pair in configuration.QuickInfos) { var filter = CreateFilter(pair.Value); var filteredLogFile = source.AsFiltered(scheduler, filter, logEntryFilter: null); logFiles.Add(filteredLogFile, pair.Key); _lastMatchingLines.Add(pair.Key, value: null); filteredLogFile.AddListener(this, maximumWaitTime, MaximumLineCount); } } catch (Exception) { Dispose(logFiles.Keys); throw; } _task = scheduler.StartPeriodic(OnUpdate, maximumWaitTime, "Quick Info Analyser"); }
public ChatService(IPeriodicTask periodicTask) { this.periodicTask = periodicTask; }
public ThreadBasedPeriodicTaskExecutor(IPeriodicTask task, TimeSpan period) { this.task = task; this.period = period; }
/// <summary> /// Any subclass MUST call this method in its constructor (preferably after the log file has been initialized, /// as after this call, <see cref="RunOnce" /> will be called. /// </summary> protected virtual void StartTask() { _readTask = _scheduler.StartPeriodic(Run, ToString()); }
public ThreadBasedPeriodicTaskExecutor(IPeriodicTask task, TimeSpan period, ILog logger) { this.task = task; this.period = period; this.logger = logger; }
protected void StartTask() { _readTask = _scheduler.StartPeriodic(Run, ToString()); }