public static IndexingActivityHistory GetHistory() { IndexingActivityHistory result; var list = new List <IndexingActivityHistoryItem>(_history.Length); lock (_lock) { for (int i = _position; i < _history.Length; i++) { if (_history[i] != null) { list.Add(_history[i]); } } for (int i = 0; i < _position; i++) { if (_history[i] != null) { list.Add(_history[i]); } } result = new IndexingActivityHistory() { State = IndexingActivityQueue.GetCurrentState(), Recent = list.ToArray() }; } return(result); }
public static void ExecuteActivity(LuceneIndexingActivity activity, bool waitForComplete, bool distribute) { if (distribute) { activity.Distribute(); } // If there are too many activities in the queue, we have to drop at least the inner // data of the activity to prevent memory overflow. We still have to wait for the // activity to finish, but the inner data can (and will) be loaded from the db when // the time comes for this activity to be executed. if (IndexingActivityQueue.IsOverloaded()) { SnTrace.Index.Write("IAQ OVERLOAD drop activity FromPopulator A:" + activity.Id); activity.IndexDocumentData = null; } // all activities must be executed through the activity queue's API IndexingActivityQueue.ExecuteActivity(activity); if (waitForComplete) { activity.WaitForComplete(); } }
// for testing purposes we need a parameterless method because ElapsedEventArgs has only internal constructor private static void Timer_Elapsed() { if (RepositoryInstance.ContentQueryIsAllowed) { var timerEnabled = _timer.Enabled; _timer.Enabled = false; try { IndexingActivityQueue.HealthCheck(); } catch (Exception ex) // logged { SnLog.WriteException(ex); } finally { _timer.Enabled = timerEnabled; } } }
internal static void HealthCheck() { if (IsWorking()) { SnTrace.Index.Write("IAQ: Health check triggered but ignored."); return; } SnTrace.Index.Write("IAQ: Health check triggered."); var state = TerminationHistory.GetCurrentState(); var gapsLength = state.Gaps.Length; if (gapsLength > 0) { SnTrace.IndexQueue.Write("IAQ: Health checker is processing {0} gap{1}.", gapsLength, gapsLength > 1 ? "s" : ""); foreach (LuceneIndexingActivity activity in new IndexingActivityLoader(state.Gaps, false)) { WaitIfOverloaded(); IndexingActivityQueue.ExecuteActivity(activity); } } var lastId = TerminationHistory.GetLastTerminatedId(); var lastDbId = LuceneManager.GetLastStoredIndexingActivityId(); var newerCount = lastDbId - lastId; if (lastId < lastDbId) { SnTrace.IndexQueue.Write("IAQ: Health checker is processing activities from {0} to {1}", (lastId + 1), lastDbId); foreach (LuceneIndexingActivity activity in new IndexingActivityLoader(lastId + 1, lastDbId, false)) { WaitIfOverloaded(); IndexingActivityQueue.ExecuteActivity(activity); } } }
public static IndexingActivityHistory Reset() { IndexingActivityHistory result; lock (_lock) { for (int i = 0; i < _history.Length; i++) { _history[i] = null; } _position = 0; _unfinished = 0; result = new IndexingActivityHistory() { State = IndexingActivityQueue.GetCurrentState(), Recent = new IndexingActivityHistoryItem[0] }; } return(result); }
private static void Startup(System.IO.TextWriter consoleOut) { // we positively start the message cluster int dummy = SenseNet.ContentRepository.DistributedApplication.Cache.Count; var dummy2 = SenseNet.ContentRepository.DistributedApplication.ClusterChannel; if (SenseNet.ContentRepository.RepositoryInstance.RestoreIndexOnStartup()) { BackupTools.RestoreIndex(false, consoleOut); } CreateWriterAndReader(); IndexingActivityQueue.Startup(consoleOut); Warmup(); var commitStart = new ThreadStart(CommitWorker); var t = new Thread(commitStart); t.Start(); SnTrace.Index.Write("LM: 'CommitWorker' thread started. ManagedThreadId: {0}", t.ManagedThreadId); }
private static void WaitIfOverloaded(bool startProcessing = false) { // We prevent memory overflow by limiting the number of activities that we // keep in memory. This method waits for the queue to be able to process // new activities. var logCount = 1; while (IndexingActivityQueue.IsOverloaded()) { // In case of startup, we have to start processing activities that are // already in the queue so that new ones can be added later. if (startProcessing) { DependencyManager.ActivityEnqueued(); } if (logCount++ % 10 == 1) { SnTrace.Index.Write("IAQ OVERLOAD waiting {0} milliseconds.", IndexingOverloadWaitingTime * 10); } Thread.Sleep(IndexingOverloadWaitingTime); } }
private static void ShutDown(bool log) { if (!_running) { return; } if (Paused) { throw GetPausedException(); } using (var op = SnTrace.Index.StartOperation("LUCENEMANAGER SHUTDOWN")) { if (_writer != null) { _stopCommitWorker = true; lock (_commitLock) Commit(false); using (var op2 = SnTrace.Index.StartOperation("LM.CloseReaders")) { using (var wrFrame = IndexWriterFrame.Get(true)) // // ShutDown { if (_reader != null) { _reader.Close(); } if (_writer != null) { _writer.Close(); } _running = false; } op2.Successful = true; } op.Successful = true; } } if (log) { SnLog.WriteInformation("LuceneManager has stopped. Max task id and exceptions: " + IndexingActivityQueue.GetCurrentCompletionState()); } }
internal static CompletionState GetCurrent() { return(IndexingActivityQueue.GetCurrentCompletionState()); }