private async Task RestoreStateFromPreviousRunsAsync()
{
if (this.GetType().IsSubclassOf(typeof(TimeTriggeredAgent)))
{
this.Logger.LogMessage("RestoreStateFromPreviousRunsAsync:: Skipping Restore for TimeTriggered Agents");
return;
}
// Restore the signals that haven't been processed yet. Read them from persistent storage and put them into our in memory queue.
var analysisDetails = await this.signalWaitingToBeProcessedStoreInstance.GetAllValuesAsync(this.CancelToken).ConfigureAwait(false);
this.Logger.LogMessage("RestoreStateFromPreviousRunsAsync:: Restoring unprocessed Signal Queue. Queue Depth: {0}", analysisDetails.Count);
foreach (var entry in analysisDetails)
{
var queue = this.signalWaitingToBeProcessedMap.GetOrAdd(entry.Key, InsightsUtil.DeSerialize <ConcurrentQueue <ScenarioData> >(entry.Value));
}
// Restores the Analysis metadata map from persistent storage.
var metadataInMemoryMap = await this.analysisMetadataObjectStore.GetCurrentSnapshotOfAllTypedObjectsAsync().ConfigureAwait(false);
foreach (var oneMetatada in metadataInMemoryMap.Values)
{
// Little bit of hacky way. Basically any analysis that was in progress or not started from some earlier run,
// we mark them as suspended with immediate resume so that activator thread can pick it up.
if (oneMetatada.SchedulingInfo.CurrentStatus == AnalysisStatus.InProgress ||
oneMetatada.SchedulingInfo.CurrentStatus == AnalysisStatus.NotStarted ||
oneMetatada.SchedulingInfo.CurrentStatus == AnalysisStatus.Queued)
{
oneMetatada.SchedulingInfo.SetContinuation(Continuation.ResumeImmediately);
await this.analysisMetadataObjectStore.PersistTypedObjectAsync(oneMetatada).ConfigureAwait(false);
}
}
}
public async Task SavePrimaryReplicaContextAsync(PrimaryReplicaContext context)
{
await this.InitializeStoreAsync().ConfigureAwait(false);
string serializedContext = InsightsUtil.Serialize(context);
await this.contextStore.SetEntityAsync(context.PartitionId, serializedContext, this.cancellationToken).ConfigureAwait(false);
}
public async Task <PrimaryReplicaContext> GetPrimaryReplicaContextAsync(Guid partitionId)
{
await this.InitializeStoreAsync().ConfigureAwait(false);
string contextAsString = await this.contextStore.GetEntityAsync(partitionId, this.cancellationToken).ConfigureAwait(false);
var context = InsightsUtil.DeSerialize <PrimaryReplicaContext>(contextAsString);
return(context);
}
// This routine reads from the undispatched persistent store and return all the values present there.
private async Task <IList <ScenarioNotificationData> > GetUndispatchedSignalsFromLastRunAsync(CancellationToken token)
{
var undispatchDataList = new List <ScenarioNotificationData>();
var allDataSerialized = await this.signalsInDispatchQueuePersistentStore.GetAllValuesAsync(token).ConfigureAwait(false);
foreach (var oneVal in allDataSerialized.Values)
{
var data = InsightsUtil.DeSerialize <ScenarioNotificationData>(oneVal);
undispatchDataList.Add(data);
}
return(undispatchDataList);
}
// Sometime when a signal is received, the analysis container may not be in position to accept the data and
// the data is put into this queue. When the analysis is in position to accept more data, this routine
// is called to fetch data (if present).
private async Task <ScenarioData> GetQueuedUpDataForAnalysisAsync(Guid analysisContainerIdentifier)
{
ConcurrentQueue <ScenarioData> queueOfDataInDispatchWaiting;
if (!this.signalWaitingToBeProcessedMap.TryGetValue(analysisContainerIdentifier, out queueOfDataInDispatchWaiting))
{
return(null);
}
ScenarioData firstInQueue;
if (!queueOfDataInDispatchWaiting.TryDequeue(out firstInQueue))
{
return(null);
}
// Persist the change in queue.
await this.signalWaitingToBeProcessedStoreInstance.SetEntityAsync(
analysisContainerIdentifier,
InsightsUtil.Serialize(queueOfDataInDispatchWaiting),
this.CancelToken).ConfigureAwait(false);
return(firstInQueue);
}
