private void RefreshIndexOneNode(Node node)
{
// node index is refreshed only on this node and should not be distributed.
var versionId = node.VersionId;
if (RepositoryInstance.ContentQueryIsAllowed)
{
var activity = CreateActivity(IndexingActivityType.UpdateDocument, node.Id, node.VersionId, node.VersionTimestamp, null, null);
IndexingActivityManager.ExecuteActivity(activity, true, false);
}
}
private static void ProcessTasks(IndexingActivity[] activities, System.IO.TextWriter consoleOut)
{
if (consoleOut != null && activities.Length != 0)
{
consoleOut.Write(" Executing {0} unprocessed tasks ...", activities.Length);
}
foreach (var activity in activities)
{
activity.FromHealthMonitor = true; // make sure adddocument will delete first
IndexingActivityManager.ExecuteActivity(activity, false, false);
}
}
/*======================================================================================================= IIndexPopulator Members */
// caller: IndexPopulator.Populator, Import.Importer, Tests.Initializer, RunOnce
public void ClearAndPopulateAll(bool backup = true)
{
var lastActivityId = IndexingActivityManager.GetLastActivityId();
var commitData = IndexManager.CreateCommitUserData(lastActivityId);
using (var traceOperation = Logger.TraceOperation("IndexPopulator ClearAndPopulateAll"))
{
//-- recreate
var writer = IndexManager.GetIndexWriter(true);
try
{
foreach (var docData in StorageContext.Search.LoadIndexDocumentsByPath("/Root"))
{
var doc = IndexDocumentInfo.GetDocument(docData);
if (doc == null) // indexing disabled
{
continue;
}
writer.AddDocument(doc);
OnNodeIndexed(docData.Path);
}
RepositoryInstance.Instance.ConsoleWrite(" Commiting ... ");
writer.Commit(commitData);
RepositoryInstance.Instance.ConsoleWriteLine("ok");
RepositoryInstance.Instance.ConsoleWrite(" Optimizing ... ");
writer.Optimize();
RepositoryInstance.Instance.ConsoleWriteLine("ok");
}
finally
{
writer.Close();
}
RepositoryInstance.Instance.ConsoleWrite(" Deleting indexing activities ... ");
IndexingActivityManager.DeleteAllActivities();
RepositoryInstance.Instance.ConsoleWriteLine("ok");
if (backup)
{
RepositoryInstance.Instance.ConsoleWrite(" Making backup ... ");
BackupTools.BackupIndexImmediatelly();
RepositoryInstance.Instance.ConsoleWriteLine("ok");
}
traceOperation.IsSuccessful = true;
}
}
internal static void ExecuteLostIndexingActivities()
{
lock (_executingUnprocessedIndexingActivitiesLock)
{
var gap = MissingActivityHandler.GetOldestGapAndMoveToNext();
var i = 0;
while (i * ACTIVITIESFRAGMENTSIZE < gap.Length)
{
var gapSegment = gap.Skip(i * ACTIVITIESFRAGMENTSIZE).Take(ACTIVITIESFRAGMENTSIZE).ToArray();
var activities = IndexingActivityManager.GetUnprocessedActivities(gapSegment);
if (activities.Length > 0)
{
foreach (var act in activities)
{
act.FromHealthMonitor = true;
IndexingActivityManager.ExecuteActivity(act, false, false);
}
}
i++;
}
}
}
private static void ExecuteActivity(IndexingActivity activity)
{
IndexingActivityManager.RegisterActivity(activity);
IndexingActivityManager.ExecuteActivity(activity, true, true);
}
internal LuceneIndexingActivity CreateLuceneActivity()
{
return(IndexingActivityManager.CreateLucActivity(this));
}
//---- Caller: Startup, ForceRestore
internal static void ExecuteUnprocessedIndexingActivities(System.IO.TextWriter consoleOut)
{
lock (_executingUnprocessedIndexingActivitiesLock)
{
try
{
_executingUnprocessedIndexingActivities = true;
CommitUserData cud;
using (var readerFrame = LuceneManager.GetIndexReaderFrame())
{
cud = IndexManager.ReadCommitUserData(readerFrame.IndexReader);
}
MissingActivityHandler.MaxActivityId = cud.LastActivityId;
MissingActivityHandler.SetGap(cud.Gap);
var logProps = new Dictionary <string, object> {
{ "LastActivityID", cud.LastActivityId }, { "Size of gap", cud.Gap.Count }
};
Logger.WriteInformation("Executing unprocessed indexing activities from the stored commit point.",
Logger.EmptyCategoryList, logProps);
var i = 0;
var sumCount = 0;
// This loop was created to avoid loading too many activities at once that are present in the gap.
while (i * ACTIVITIESFRAGMENTSIZE <= cud.Gap.Count)
{
// get activities from the DB that are in the current gap fragment
var gapSegment = cud.Gap.Skip(i * ACTIVITIESFRAGMENTSIZE).Take(ACTIVITIESFRAGMENTSIZE).ToArray();
var activities = IndexingActivityManager.GetUnprocessedActivities(gapSegment);
ProcessTasks(activities, consoleOut);
sumCount += activities.Length;
i++;
}
// Execute activities where activity id is bigger than than our last (activity) task id
var maxIdInDb = 0;
var newtasks = IndexingActivityManager.GetUnprocessedActivities(MissingActivityHandler.MaxActivityId, out maxIdInDb, ACTIVITIESFRAGMENTSIZE);
while (newtasks.Length > 0)
{
ProcessTasks(newtasks, consoleOut);
sumCount += newtasks.Length;
//load the remaining activities, but only if they were created before this operation started
var tempMax = 0;
newtasks = IndexingActivityManager.GetUnprocessedActivities(MissingActivityHandler.MaxActivityId, out tempMax, ACTIVITIESFRAGMENTSIZE, maxIdInDb);
}
if (consoleOut != null)
{
consoleOut.WriteLine("ok.");
}
logProps.Add("Processed tasks", sumCount);
//write the latest max activity id and gap size to log
logProps["LastActivityID"] = MissingActivityHandler.MaxActivityId;
logProps["Size of gap"] = MissingActivityHandler.GetGap().Count;
Logger.WriteInformation("Executing unprocessed tasks is finished.", Logger.EmptyCategoryList, logProps);
}
finally
{
_executingUnprocessedIndexingActivities = false;
}
}
}
