public static void UpdateActivity(IndexingActivity activity)
{
using (var context = new IndexingDataContext())
{
context.CommandTimeout = RepositoryConfiguration.SqlCommandTimeout;
context.IndexingActivities.Attach(activity, true);
context.SubmitChanges();
}
}
public static void RegisterActivity(IndexingActivity activity)
{
using (var context = new IndexingDataContext())
{
context.CommandTimeout = RepositoryConfiguration.SqlCommandTimeout;
context.IndexingActivities.InsertOnSubmit(activity);
context.SubmitChanges();
}
}
public static void RegisterActivity(IndexingActivity activity)
{
using (var context = new IndexingDataContext())
{
context.CommandTimeout = RepositoryConfiguration.SqlCommandTimeout;
context.IndexingActivities.InsertOnSubmit(activity);
context.SubmitChanges();
}
}
public static void UpdateActivity(IndexingActivity activity)
{
using (var context = new IndexingDataContext())
{
context.CommandTimeout = RepositoryConfiguration.SqlCommandTimeout;
context.IndexingActivities.Attach(activity, true);
context.SubmitChanges();
}
}
public static void RegisterActivity(IndexingActivity activity)
{
var transaction = DataProvider.GetCurrentTransaction();
using (var context = transaction == null ? new IndexingDataContext() : new IndexingDataContext(transaction))
{
context.CommandTimeout = RepositoryConfiguration.SqlCommandTimeout;
context.IndexingActivities.InsertOnSubmit(activity);
context.SubmitChanges();
}
}
public static void ExecuteActivity(IndexingActivity activity, bool waitForComplete, bool distribute)
{
var lucAct = activity.CreateLuceneActivity();
if (distribute)
{
lucAct.Distribute();
}
lucAct.InternalExecute();
if (waitForComplete)
{
lucAct.WaitForComplete();
}
}
internal static LuceneIndexingActivity CreateLucActivity(IndexingActivity activity)
{
switch (activity.ActivityType)
{
case IndexingActivityType.AddDocument:
return LuceneIndexingActivity.CreateFromIndexingActivity<AddDocumentActivity>(activity);
case IndexingActivityType.AddTree:
return LuceneIndexingActivity.CreateFromIndexingActivity<AddTreeActivity>(activity);
case IndexingActivityType.UpdateDocument:
return LuceneIndexingActivity.CreateFromIndexingActivity<UpdateDocumentActivity>(activity);
case IndexingActivityType.RemoveTree:
return LuceneIndexingActivity.CreateFromIndexingActivity<RemoveTreeActivity>(activity);
case IndexingActivityType.RemoveDocument:
return LuceneIndexingActivity.CreateFromIndexingActivity<RemoveDocumentActivity>(activity);
}
throw new ArgumentException("Invalid ActivityType value", activity.ActivityType.ToString());
}
internal static LuceneIndexingActivity CreateLucActivity(IndexingActivity activity)
{
switch (activity.ActivityType)
{
case IndexingActivityType.AddDocument:
return(LuceneIndexingActivity.CreateFromIndexingActivity <AddDocumentActivity>(activity));
case IndexingActivityType.AddTree:
return(LuceneIndexingActivity.CreateFromIndexingActivity <AddTreeActivity>(activity));
case IndexingActivityType.UpdateDocument:
return(LuceneIndexingActivity.CreateFromIndexingActivity <UpdateDocumentActivity>(activity));
case IndexingActivityType.RemoveTree:
return(LuceneIndexingActivity.CreateFromIndexingActivity <RemoveTreeActivity>(activity));
case IndexingActivityType.RemoveDocument:
return(LuceneIndexingActivity.CreateFromIndexingActivity <RemoveDocumentActivity>(activity));
}
throw new ArgumentException("Invalid ActivityType value", activity.ActivityType.ToString());
}
partial void InsertIndexingActivity(IndexingActivity instance);
public void Indexing_ExecuteLostIndexingActivities()
{
lock (LuceneManager._executingUnprocessedIndexingActivitiesLock) // make sure indexhealthmonitor will not overlap
{
var initInfo = InitCarsForUnprocessedTests();
var carlist = initInfo.Item1;
var lastActivityId = initInfo.Item2;
var expectedLastActivityId = initInfo.Item3;
// generate a gap and delete corresponding documents from index
var activities = GetCarActivities(lastActivityId);
var activitiesToDelete = new IndexingActivity[] { activities[0], activities[2], activities[5], activities[7], activities[8] };
MissingActivityHandler.SetGap(activitiesToDelete.Select(a => a.IndexingActivityId).ToList()); // 0,2,5,7,8 will be missing
// commit gap and maxactivityid to the index
EnsureWriterHasChanges();
LuceneManager.Commit(true);
foreach (var activity in activitiesToDelete)
{
DeleteVersionFromIndex(activity.VersionId);
DeleteVersionIdFromIndexingHistory(activity.VersionId);
}
// check: cars deleted can NOT be found in the index
for (var i = 0; i < carlist.Count; i++)
{
var id = carlist[i].Id;
if (activitiesToDelete.Select(a => a.NodeId).Contains(id))
Assert.IsFalse(CheckCarInIndex(id), "Deleted car can still be found in the index."); // deleted car should not be in index
else
Assert.IsTrue(CheckCarInIndex(id), "Untouched car can not be found in the index."); // untouched car should still be in index
}
// make sure to move current gap to oldest gap, since always the oldest gap will get processed
for (var i = 0; i < MissingActivityHandler.GapSegments - 1; i++)
MissingActivityHandler.GetOldestGapAndMoveToNext();
// execute unprocessed indexing tasks
LuceneManager.ExecuteLostIndexingActivities();
// check: all cars can be found in the index again
for (var i = 0; i < carlist.Count; i++)
{
Assert.IsTrue(CheckCarInIndex(carlist[i].Id), "ExecuteLostIndexingActivities did not repair lost document.");
}
Assert.AreEqual(expectedLastActivityId, MissingActivityHandler.MaxActivityId, "Maxtaskid is not what is expected.");
Assert.AreEqual(0, MissingActivityHandler.GetGap().Count, "Gap size is not 0.");
}
}
public static void ExecuteActivityDirect(IndexingActivity activity)
{
var lucAct = activity.CreateLuceneActivity();
lucAct.Execute();
}
partial void UpdateIndexingActivity(IndexingActivity instance);
partial void InsertIndexingActivity(IndexingActivity instance);
partial void DeleteIndexingActivity(IndexingActivity instance);
public static void ExecuteActivity(IndexingActivity activity, bool waitForComplete, bool distribute)
{
var lucAct = activity.CreateLuceneActivity();
//TODO: we need to call waitmultiple here
if (distribute)
lucAct.Distribute();
lucAct.InternalExecute();
if (waitForComplete)
lucAct.WaitForComplete();
}
partial void UpdateIndexingActivity(IndexingActivity instance);
public static void ExecuteActivityDirect(IndexingActivity activity)
{
var lucAct = activity.CreateLuceneActivity();
lucAct.Execute();
}
private static void ExecuteActivity(IndexingActivity activity)
{
IndexingActivityManager.RegisterActivity(activity);
IndexingActivityManager.ExecuteActivity(activity, true, true);
}
partial void DeleteIndexingActivity(IndexingActivity instance);
[Description("An activity execution with update activity after delete activity not throws any exception.")] // ??
public void Indexing_ActivitesWithMissingVersion()
{
var content = Content.CreateNew("Car", TestRoot, "Car_Indexing_ActivitesWithMissingVersion");
var handler = (GenericContent)content.ContentHandler;
//handler.VersioningMode = VersioningType.None;
content.Save();
var id = content.Id;
LuceneManager.ApplyChanges();
IndexingActivity[] act = new IndexingActivity[3];
act[0] = new IndexingActivity
{
ActivityType = IndexingActivityType.RemoveDocument,
NodeId = _fakeId,
VersionId = _fakeId
};
act[1] = new IndexingActivity
{
ActivityType = IndexingActivityType.UpdateDocument,
NodeId = _fakeId,
VersionId = _fakeId
};
act[2] = new IndexingActivity
{
ActivityType = IndexingActivityType.AddDocument,
NodeId = _fakeId,
VersionId = _fakeId
};
try
{
using (var context = new IndexingDataContext())
{
foreach (var a in act)
{
context.IndexingActivities.InsertOnSubmit(a);
context.SubmitChanges();
}
}
var max = 0;
var activities = IndexingActivityManager.GetUnprocessedActivities(act[2].IndexingActivityId - 1, out max);
foreach (var a in activities)
IndexingActivityManager.ExecuteActivityDirect(a);
}
finally
{
RemoveFakeTestActivity();
}
}
private static void ExecuteActivity(IndexingActivity activity)
{
IndexingActivityManager.RegisterActivity(activity);
IndexingActivityManager.ExecuteActivity(activity, true, true);
}