private static void Startup(int lastDatabaseId, int lastExecutedId, int[] gaps, System.IO.TextWriter consoleOut)
{
Serializer.Reset();
DependencyManager.Reset();
TerminationHistory.Reset(lastExecutedId, gaps);
Serializer.Start(lastDatabaseId, lastExecutedId, gaps, consoleOut);
}
internal static void Finish(SecurityActivity activity)
{
lock (_waitingSetLock)
{
// activity is done in the ActivityQueue
_waitingSet.Remove(activity);
// terminate and release waiting threads if there is any.
activity.Finish();
// register activity termination in the log.
SecurityActivityHistory.Finish(activity.Id);
// register activity termination.
TerminationHistory.FinishActivity(activity);
// execute all activities that are completely freed.
foreach (var dependentItem in activity.WaitingForMe.ToArray())
{
dependentItem.FinishWaiting(activity);
if (dependentItem.WaitingFor.Count == 0)
{
Task.Run(() => Executor.Execute(dependentItem));
}
}
}
}
/// <summary>
/// Retrieves a generic collection of all verifications of terminated candidacy on record for the specified candidate and election cycle.
/// </summary>
/// <param name="candidateID">The ID of the candidate whose verifications of terminated candidacy are to be retrieved.</param>
/// <param name="electionCycle">The election cycle in which to search.</param>
/// <returns>A generic List collection of all verifications of terminated candidacy on record for the specified candidate and election cycle.</returns>
public TerminationHistory GetTerminationVerifications(string candidateID, string electionCycle)
{
using (TerminationVerificationTds ds = new TerminationVerificationTds())
{
using (TerminationVerificationsTableAdapter ta = new TerminationVerificationsTableAdapter())
{
ta.Fill(ds.TerminationVerifications, candidateID, electionCycle);
}
TerminationHistory c = new TerminationHistory(ds.TerminationVerifications.Count);
foreach (TerminationVerificationTds.TerminationVerificationsRow row in ds.TerminationVerifications.Rows)
{
c.Documents.Add(new TerminationVerification(row.Number, row.LastUpdated)
{
PageCount = row.PageCount,
StatusReason = CPConvert.ToDocumentStatusReason(row.ReasonCode.Trim()),
Status = CPConvert.ToDocumentStatus(row.StatusCode.Trim()),
DeliveryType = CPConvert.ToDeliveryType(row.DeliveryCode.Trim()),
SubmissionType = CPConvert.ToSubmissionType(row.SubmissionCode.Trim()),
ReceivedDate = row.IsReceivedDateNull() ? null : row.ReceivedDate as DateTime?,
StatusDate = row.IsStatusDateNull() ? null : row.StatusDate as DateTime?,
PostmarkDate = row.IsPostmarkDateNull() ? null : row.PostmarkDate as DateTime?
});
}
return(c);
}
}
internal static void Finish(IndexingActivityBase activity)
{
lock (WaitingSetLock)
{
// activity is done in the ActivityQueue
WaitingSet.Remove(activity);
// terminate and release waiting threads if there is any.
activity.Finish();
// register activity termination in the log.
IndexingActivityHistory.Finish(activity.Id);
// register activity termination if the activity was not skipped.
if (activity.Executed)
{
TerminationHistory.FinishActivity(activity);
}
// execute all activities that are completely freed.
foreach (var dependentItem in activity.WaitingForMe.ToArray())
{
dependentItem.FinishWaiting(activity);
if (dependentItem.WaitingFor.Count == 0)
{
System.Threading.Tasks.Task.Run(() => Executor.Execute(dependentItem));
}
}
}
}
public DependencyManager(Serializer serializer, Executor executor, TerminationHistory terminationHistory,
SecurityActivityHistoryController activityHistory)
{
_serializer = serializer;
_executor = executor;
_terminationHistory = terminationHistory;
_activityHistory = activityHistory;
}
public static SecurityActivityQueueState GetCurrentState()
{
return(new SecurityActivityQueueState
{
Serializer = Serializer.GetCurrentState(),
DependencyManager = DependencyManager.GetCurrentState(),
Termination = TerminationHistory.GetCurrentState()
});
}
public DistributedIndexingActivityQueue(IndexManager indexManager)
{
_terminationHistory = new TerminationHistory();
_activityHistory = new IndexingActivityHistoryController(this);
_dependencyManager = new DependencyManager(_terminationHistory, _activityHistory);
_serializer = new Serializer(this, _dependencyManager, _terminationHistory, _activityHistory, indexManager);
var executor = new Executor(_dependencyManager, _activityHistory, indexManager);
_dependencyManager.SetDependencies(_serializer, executor);
}
internal static void Startup(CompletionState uncompleted, int lastActivityIdFromDb)
{
CommunicationMonitor.Stop();
Serializer.Reset();
DependencyManager.Reset();
TerminationHistory.Reset(uncompleted.LastActivityId, uncompleted.Gaps);
Serializer.Start(lastActivityIdFromDb, uncompleted.LastActivityId, uncompleted.Gaps);
CommunicationMonitor.Start();
}
internal Serializer(DistributedIndexingActivityQueue activityQueue,
DependencyManager dependencyManager,
TerminationHistory terminationHistory,
IndexingActivityHistoryController activityHistory
, IndexManager indexManager)
{
_activityQueue = activityQueue;
_dependencyManager = dependencyManager;
_terminationHistory = terminationHistory;
_activityHistory = activityHistory;
_indexManager = indexManager;
}
/// <summary>
/// Raises the <see mref="Load"/> event.
/// </summary>
/// <param name="args">An <see cref="EventArgs"/> object that contains the event data.</param>
protected override void OnLoad(EventArgs args)
{
base.OnLoad(args);
if (!Page.IsPostBack)
{
TerminationHistory th = CPProfile.TerminationHistory;
if (th != null)
{
this.EnsureChildControls();
this.DataSource = th.Documents;
this.DataBind();
}
}
}
public SecurityActivityQueue(SecuritySystem securitySystem, CommunicationMonitor communicationMonitor,
DataHandler dataHandler, SecurityActivityHistoryController activityHistory)
{
_securitySystem = securitySystem;
_communicationMonitor = communicationMonitor;
_dataHandler = dataHandler;
_serializer = new Serializer(this, activityHistory, dataHandler);
_executor = new Executor(activityHistory);
_terminationHistory = new TerminationHistory();
_dependencyManager = new DependencyManager(_serializer, _executor, _terminationHistory, activityHistory);
_serializer.DependencyManager = _dependencyManager;
_executor.DependencyManager = _dependencyManager;
communicationMonitor.HearthBeat += (sender, args) => HealthCheck();
}
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" : "");
var notLoadedIds = state.Gaps.ToList();
foreach (var indexingActivity in new IndexingActivityLoader(state.Gaps, false))
{
var activity = (IndexingActivityBase)indexingActivity;
WaitIfOverloaded();
ExecuteActivity(activity);
notLoadedIds.Remove(activity.Id);
}
if (notLoadedIds.Count > 0)
{
TerminationHistory.RemoveGaps(notLoadedIds);
SnTrace.IndexQueue.Write("IAQ: Health checker ignores the following activity ids after processing the gaps: {0}", notLoadedIds);
}
}
var lastId = TerminationHistory.GetLastTerminatedId();
var lastDbId = IndexManager.GetLastStoredIndexingActivityId();
if (lastId < lastDbId)
{
SnTrace.IndexQueue.Write("IAQ: Health checker is processing activities from {0} to {1}", (lastId + 1), lastDbId);
foreach (var indexingActivity in new IndexingActivityLoader(lastId + 1, lastDbId, false))
{
var activity = (IndexingActivityBase)indexingActivity;
WaitIfOverloaded();
ExecuteActivity(activity);
}
}
}
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);
}
}
}
internal static void HealthCheck()
{
if (IsWorking())
{
SnTrace.Security.Write("SAQ: Health check triggered but ignored.");
return;
}
SnTrace.Security.Write("SAQ: Health check triggered.");
var state = TerminationHistory.GetCurrentState();
var gapsLength = state.Gaps.Length;
if (gapsLength > 0)
{
SnTrace.SecurityQueue.Write("SAQ: Health checker is processing {0} gap{1}.", gapsLength, gapsLength > 1 ? "s" : "");
var notLoaded = state.Gaps.ToList();
foreach (var activity in new SecurityActivityLoader(state.Gaps, false))
{
SecurityActivityQueue.ExecuteActivity(activity);
// memorize executed
notLoaded.Remove(activity.Id);
}
// forget not loaded activities.
TerminationHistory.RemoveFromGaps(notLoaded);
}
var lastId = TerminationHistory.GetLastTerminatedId();
var lastDbId = DataHandler.GetLastSecurityActivityId(SecurityContext.StartedAt);
if (lastId < lastDbId)
{
SnTrace.SecurityQueue.Write("SAQ: Health checker is processing activities from {0} to {1}", lastId + 1, lastDbId);
foreach (var activity in new SecurityActivityLoader(lastId + 1, lastDbId, false))
{
SecurityActivityQueue.ExecuteActivity(activity);
}
}
}
internal DependencyManager(TerminationHistory terminationHistory, IndexingActivityHistoryController activityHistory)
{
_terminationHistory = terminationHistory;
_activityHistory = activityHistory;
}
internal static void Shutdown()
{
Serializer.Reset();
DependencyManager.Reset();
TerminationHistory.Reset(0);
}
/// <summary>
/// MUST BE SYNCHRON
/// GAPS MUST BE ORDERED
/// </summary>
internal static void Start(int lastDatabaseId, int lastExecutedId, int[] gaps, System.IO.TextWriter consoleOut)
{
if (consoleOut != null)
{
consoleOut.WriteLine("Executing unprocessed activities. {0}-{1} {2}", lastExecutedId, lastDatabaseId, CompletionState.GapsToString(gaps, 5, 3));
}
SnLog.WriteInformation("Executing unprocessed activities.",
EventId.RepositoryRuntime,
properties: new Dictionary <string, object> {
{ "LastDatabaseId", lastDatabaseId },
{ "LastExecutedId", lastExecutedId },
{ "CountOfGaps", gaps.Length },
{ "Gaps", String.Join(", ", gaps) }
});
DependencyManager.Start();
var count = 0;
if (gaps.Any())
{
var loadedActivities = new IndexingActivityLoader(gaps, true);
foreach (LuceneIndexingActivity loadedActivity in loadedActivities)
{
// wait and start processing loaded activities in the meantime
WaitIfOverloaded(true);
SnTrace.IndexQueue.Write("IAQ: Startup: A{0} enqueued from db.", loadedActivity.Id);
IndexingActivityHistory.Arrive(loadedActivity);
_arrivalQueue.Enqueue(loadedActivity);
_lastQueued = loadedActivity.Id;
count++;
}
}
if (lastExecutedId < lastDatabaseId)
{
var loadedActivities = new IndexingActivityLoader(lastExecutedId + 1, lastDatabaseId, true);
foreach (LuceneIndexingActivity loadedActivity in loadedActivities)
{
// wait and start processing loaded activities in the meantime
WaitIfOverloaded(true);
SnTrace.IndexQueue.Write("IAQ: Startup: A{0} enqueued from db.", loadedActivity.Id);
IndexingActivityHistory.Arrive(loadedActivity);
_arrivalQueue.Enqueue(loadedActivity);
_lastQueued = loadedActivity.Id;
count++;
}
}
if (_lastQueued < lastExecutedId)
{
_lastQueued = lastExecutedId;
}
// ensure that the arrival activity queue is not empty at this pont.
DependencyManager.ActivityEnqueued();
if (lastDatabaseId != 0 || lastExecutedId != 0 || gaps.Any())
{
while (IsWorking())
{
Thread.Sleep(200);
}
}
// At this point we know for sure that the original gap is not there anymore.
// In case there is a false gap (e.g. because there are missing activity ids
// in the db) we have to remove these ids manually from the in-memory gap.
if (gaps.Any())
{
TerminationHistory.RemoveGaps(gaps);
// Commit is necessary because otherwise the gap is removed only in memory, but
// the index is not updated in the file system.
LuceneManager.Commit();
}
SnLog.WriteInformation($"Executing unprocessed activities ({count}) finished.", EventId.RepositoryLifecycle);
}
public static CompletionState GetCurrentCompletionState()
{
return(TerminationHistory.GetCurrentState());
}
public static IndexingActivityStatus GetCurrentCompletionState()
{
return(TerminationHistory.GetCurrentState());
}
/// <summary>Only for tests</summary>
internal static void _setCurrentExecutionState(CompletionState state)
{
Serializer.Reset(state.LastActivityId);
DependencyManager.Reset();
TerminationHistory.Reset(state.LastActivityId, state.Gaps);
}
/// <summary>
/// MUST BE SYNCHRON
/// GAPS MUST BE ORDERED
/// </summary>
internal static void Start(int lastDatabaseId, int lastExecutedId, int[] gaps, System.IO.TextWriter consoleOut)
{
consoleOut?.WriteLine("Executing unprocessed activities. {0}-{1} {2}", lastExecutedId, lastDatabaseId, IndexingActivityStatus.GapsToString(gaps, 5, 3));
SnLog.WriteInformation("Executing unprocessed activities.",
EventId.RepositoryRuntime,
properties: new Dictionary <string, object> {
{ "LastDatabaseId", lastDatabaseId },
{ "LastExecutedId", lastExecutedId },
{ "CountOfGaps", gaps.Length },
{ "Gaps", IndexingActivityStatus.GapsToString(gaps, 100, 3) }
});
IndexingActivityBase.NotIndexableContentCollection.Clear();
DependencyManager.Start();
var count = 0;
if (gaps.Any())
{
var loadedActivities = new IndexingActivityLoader(gaps, true);
foreach (var indexingActivity in loadedActivities)
{
var loadedActivity = (IndexingActivityBase)indexingActivity;
// wait and start processing loaded activities in the meantime
WaitIfOverloaded(true);
SnTrace.IndexQueue.Write("IAQ: Startup: A{0} enqueued from db.", loadedActivity.Id);
IndexingActivityHistory.Arrive(loadedActivity);
ArrivalQueue.Enqueue(loadedActivity);
_lastQueued = loadedActivity.Id;
count++;
}
}
if (lastExecutedId < lastDatabaseId)
{
var loadedActivities = new IndexingActivityLoader(lastExecutedId + 1, lastDatabaseId, true);
foreach (var indexingActivity in loadedActivities)
{
var loadedActivity = (IndexingActivityBase)indexingActivity;
// wait and start processing loaded activities in the meantime
WaitIfOverloaded(true);
SnTrace.IndexQueue.Write("IAQ: Startup: A{0} enqueued from db.", loadedActivity.Id);
IndexingActivityHistory.Arrive(loadedActivity);
ArrivalQueue.Enqueue(loadedActivity);
_lastQueued = loadedActivity.Id;
count++;
}
}
if (_lastQueued < lastExecutedId)
{
_lastQueued = lastExecutedId;
}
// ensure that the arrival activity queue is not empty at this pont.
DependencyManager.ActivityEnqueued();
if (lastDatabaseId != 0 || lastExecutedId != 0 || gaps.Any())
{
while (IsWorking())
{
Thread.Sleep(200);
}
}
if (IndexingActivityBase.NotIndexableContentCollection.Any())
{
const int maxWrittenCount = 100;
// Collect the first n ContentId, VersionId pairs into one message
// (key: version id, value: content id).
var data = string.Join("; ", IndexingActivityBase.NotIndexableContentCollection.Take(maxWrittenCount)
.OrderBy(x => x.Value)
.Select(x => $"{x.Value},{x.Key}"));
var firstN = IndexingActivityBase.NotIndexableContentCollection.Count > maxWrittenCount
? $" first {maxWrittenCount}"
: string.Empty;
// Write one aggregated message
SnLog.WriteWarning($"Cannot index {IndexingActivityBase.NotIndexableContentCollection.Count}" +
$" content. The{firstN} related ContentId, VersionId pairs: {data}");
// Do not keep memory for unnecessary data
IndexingActivityBase.NotIndexableContentCollection.Clear();
}
// At this point we know for sure that the original gap is not there anymore.
// In case there is a false gap (e.g. because there are missing activity ids
// in the db) we have to remove these ids manually from the in-memory gap.
if (gaps.Any())
{
TerminationHistory.RemoveGaps(gaps);
// Commit is necessary because otherwise the gap is removed only in memory, but
// the index is not updated in the file system.
IndexManager.CommitAsync(CancellationToken.None).GetAwaiter().GetResult(); // explicit commit
}
SnLog.WriteInformation($"Executing unprocessed activities ({count}) finished.", EventId.RepositoryLifecycle);
}
