private void ExecuteProcedureWithProgress(ProcedureType procedureType, Action action)
{
if (this.IsStopRequested)
{
Tracer.TraceInformation("ProgressController.ExecuteProcedureWithProgress: Stop requested. Procedure type: {0}", new object[]
{
procedureType
});
return;
}
try
{
if (this.StatusManager.BeginProcedure(procedureType))
{
ScenarioData scenarioData = ScenarioData.Current;
Task task = Task.Factory.StartNew(delegate()
{
ScenarioData scenarioData;
using (new ScenarioData(scenarioData))
{
this.WaitForAndProcessProgress();
}
});
Exception ex = null;
try
{
action();
}
finally
{
this.progressAvailable.Release(1);
ex = AsynchronousTaskHandler.WaitForAsynchronousTask(task);
}
if (ex != null)
{
Tracer.TraceError("ProgressController.ExecuteProcedureWithProgress: Hitting exception in progress task. Exception: {0}", new object[]
{
ex
});
throw ex;
}
}
}
finally
{
this.StatusManager.EndProcedure();
}
}
public void WriteDataBatchItemListGen(object sender, DataBatchEventArgs<ItemListGenerator.ItemIdsDataBatch> args)
{
ScenarioData scenarioData = ScenarioData.Current;
ExportException ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
this.writingTask = ((ex != null || args.DataBatch == null) ? null : Task.Factory.StartNew(delegate(object dataBatch)
{
ScenarioData scenarioData;
using (new ScenarioData(scenarioData))
{
this.WriteDataBatch((ItemListGenerator.ItemIdsDataBatch)dataBatch);
}
}, args.DataBatch));
if (ex != null)
{
throw ex;
}
}
private void WriteDataBatch(object sender, DataBatchEventArgs <T> args)
{
ScenarioData scenarioData = ScenarioData.Current;
ExportException ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
this.writingTask = ((ex != null || args.DataBatch == null) ? null : Task.Factory.StartNew(delegate(object dataBatch)
{
ScenarioData scenarioData;
using (new ScenarioData(scenarioData))
{
this.batchDataWriter.WriteDataBatch((T)((object)dataBatch));
}
}, args.DataBatch));
if (ex != null)
{
throw ex;
}
}
public void Execute()
{
ExportException ex = null;
try
{
this.batchDataReader.StartReading();
}
finally
{
ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
this.writingTask = null;
}
if (ex != null)
{
throw ex;
}
}
public void WriteDataBatchDataRetriever(object sender, DataBatchEventArgs<List<ItemInformation>> args)
{
if (this.DataRetriever == null || this.DataRetriever.DataWriter == null)
{
return;
}
ScenarioData scenarioData = ScenarioData.Current;
ExportException ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
this.writingTask = ((ex != null || args.DataBatch == null) ? null : Task.Factory.StartNew(delegate(object dataBatch)
{
ScenarioData scenarioData;
using (new ScenarioData(scenarioData))
{
this.DataRetriever.DataWriter.WriteDataBatch((List<ItemInformation>)dataBatch);
}
}, args.DataBatch));
if (ex != null)
{
throw ex;
}
}
private void ExportSourceMailbox(IContextualBatchDataWriter <List <ItemInformation> > dataWriter, SourceInformation source, bool isUnsearchable)
{
Tracer.TraceInformation("ProgressController.ExportSourceMailbox: Source Id: {0}; isUnsearchable: {1}", new object[]
{
source.Configuration.Id,
isUnsearchable
});
this.ItemListGenerator.DoUnSearchable = isUnsearchable;
bool flag = (!isUnsearchable && source.Status.ItemCount <= 0) || (isUnsearchable && source.Status.UnsearchableItemCount <= 0);
if ((!isUnsearchable && source.Status.ItemCount > source.Status.ProcessedItemCount) || (isUnsearchable && source.Status.UnsearchableItemCount > source.Status.ProcessedUnsearchableItemCount) || !this.target.ExportContext.IsResume || flag)
{
IItemIdList itemIdList = this.target.CreateItemIdList(source.Configuration.Id, isUnsearchable);
DataContext dataContext = new DataContext(source, itemIdList);
DataRetriever dataRetriever = new DataRetriever(dataContext, this);
dataRetriever.DataWriter = dataWriter;
this.ItemListGenerator.DataRetriever = dataRetriever;
this.ItemListGenerator.DataBatchRead += this.ItemListGenerator.WriteDataBatchItemListGen;
dataRetriever.DataBatchRead += this.ItemListGenerator.WriteDataBatchDataRetriever;
ExportException ex = null;
try
{
this.ItemListGenerator.DoExportForSourceMailbox(dataRetriever.DataContext.SourceInformation);
}
finally
{
ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.ItemListGenerator.WritingTask);
this.ItemListGenerator.WritingTask = null;
this.ItemListGenerator.DataRetriever = null;
}
if (ex != null)
{
throw ex;
}
}
}
private void ReaderAborting(object sender, EventArgs args)
{
AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
this.writingTask = null;
}
public void DoExportForSourceMailbox(SourceInformation sourceMailbox)
{
Tracer.TraceInformation("ItemListGenerator.DoExportForSourceMailbox: Generating item list for mailbox '{0}'", new object[]
{
sourceMailbox.Configuration.Id
});
ErrorRecord errorRecord = null;
sourceMailbox.Configuration.Id.StartsWith("\\");
ScenarioData.Current["PM"] = sourceMailbox.Configuration.LegacyExchangeDN.GetHashCode().ToString();
if (sourceMailbox.Status.ItemCount < 0)
{
sourceMailbox.Status.ItemCount = 0;
}
if (sourceMailbox.Status.UnsearchableItemCount < 0)
{
sourceMailbox.Status.UnsearchableItemCount = 0;
}
try
{
bool flag = this.target.ExportContext.ExportMetadata.IncludeSearchableItems && !this.DoUnSearchable;
bool flag2 = this.target.ExportContext.ExportMetadata.IncludeUnsearchableItems && this.DoUnSearchable;
bool flag3 = false;
Dictionary<string, string> dictionary = null;
dictionary = ItemListGenerator.PrepareAllFolders(sourceMailbox.ServiceClient, sourceMailbox.Configuration.Id);
if (flag)
{
bool errorHappened = false;
try
{
bool flag4 = false;
Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer for primary for mailbox: '{0}'", new object[]
{
sourceMailbox.Configuration.Id
});
this.GetAllItemIdsFromServer<ItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<ItemId>(this.GetItemIdPageFromServer), dictionary, !flag, false, ref flag4, out flag3);
if (dictionary != null && dictionary.Values.Contains("\\archive"))
{
Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer for archive for mailbox: '{0}'", new object[]
{
sourceMailbox.Configuration.Id
});
this.GetAllItemIdsFromServer<ItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<ItemId>(this.GetItemIdPageFromServer), dictionary, !flag, true, ref flag4, out flag3);
}
ExportException ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
if (ex != null)
{
errorHappened = true;
throw ex;
}
}
finally
{
this.DataRetriever.DataWriter.ExitDataContext(errorHappened);
}
}
bool isUnsearchable = true;
if (flag2)
{
bool errorHappened2 = false;
try
{
bool flag5 = false;
Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer isunsearchable for primary for mailbox: '{0}'", new object[]
{
sourceMailbox.Configuration.Id
});
this.GetAllItemIdsFromServer<ItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<ItemId>(this.GetItemIdPageFromServer), dictionary, isUnsearchable, false, ref flag5, out flag3);
if (!flag3)
{
Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer isunsearchable for newschemafailed for mailbox: '{0}'", new object[]
{
sourceMailbox.Configuration.Id
});
this.GetAllItemIdsFromServer<UnsearchableItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<UnsearchableItemId>(this.GetUnsearchableItemIdPageFromServer), dictionary, isUnsearchable, false, ref flag5, out flag3);
}
else if (dictionary != null && dictionary.Values.Contains("\\archive"))
{
Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer isunsearchable for archive for mailbox: '{0}'", new object[]
{
sourceMailbox.Configuration.Id
});
this.GetAllItemIdsFromServer<ItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<ItemId>(this.GetItemIdPageFromServer), dictionary, isUnsearchable, true, ref flag5, out flag3);
}
ExportException ex2 = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
if (ex2 != null)
{
errorHappened2 = true;
throw ex2;
}
}
finally
{
this.DataRetriever.DataWriter.ExitDataContext(errorHappened2);
}
}
}
catch (ExportException ex3)
{
Tracer.TraceInformation("ItemListGenerator.DoExportForSourceMailbox: Error for mailbox '{0}'. Exception: {1}", new object[]
{
sourceMailbox.Configuration.Id,
ex3
});
errorRecord = new ErrorRecord
{
SourceId = sourceMailbox.Configuration.Id,
Item = null,
ErrorType = ex3.ErrorType,
DiagnosticMessage = ex3.Message,
Time = DateTime.UtcNow
};
}
if (ScenarioData.Current.ContainsKey("PM"))
{
ScenarioData.Current.Remove("PM");
}
if (errorRecord != null)
{
this.AbortForSourceMailbox(errorRecord);
}
}