public IndexManager(IDataStore dataStore, ISearchManager searchManager)
{
_dataStore = dataStore;
_searchManager = searchManager;
DistributedIndexingActivityQueue = new DistributedIndexingActivityQueue(this);
CentralizedIndexingActivityQueue = new CentralizedIndexingActivityQueue();
}
/// <summary>
/// Generates a history from the recent items.
/// </summary>
/// <returns></returns>
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 = DistributedIndexingActivityQueue.GetCurrentState(),
Recent = list.ToArray()
};
}
return(result);
}
internal Serializer(DistributedIndexingActivityQueue activityQueue,
DependencyManager dependencyManager,
TerminationHistory terminationHistory,
IndexingActivityHistoryController activityHistory
, IndexManager indexManager)
{
_activityQueue = activityQueue;
_dependencyManager = dependencyManager;
_terminationHistory = terminationHistory;
_activityHistory = activityHistory;
_indexManager = indexManager;
}
private static async STT.Task ExecuteDistributedActivityAsync(IndexingActivityBase activity, CancellationToken cancellationToken)
{
SnTrace.Index.Write("ExecuteDistributedActivity: #{0}", activity.Id);
await activity.DistributeAsync(cancellationToken).ConfigureAwait(false);
// 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 (DistributedIndexingActivityQueue.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
DistributedIndexingActivityQueue.ExecuteActivity(activity);
await activity.WaitForCompleteAsync(cancellationToken).ConfigureAwait(false);
}
// for testing purposes we need a parameterless method because ElapsedEventArgs has only internal constructor
private static void Timer_Elapsed()
{
if (SearchManager.ContentQueryIsAllowed)
{
var timerEnabled = _timer.Enabled;
_timer.Enabled = false;
try
{
DistributedIndexingActivityQueue.HealthCheck();
}
catch (Exception ex) // logged
{
SnLog.WriteException(ex);
}
finally
{
_timer.Enabled = timerEnabled;
}
}
}
/// <summary>
/// Initializes the indexing feature: starts the IndexingEngine, CommitManager and indexing activity organizer.
/// If "consoleOut" is not null, writes progress and debug messages into it.
/// </summary>
/// <param name="consoleOut">A <see cref="TextWriter"/> instance or null.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is None.</param>
/// <returns>A Task that represents the asynchronous operation.</returns>
public static async STT.Task StartAsync(TextWriter consoleOut, CancellationToken cancellationToken)
{
await IndexingEngine.StartAsync(consoleOut, cancellationToken).ConfigureAwait(false);
CommitManager = IndexingEngine.IndexIsCentralized
? (ICommitManager) new NoDelayCommitManager()
: new NearRealTimeCommitManager();
SnTrace.Index.Write("LM: {0} created.", CommitManager.GetType().Name);
CommitManager.Start();
if (IndexingEngine.IndexIsCentralized)
{
CentralizedIndexingActivityQueue.Startup(consoleOut);
}
else
{
DistributedIndexingActivityQueue.Startup(consoleOut);
}
}
/// <summary>
/// Shuts down the indexing feature: stops CommitManager, indexing activity organizator and IndexingEngine.
/// </summary>
public static void ShutDown()
{
CommitManager?.ShutDown();
if (IndexingEngine == null)
{
return;
}
if (IndexingEngine.IndexIsCentralized)
{
CentralizedIndexingActivityQueue.ShutDown();
}
else
{
DistributedIndexingActivityQueue.ShutDown();
}
IndexingEngine.ShutDown();
SnLog.WriteInformation("Indexing engine has stopped. Max task id and exceptions: " + DistributedIndexingActivityQueue.GetCurrentCompletionState());
}
/// <summary>
/// Initializes the indexing feature: starts the IndexingEngine, CommitManager and indexing activity organizator.
/// If "consoleOut" is not null, writes progress and debug messages into it.
/// </summary>
/// <param name="consoleOut">A <see cref="TextWriter"/> instance or null.</param>
public static void Start(TextWriter consoleOut)
{
IndexingEngine.Start(consoleOut);
CommitManager = IndexingEngine.IndexIsCentralized
? (ICommitManager) new NoDelayCommitManager()
: new NearRealTimeCommitManager();
SnTrace.Index.Write("LM: {0} created.", CommitManager.GetType().Name);
CommitManager.Start();
if (IndexingEngine.IndexIsCentralized)
{
CentralizedIndexingActivityQueue.Startup(consoleOut);
}
else
{
DistributedIndexingActivityQueue.Startup(consoleOut);
}
}
/// <summary>
/// Resets the history and returns with the starting state.
/// </summary>
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 = DistributedIndexingActivityQueue.GetCurrentState(),
Recent = new IndexingActivityHistoryItem[0]
};
}
return(result);
}
public void ShutDown()
{
CommitManager?.ShutDown();
if (IndexingEngine == null)
{
return;
}
//TODO: [async] rewrite this using async APIs.
if (IndexingEngine.IndexIsCentralized)
{
CentralizedIndexingActivityQueue.ShutDown();
}
else
{
DistributedIndexingActivityQueue.ShutDown();
}
//TODO: [async] rewrite this using async APIs.
IndexingEngine.ShutDownAsync(CancellationToken.None).GetAwaiter().GetResult();
SnLog.WriteInformation("Indexing engine has stopped. Max task id and exceptions: " + DistributedIndexingActivityQueue.GetCurrentCompletionState());
}
public IndexingActivityStatus GetCurrentIndexingActivityStatus()
{
return(DistributedIndexingActivityQueue.GetCurrentCompletionState());
}
public IndexingActivityHistoryController(DistributedIndexingActivityQueue activityQueue)
{
_activityQueue = activityQueue;
}
