void ISourceMailbox.ExportFolders(List <byte[]> folderIds, IFxProxyPool proxyPool, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludeProps, AclFlags extendedAclFlags)
{
string text = "ISourceMailbox.ExportFolders";
TimeSpan targetDuration = TimeSpan.Zero;
Stopwatch stopwatch = Stopwatch.StartNew();
base.CreateContext(text, new DataContext[]
{
new EntryIDsDataContext(folderIds),
new SimpleValueDataContext("exportFoldersDataToCopyFlags", exportFoldersDataToCopyFlags),
new SimpleValueDataContext("folderRecFlags", folderRecFlags),
new PropTagsDataContext(additionalFolderRecProps),
new SimpleValueDataContext("copyPropertiesFlags", copyPropertiesFlags),
new PropTagsDataContext(excludeProps),
new SimpleValueDataContext("extendedAclFlags", extendedAclFlags)
}).Execute(delegate
{
using (FxProxyPoolFxCallbackWrapper fxProxyPoolFxCallbackWrapper = new FxProxyPoolFxCallbackWrapper(proxyPool, true, delegate(TimeSpan duration)
{
targetDuration += duration;
}))
{
((ISourceMailbox)this.WrappedObject).ExportFolders(folderIds, fxProxyPoolFxCallbackWrapper, exportFoldersDataToCopyFlags, folderRecFlags, additionalFolderRecProps, copyPropertiesFlags, excludeProps, extendedAclFlags);
}
}, false);
base.UpdateDuration(text, stopwatch.Elapsed.Subtract(targetDuration));
}
private static bool ExportMessageBatch(ISourceMailbox mailbox, List <MessageRec> messages, Func <IFxProxyPool> getProxyPool, ExportMessagesFlags flags, PropTag[] propsToCopyExplicitly, PropTag[] excludeProps, TestIntegration testIntegration, out Exception failure)
{
failure = null;
try
{
using (IFxProxyPool fxProxyPool = getProxyPool())
{
mailbox.ExportMessages(messages, fxProxyPool, flags, propsToCopyExplicitly, excludeProps);
}
return(true);
}
catch (Exception ex)
{
if (!MapiUtils.IsBadItemIndicator(ex, out failure))
{
if (failure != ex)
{
failure.PreserveExceptionStack();
throw failure;
}
throw;
}
}
return(false);
}
private void FlushBatchToFolder(List <MessageRec> batch, IFxProxyPool proxyPool)
{
if (batch.Count == 0)
{
return;
}
MrsTracer.Provider.Function("MapiSourceMailbox.FlushBatchToFolder({0} messages)", new object[]
{
batch.Count
});
byte[] folderId = batch[0].FolderId;
using (MapiSourceFolder folder = base.GetFolder <MapiSourceFolder>(folderId))
{
if (folder == null)
{
MrsTracer.Provider.Debug("Folder {0} is missing in source. Will sync its deletion later.", new object[]
{
TraceUtils.DumpEntryId(folderId)
});
}
else
{
folder.CopyBatch(proxyPool, batch);
}
}
}
void ISourceMailbox.ExportMessages(List <MessageRec> messages, IFxProxyPool proxyPool, ExportMessagesFlags flags, PropTag[] propsToCopyExplicitly, PropTag[] excludeProps)
{
MrsTracer.Provider.Function("PstSourceMailbox.ExportMessages({0} messages)", new object[]
{
messages.Count
});
this.CopyMessagesOneByOne(messages, proxyPool, propsToCopyExplicitly, excludeProps, null);
}
void ISourceMailbox.ExportMessages(List <MessageRec> messages, IFxProxyPool proxyPool, ExportMessagesFlags flags, PropTag[] propsToCopyExplicitly, PropTag[] excludeProps)
{
MrsTracer.Provider.Function("PopSourceMailbox.ExportMessages({0} messages)", new object[]
{
messages.Count
});
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
this.CopyMessagesOneByOne(messages, proxyPool, propsToCopyExplicitly, excludeProps, delegate(MessageRec curMsg)
{
});
}
void ISourceMailbox.ExportMessages(List <MessageRec> messages, IFxProxyPool proxyPool, ExportMessagesFlags flags, PropTag[] propsToCopyExplicitly, PropTag[] excludeProps)
{
MrsTracer.Provider.Function("MapiSourceMailbox.ExportMessages({0} messages)", new object[]
{
messages.Count
});
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
if ((flags & ExportMessagesFlags.OneByOne) != ExportMessagesFlags.None)
{
this.CopyMessagesOneByOne(messages, proxyPool, propsToCopyExplicitly, excludeProps, null);
return;
}
this.CopyMessageBatch(messages, proxyPool);
}
private void CopyMessageBatch(List <MessageRec> messages, IFxProxyPool proxyPool)
{
MrsTracer.Provider.Function("MapiSourceMailbox.CopyMessageBatch({0} messages)", new object[]
{
messages.Count
});
byte[] curFolderId = null;
List <MessageRec> curBatch = new List <MessageRec>();
bool exportCompleted = false;
List <byte[]> list = new List <byte[]>(messages.Count);
foreach (MessageRec messageRec in messages)
{
list.Add(messageRec.EntryId);
}
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("LocalSourceMailbox.CopyMessageBatch", OperationType.None),
new EntryIDsDataContext(list)
}).Execute(delegate
{
try
{
foreach (MessageRec messageRec2 in messages)
{
if (curFolderId != null && !CommonUtils.IsSameEntryId(curFolderId, messageRec2.FolderId))
{
this.FlushBatchToFolder(curBatch, proxyPool);
curFolderId = null;
curBatch.Clear();
}
curFolderId = messageRec2.FolderId;
curBatch.Add(messageRec2);
}
this.FlushBatchToFolder(curBatch, proxyPool);
exportCompleted = true;
proxyPool.Flush();
}
catch (LocalizedException)
{
if (!exportCompleted)
{
MrsTracer.Provider.Debug("Flushing target proxy after receiving an exception.", new object[0]);
CommonUtils.CatchKnownExceptions(new Action(proxyPool.Flush), null);
}
throw;
}
});
}
private static IFolderProxy GetFolderProxyForExportFolder(IFxProxyPool proxyPool, IFolder sourceFolder, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps)
{
IFolderProxy result;
if ((exportFoldersDataToCopyFlags & ExportFoldersDataToCopyFlags.OutputCreateMessages) == ExportFoldersDataToCopyFlags.OutputCreateMessages)
{
FolderRec folderRec = sourceFolder.GetFolderRec(additionalFolderRecProps, folderRecFlags);
result = proxyPool.CreateFolder(folderRec);
}
else
{
result = proxyPool.GetFolderProxy(sourceFolder.GetFolderId());
}
return(result);
}
private void ExportSingleFolder(IFxProxyPool proxyPool, byte[] folderEntryId, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludePropertiesFromCopy, AclFlags extendedAclFlags)
{
ExecutionContext.Create(new DataContext[]
{
new OperationDataContext("StorageSourceMailbox.ExportSingleFolder", OperationType.None),
new EntryIDsDataContext(folderEntryId),
new SimpleValueDataContext("exportFoldersDataToCopyFlags", exportFoldersDataToCopyFlags),
new SimpleValueDataContext("folderRecFlags", folderRecFlags),
new PropTagsDataContext(additionalFolderRecProps),
new SimpleValueDataContext("copyPropertiesFlags", copyPropertiesFlags),
new PropTagsDataContext(excludePropertiesFromCopy),
new SimpleValueDataContext("extendedAclFlags", extendedAclFlags)
}).Execute(delegate
{
using (this.RHTracker.Start())
{
using (ISourceFolder folder = this.GetFolder <StorageSourceFolder>(folderEntryId))
{
if (folder == null)
{
MrsTracer.Provider.Debug("Folder {0} is missing in source. Skipping.", new object[]
{
TraceUtils.DumpEntryId(folderEntryId)
});
}
else
{
using (IFolderProxy folderProxyForExportFolder = StorageSourceMailbox.GetFolderProxyForExportFolder(proxyPool, folder, exportFoldersDataToCopyFlags, folderRecFlags, additionalFolderRecProps))
{
if (extendedAclFlags != AclFlags.None)
{
this.ExportExtendedAcls(extendedAclFlags, folder, folderProxyForExportFolder);
}
using (FxProxyBudgetWrapper fxProxyBudgetWrapper = new FxProxyBudgetWrapper(folderProxyForExportFolder, false, new Func <IDisposable>(this.RHTracker.StartExclusive), new Action <uint>(this.RHTracker.Charge)))
{
if (exportFoldersDataToCopyFlags.HasFlag(ExportFoldersDataToCopyFlags.IncludeCopyToStream))
{
folder.CopyTo(fxProxyBudgetWrapper, copyPropertiesFlags, excludePropertiesFromCopy);
}
}
}
}
}
}
});
}
IFxProxyPool IDestinationMailbox.GetFxProxyPool(ICollection <byte[]> folderIds)
{
IFxProxyPool result = null;
base.CreateContext("IDestinationMailbox.GetFxProxyPool", new DataContext[]
{
new EntryIDsDataContext(new List <byte[]>(folderIds))
}).Execute(delegate
{
result = ((IDestinationMailbox)this.WrappedObject).GetFxProxyPool(folderIds);
}, true);
if (result == null)
{
return(null);
}
return(new FxProxyPoolWrapper(result, base.CreateContext));
}
protected override IFxProxyPool GetFxProxyPoolTransmissionPipeline(EntryIdMap <byte[]> sourceMap)
{
IFxProxyPool result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
IFxProxyPool fxProxyPool = base.DestMailbox.GetFxProxyPool(sourceMap.Keys);
disposeGuard.Add <IFxProxyPool>(fxProxyPool);
IFxProxyPool fxProxyPool2 = new MailboxMerger.SimpleTranslatingProxyPool(fxProxyPool, sourceMap);
disposeGuard.Success();
disposeGuard.Add <IFxProxyPool>(fxProxyPool2);
IFxProxyPool fxProxyPool3 = base.CreateFxProxyPoolTransmissionPipeline(fxProxyPool2);
disposeGuard.Success();
result = fxProxyPool3;
}
return(result);
}
void ISourceMailbox.ExportFolders(List <byte[]> folderIds, IFxProxyPool proxyPool, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludeProps, AclFlags extendedAclFlags)
{
MrsTracer.ProxyClient.Function("RemoteSourceMailbox.ExportFolders", new object[0]);
base.VerifyMailboxConnection();
if (!base.ServerVersion[54])
{
throw new UnsupportedRemoteServerVersionWithOperationPermanentException(base.MrsProxyClient.ServerName, base.ServerVersion.ToString(), "ISourceMailbox_ExportFolders");
}
DataExportBatch dataExportBatch = base.MrsProxy.ISourceMailbox_ExportFolders(base.Handle, folderIds, (int)exportFoldersDataToCopyFlags, (int)folderRecFlags, DataConverter <PropTagConverter, PropTag, int> .GetData(additionalFolderRecProps), (int)copyPropertiesFlags, DataConverter <PropTagConverter, PropTag, int> .GetData(excludeProps), (int)extendedAclFlags);
using (IDataImport dataImport = new FxProxyPoolReceiver(proxyPool, false))
{
using (BufferedReceiver bufferedReceiver = new BufferedReceiver(dataImport, false, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression))
{
RemoteDataExport.ExportRoutine(base.MrsProxy, dataExportBatch.DataExportHandle, bufferedReceiver, dataExportBatch, base.MrsProxyClient.UseCompression);
}
}
}
void ISourceMailbox.ExportMessages(List <MessageRec> messages, IFxProxyPool proxyPool, ExportMessagesFlags flags, PropTag[] propsToCopyExplicitly, PropTag[] excludeProps)
{
MrsTracer.Provider.Function("ImapSourceMailbox.ExportMessages({0} messages)", new object[]
{
messages.Count
});
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
this.CopyMessagesOneByOne(messages, proxyPool, propsToCopyExplicitly, excludeProps, delegate(MessageRec curMsg)
{
using (ImapFolder folder = base.GetFolder <ImapSourceFolder>(curMsg.FolderId))
{
if (folder == null)
{
throw new FolderIsMissingTransientException();
}
folder.Folder.SelectImapFolder(base.ImapConnection);
}
});
}
void ISourceMailbox.ExportMessages(List <MessageRec> messages, IFxProxyPool destProxies, ExportMessagesFlags flags, PropTag[] propsToCopyExplicitly, PropTag[] excludeProps)
{
string text = "ISourceMailbox.ExportMessages";
TimeSpan targetDuration = TimeSpan.Zero;
Stopwatch stopwatch = Stopwatch.StartNew();
base.CreateContext(text, new DataContext[]
{
new SimpleValueDataContext("Flags", flags),
new PropTagsDataContext(excludeProps)
}).Execute(delegate
{
using (FxProxyPoolFxCallbackWrapper fxProxyPoolFxCallbackWrapper = new FxProxyPoolFxCallbackWrapper(destProxies, true, delegate(TimeSpan duration)
{
targetDuration += duration;
}))
{
((ISourceMailbox)this.WrappedObject).ExportMessages(messages, fxProxyPoolFxCallbackWrapper, flags, propsToCopyExplicitly, excludeProps);
}
}, false);
base.UpdateDuration(text, stopwatch.Elapsed.Subtract(targetDuration));
}
internal void CopyBatch(IFxProxyPool proxyPool, List <MessageRec> batch)
{
StorageSourceFolder.< > c__DisplayClass9 CS$ < > 8__locals1 = new StorageSourceFolder.< > c__DisplayClass9();
CS$ < > 8__locals1.< > 4__this = this;
if (batch.Count == 0)
{
return;
}
byte[][] array = new byte[batch.Count][];
for (int i = 0; i < batch.Count; i++)
{
array[i] = batch[i].EntryId;
}
CS$ < > 8__locals1.flags = CopyMessagesFlags.SendEntryId;
using (IMapiFxProxy destFolderProxy = proxyPool.GetFolderProxy(base.FolderId))
{
if (destFolderProxy == null)
{
MrsTracer.Provider.Warning("Destination folder {0} does not exist.", new object[]
{
TraceUtils.DumpEntryId(base.FolderId)
});
}
else
{
MapiUtils.ProcessMapiCallInBatches <byte[]>(array, delegate(byte[][] smallBatch)
{
using (CS$ < > 8__locals1.< > 4__this.Mailbox.RHTracker.Start())
{
using (FxProxyBudgetWrapper fxProxyBudgetWrapper = new FxProxyBudgetWrapper(destFolderProxy, false, new Func <IDisposable>(CS$ < > 8__locals1.< > 4__this.Mailbox.RHTracker.StartExclusive), new Action <uint>(CS$ < > 8__locals1.< > 4__this.Mailbox.RHTracker.Charge)))
{
CS$ < > 8__locals1.< > 4__this.MapiFolder.ExportMessages(fxProxyBudgetWrapper, CS$ < > 8__locals1.flags, smallBatch);
}
}
});
}
}
}
void ISourceMailbox.ExportFolders(List <byte[]> folderIds, IFxProxyPool proxyPool, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludeProps, AclFlags extendedAclFlags)
{
MrsTracer.ProxyClient.Function("StorageSourceMailbox.ExportFolders", new object[0]);
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
bool exportCompleted = false;
CommonUtils.ProcessKnownExceptions(delegate
{
foreach (byte[] folderEntryId in folderIds)
{
this.ExportSingleFolder(proxyPool, folderEntryId, exportFoldersDataToCopyFlags, folderRecFlags, additionalFolderRecProps, copyPropertiesFlags, excludeProps, extendedAclFlags);
}
exportCompleted = true;
proxyPool.Flush();
}, delegate(Exception ex)
{
if (!exportCompleted)
{
MrsTracer.Provider.Debug("Flushing target proxy after receiving an exception.", new object[0]);
CommonUtils.CatchKnownExceptions(new Action(proxyPool.Flush), null);
}
return(false);
});
}
void ISourceMailbox.ExportFolders(List <byte[]> folderIds, IFxProxyPool proxyPool, ExportFoldersDataToCopyFlags exportFoldersDataToCopyFlags, GetFolderRecFlags folderRecFlags, PropTag[] additionalFolderRecProps, CopyPropertiesFlags copyPropertiesFlags, PropTag[] excludeProps, AclFlags extendedAclFlags)
{
throw new NotImplementedException();
}
void ISourceMailbox.ExportMessages(List <MessageRec> messages, IFxProxyPool proxyPool, ExportMessagesFlags flags, PropTag[] propsToCopyExplicitly, PropTag[] excludeProps)
{
MrsTracer.ProxyClient.Function("RemoteSourceMailbox.ExportMessages({0} messages)", new object[]
{
messages.Count
});
if (propsToCopyExplicitly != null)
{
throw new UnsupportedRemoteServerVersionWithOperationPermanentException(base.MrsProxyClient.ServerName, base.ServerVersion.ToString(), "ISourceMailbox_ExportMessages");
}
base.VerifyMailboxConnection();
using (IDataImport dataImport = new FxProxyPoolReceiver(proxyPool, false))
{
IDataMessage dataMessage = new FxProxyPoolGetFolderDataResponseMessage(proxyPool.GetFolderData());
DataMessageOpcode dataMessageOpcode;
byte[] targetObjectData;
dataMessage.Serialize(base.MrsProxyClient.UseCompression, out dataMessageOpcode, out targetObjectData);
DataExportBatch dataExportBatch;
if (!base.ServerVersion[8])
{
if ((flags & ExportMessagesFlags.OneByOne) != ExportMessagesFlags.None || excludeProps != null)
{
throw new UnsupportedRemoteServerVersionWithOperationPermanentException(base.MrsProxyClient.ServerName, base.ServerVersion.ToString(), "ISourceMailbox_ExportMessages");
}
dataExportBatch = base.MrsProxy.ISourceMailbox_ExportMessageBatch2(base.Handle, messages, targetObjectData);
}
else
{
int[] data = DataConverter <PropTagConverter, PropTag, int> .GetData(excludeProps);
dataExportBatch = base.MrsProxy.ISourceMailbox_ExportMessages(base.Handle, messages, (int)flags, data, targetObjectData);
}
MessageExportResultReceiver messageExportResultReceiver = null;
IDataImport destination = dataImport;
if (!base.ServerVersion[16])
{
messageExportResultReceiver = new MessageExportResultReceiver(destination, false);
destination = messageExportResultReceiver;
}
using (messageExportResultReceiver)
{
using (BufferedReceiver bufferedReceiver = new BufferedReceiver(destination, false, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression))
{
RemoteDataExport.ExportRoutine(base.MrsProxy, dataExportBatch.DataExportHandle, bufferedReceiver, dataExportBatch, base.MrsProxyClient.UseCompression);
if (messageExportResultReceiver != null)
{
List <BadMessageRec> badMessages = messageExportResultReceiver.BadMessages;
if (messageExportResultReceiver.MissingMessages != null)
{
foreach (MessageRec msg in messageExportResultReceiver.MissingMessages)
{
badMessages.Add(BadMessageRec.MissingItem(msg));
}
}
if (badMessages != null && badMessages.Count > 0)
{
throw new DownlevelBadItemsPermanentException(badMessages);
}
}
}
}
}
}
private void CopyMessageBatch(FolderContentsMapper mapper, List <MessageRec> itemsToCopy, FolderMapping fm)
{
if (itemsToCopy == null || itemsToCopy.Count == 0)
{
return;
}
MrsTracer.Service.Debug("Sorting {0} messages in folder '{1}'", new object[]
{
itemsToCopy.Count,
fm.FullFolderName
});
MessageRecSorter messageRecSorter = new MessageRecSorter();
Queue <List <MessageRec> > queue = messageRecSorter.Sort(itemsToCopy, (base.MRSJob.CachedRequestJob.SyncProtocol == SyncProtocol.Imap) ? MessageRecSortBy.SkipSort : MessageRecSortBy.DescendingTimeStamp);
byte[][] folderIDs = new byte[][]
{
fm.TargetFolder.EntryId
};
while (queue.Count > 0)
{
base.MRSJob.CheckServersHealth();
List <MessageRec> list = queue.Dequeue();
ulong num = 0UL;
foreach (MessageRec messageRec in list)
{
num += (ulong)((long)messageRec.MessageSize);
}
MrsTracer.Service.Debug("Copying a batch of {0} messages, {1}", new object[]
{
list.Count,
new ByteQuantifiedSize(num)
});
List <BadMessageRec> list2 = new List <BadMessageRec>();
MapiUtils.ExportMessagesWithBadItemDetection(base.SourceMailbox, list, delegate
{
IFxProxyPool fxProxyPool = this.DestMailbox.GetFxProxyPool(folderIDs);
IFxProxyPool fxProxyTransformer = mapper.GetFxProxyTransformer(fxProxyPool);
return(this.CreateFxProxyPoolTransmissionPipeline(fxProxyTransformer));
}, ExportMessagesFlags.OneByOne, ((base.Flags & MailboxCopierFlags.TargetIsPST) != MailboxCopierFlags.None) ? MailboxCopierBase.PSTIncludeMessagePtags : null, null, base.MRSJob.TestIntegration, ref list2);
if (list2 != null && list2.Count > 0)
{
List <BadMessageRec> list3 = new List <BadMessageRec>();
foreach (BadMessageRec badMessageRec in list2)
{
if (badMessageRec.Kind == BadItemKind.MissingItem)
{
MrsTracer.Service.Warning("Message {0} is missing in source, skipping.", new object[]
{
TraceUtils.DumpEntryId(badMessageRec.EntryId)
});
}
else
{
list3.Add(badMessageRec);
}
}
this.ReportBadItems(list3);
}
if (base.MRSJob.TestIntegration.LogContentDetails)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine(string.Format("CopyMessageBatch: {0} items copied", list.Count));
foreach (MessageRec messageRec2 in list)
{
stringBuilder.AppendLine(string.Format("ItemID {0}, FolderID {1}{2}", TraceUtils.DumpEntryId(messageRec2.EntryId), TraceUtils.DumpEntryId(messageRec2.FolderId), messageRec2.IsFAI ? ", FAI" : string.Empty));
}
base.MRSJob.Report.AppendDebug(stringBuilder.ToString());
}
base.MRSJob.MessagesWritten += list.Count;
base.MRSJob.MessageSizeWritten += num;
base.MRSJob.ProgressTracker.AddItems((uint)list.Count);
SaveStateFlags saveStateFlags = SaveStateFlags.Lazy;
if (num > 0UL)
{
base.UpdateTimestampWhenPersistentProgressWasMade();
saveStateFlags |= SaveStateFlags.RelinquishLongRunningJob;
}
base.MRSJob.SaveState(saveStateFlags, null);
}
}
public override IFxProxyPool GetDestinationFxProxyPool(ICollection <byte[]> folderIds)
{
IFxProxyPool fxProxyPool = base.DestMailbox.GetFxProxyPool(folderIds);
return(new TranslatorPFProxy(base.SourceMailbox, base.DestMailbox, fxProxyPool));
}
public IFxProxyPool GetFxProxyTransformer(IFxProxyPool targetFxProxyPool)
{
return(new FolderContentsMapper.TranslatingProxyPool(this, targetFxProxyPool));
}
