public override bool ShouldCreateFolder(FolderMap.EnumFolderContext context, FolderRecWrapper sourceFolderRecWrapper)
{
FolderMapping folderMapping = sourceFolderRecWrapper as FolderMapping;
Guid contentMailboxGuid = this.GetContentMailboxGuid(sourceFolderRecWrapper);
bool isRoot = base.IsRoot;
bool flag = contentMailboxGuid == base.TargetMailboxGuid;
if (!isRoot && !flag && (!this.ShouldCreateUnderParentInSecondary() || !this.DoesAnySubFolderResideInTargetMailbox(sourceFolderRecWrapper)))
{
MrsTracer.Service.Debug("Not creating folder \"{0}\" in mailbox {1}. This is neither the primary hierarchy mailbox nor the content mailbox of this folder or any of its subfolders.", new object[]
{
sourceFolderRecWrapper.FullFolderName,
base.TargetMailboxGuid
});
return(false);
}
switch (folderMapping.WKFType)
{
case WellKnownFolderType.Root:
case WellKnownFolderType.NonIpmSubtree:
case WellKnownFolderType.IpmSubtree:
case WellKnownFolderType.EFormsRegistry:
return(false);
default:
if (folderMapping.IsLegacyPublicFolder)
{
context.Result = EnumHierarchyResult.SkipSubtree;
return(false);
}
return(true);
}
}
private ConflictResolutionOption GetConflictResolutionOption(FolderMapping fm)
{
WellKnownFolderType wkftype = fm.WKFType;
switch (wkftype)
{
case WellKnownFolderType.DumpsterDeletions:
case WellKnownFolderType.DumpsterVersions:
case WellKnownFolderType.DumpsterPurges:
break;
default:
switch (wkftype)
{
case WellKnownFolderType.DumpsterAdminAuditLogs:
case WellKnownFolderType.DumpsterAudits:
break;
default:
{
ConflictResolutionOption?conflictResolutionOption = base.MRSJob.CachedRequestJob.ConflictResolutionOption;
if (conflictResolutionOption == null)
{
return(ConflictResolutionOption.KeepSourceItem);
}
return(conflictResolutionOption.GetValueOrDefault());
}
}
break;
}
return(ConflictResolutionOption.KeepAll);
}
private void CreateFolderHierarchy()
{
base.RefreshRequestIfNeeded();
base.CheckServersHealth();
MrsTracer.Service.Debug("WorkItem: create folder hierarchy.", new object[0]);
MrsTracer.Service.Debug("Creating missing folders in target", new object[0]);
this.MailboxMerger.DestHierarchy.CreateMissingFolders();
base.RefreshRequestIfNeeded();
base.CheckServersHealth();
List <FolderMapping> foldersToCopy = new List <FolderMapping>();
foreach (WellKnownFolderType wkfType in MergeJob.FolderSyncOrder)
{
FolderMapping wellKnownFolder = this.MailboxMerger.SourceHierarchy.GetWellKnownFolder(wkfType);
if (wellKnownFolder != null && wellKnownFolder.IsIncluded)
{
foldersToCopy.Add(wellKnownFolder);
}
}
this.MailboxMerger.SourceHierarchy.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper folderRec, FolderMap.EnumFolderContext context)
{
FolderMapping folderMapping = (FolderMapping)folderRec;
if (folderMapping.IsIncluded && !foldersToCopy.Contains(folderMapping))
{
foldersToCopy.Add(folderMapping);
}
});
base.ScheduleWorkItem <List <FolderMapping> >(new Action <List <FolderMapping> >(this.CopyMessages), foldersToCopy, WorkloadType.Unknown);
}
public override byte[] GetDestinationFolderEntryId(byte[] sourceId)
{
FolderMapping result = (FolderMapping)this.SourceHierarchy[sourceId];
if (result != null && result.TargetFolder != null)
{
return(result.TargetFolder.EntryId);
}
result = null;
this.DestHierarchy.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)fRec;
byte[] eid = folderMapping.FolderRec[this.DestHierarchy.SourceEntryIDPtag] as byte[];
if (CommonUtils.IsSameEntryId(sourceId, eid))
{
result = folderMapping;
ctx.Result = EnumHierarchyResult.Cancel;
}
});
if (result == null)
{
return(null);
}
return(result.EntryId);
}
private void HashFolderMessages(WellKnownFolderType wkfType, HashSet <byte[]> hashset)
{
MrsTracer.Service.Debug("Enumerating target {0} folder to check for deleted messages", new object[]
{
wkfType
});
FolderMapping wellKnownFolder = this.DestHierarchy.GetWellKnownFolder(wkfType);
if (wellKnownFolder != null)
{
using (IDestinationFolder folder = base.DestMailbox.GetFolder(wellKnownFolder.EntryId))
{
if (folder != null)
{
List <MessageRec> list = folder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages, this.GetEnumerateMessagesPropsForContentVerification(MailboxWrapperFlags.Target));
foreach (MessageRec messageRec in list)
{
byte[] array = messageRec[this.DestHierarchy.SourceEntryIDPtag] as byte[];
if (array != null && !hashset.Contains(array))
{
hashset.Add(array);
}
}
}
}
}
}
public static FolderContentsMapper Create(FolderMapping folderMapping, ISourceFolder srcFolder, FolderHierarchy sourceHierarchy, IDestinationFolder destFolder, FolderHierarchy destHierarchy, ConflictResolutionOption conflictResolutionOption, FAICopyOption faiCopyOption, FolderContentsMapperFlags mapperFlags)
{
if (!mapperFlags.HasFlag(FolderContentsMapperFlags.ImapSync))
{
return(new FolderContentsMapper(folderMapping, srcFolder, sourceHierarchy, destFolder, destHierarchy, conflictResolutionOption, faiCopyOption, mapperFlags));
}
return(new ImapFolderContentsMapper(folderMapping, srcFolder, sourceHierarchy, destFolder, destHierarchy, conflictResolutionOption, faiCopyOption, mapperFlags));
}
public override FolderRecWrapper CreateTargetFolderRec(FolderRecWrapper sourceFolderRec)
{
FolderMapping folderMapping = (FolderMapping)sourceFolderRec;
FolderMapping folderMapping2 = new FolderMapping(sourceFolderRec.FolderRec);
folderMapping2.SourceFolder = folderMapping;
folderMapping.TargetFolder = folderMapping2;
return(folderMapping2);
}
public void LoadHierarchy(EnumerateFolderHierarchyFlags flags, string rootFolderPath, bool createRootIfNeeded, PropTag[] additionalPtagsToLoad)
{
List <PropTag> list = new List <PropTag>();
if (this.SourceWKFTypePtag != PropTag.Null)
{
list.Add(this.SourceWKFTypePtag);
}
if (this.SourceEntryIDPtag != PropTag.Null)
{
list.Add(this.SourceEntryIDPtag);
}
if (additionalPtagsToLoad != null)
{
list.AddRange(additionalPtagsToLoad);
}
List <FolderRecWrapper> folders = this.mbxWrapper.LoadFolders <FolderMapping>(flags, list.ToArray());
base.Config(folders);
this.DiscoverWellKnownFolders();
if (string.IsNullOrEmpty(rootFolderPath))
{
this.rootFolder = (FolderMapping)this.RootRec;
}
else
{
FolderMappingFlags folderMappingFlags;
this.rootFolder = this.FindFolderByPath(string.Empty, rootFolderPath, createRootIfNeeded, out folderMappingFlags);
if (this.rootFolder == null)
{
throw new FolderIsMissingPermanentException(rootFolderPath);
}
if (!base.IsPublicFolderMailbox)
{
this.wellKnownFolderMap.Reset();
this.wellKnownFolderMap.Clear();
this.EnumerateSubtree(EnumHierarchyFlags.AllFolders, this.rootFolder, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)fRec;
object obj = folderMapping.FolderRec[this.SourceWKFTypePtag];
if (obj != null)
{
this.SetWellKnownFolder((WellKnownFolderType)((int)obj), folderMapping);
}
});
if (this.GetWellKnownFolder(WellKnownFolderType.IpmSubtree) == null)
{
this.SetWellKnownFolder(WellKnownFolderType.IpmSubtree, this.rootFolder);
}
}
}
this.rootFolder.Flags |= FolderMappingFlags.Root;
if (this.GetWellKnownFolder(WellKnownFolderType.IpmSubtree) == null && !base.IsPublicFolderMailbox)
{
throw new FolderIsMissingPermanentException("IPM subtree");
}
}
public void Add(WellKnownFolderType wkfType, FolderMapping fm)
{
fm.WKFType = wkfType;
this.wellKnownFolders[wkfType] = fm;
if (fm.EntryId != null)
{
this.wellKnownFolderTypes[fm.EntryId] = wkfType;
}
}
protected override void PerformFolderRecoverySync(MailboxChanges changes, MailboxContentsCrawler crawler)
{
foreach (FolderChangesManifest folderChangesManifest in from folderChanges in changes.FolderChanges.Values
where folderChanges.FolderRecoverySync
select folderChanges)
{
FolderMapping folder = base.MailboxMerger.SourceHierarchy[folderChangesManifest.FolderId] as FolderMapping;
crawler.ResetFolder(folder);
}
}
public override byte[] GetSourceFolderEntryId(FolderRecWrapper targetFolder)
{
FolderMapping folderMapping = (FolderMapping)targetFolder;
if (folderMapping.SourceFolder != null)
{
return(folderMapping.SourceFolder.EntryId);
}
return(folderMapping.FolderRec[this.DestHierarchy.SourceEntryIDPtag] as byte[]);
}
private void VerifyFolderContents(FolderMapping fm, List <FolderSizeRec> verificationResults)
{
FolderSizeRec folderSizeRec = this.MailboxMerger.VerifyFolderContents(fm, fm.WKFType, false);
if (folderSizeRec != null)
{
verificationResults.Add(folderSizeRec);
this.MailboxMerger.ReportBadItems(folderSizeRec.MissingItems);
}
}
public override void ApplyContentsChanges(SyncContext ctx, MailboxChanges changes)
{
MrsTracer.Service.Function("MailboxMerger.ApplyContentsChanges", new object[0]);
if (changes.HasFolderRecoverySync)
{
return;
}
foreach (FolderChangesManifest folderChangesManifest in changes.FolderChanges.Values)
{
FolderMapping folderMapping = (FolderMapping)this.SourceHierarchy[folderChangesManifest.FolderId];
if (folderMapping == null)
{
MrsTracer.Service.Warning("Folder {0} is not discovered in source, will not apply changes", new object[]
{
TraceUtils.DumpEntryId(folderChangesManifest.FolderId)
});
return;
}
using (ISourceFolder folder = base.SourceMailbox.GetFolder(folderMapping.EntryId))
{
if (folder == null)
{
MrsTracer.Service.Warning("Folder {0} disappeared from source, will not apply changes", new object[]
{
TraceUtils.DumpEntryId(folderChangesManifest.FolderId)
});
return;
}
byte[] array = base.FolderIdTranslator.TranslateFolderId(folderChangesManifest.FolderId);
if (array == null)
{
MrsTracer.Service.Warning("Source folder {0} is not present in target mailbox, will not apply changes", new object[]
{
TraceUtils.DumpEntryId(folderChangesManifest.FolderId)
});
return;
}
using (IDestinationFolder folder2 = base.DestMailbox.GetFolder(array))
{
if (folder2 == null)
{
MrsTracer.Service.Warning("Destination folder {0} disappeared, will not apply changes", new object[]
{
TraceUtils.DumpEntryId(array)
});
return;
}
this.ApplyFolderChanges(ctx, folderChangesManifest, folderMapping, folder, folder2);
}
}
}
base.ReportContentChangesSynced(ctx);
base.ICSSyncState.ProviderState = base.SourceMailbox.GetMailboxSyncState();
base.SaveICSSyncState(false);
}
public override FolderRecWrapper GetTargetFolderBySourceId(byte[] sourceId)
{
FolderMap sourceFolderMap = base.SourceFolderMap;
FolderMapping folderMapping = base.SourceFolderMap[sourceId] as FolderMapping;
if (folderMapping != null && folderMapping.IsSystemPublicFolder)
{
FolderHierarchy folderHierarchy = base.TargetFolderMap as FolderHierarchy;
return folderHierarchy.GetWellKnownFolder(folderMapping.WKFType);
}
return base.TargetFolderMap[this.destinationMailbox.GetSessionSpecificEntryId(sourceId)];
}
private void MapSubtreeByName(FolderMapping root, bool createIfNeeded)
{
this.EnumerateSubtree(EnumHierarchyFlags.AllFolders, root, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)fRec;
if (folderMapping.IsIncluded && folderMapping.TargetFolder == null)
{
this.MapFolderChainByName(folderMapping, createIfNeeded);
}
});
}
public void CreateMissingFolders()
{
IDestinationMailbox destMailbox = (IDestinationMailbox)this.MbxWrapper.Mailbox;
base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx)
{
if (fRec.EntryId != null)
{
return;
}
FolderMapping fm = (FolderMapping)fRec;
fm.FolderRec.ParentId = fm.ParentId;
ExecutionContext.Create(new DataContext[]
{
new FolderRecWrapperDataContext(fRec)
}).Execute(delegate
{
byte[] array;
destMailbox.CreateFolder(fRec.FolderRec, CreateFolderFlags.FailIfExists, out array);
fm.FolderRec.EntryId = array;
this[array] = fm;
if (fm.SourceFolder != null)
{
List <PropValueData> list = new List <PropValueData>();
list.Add(new PropValueData(this.SourceEntryIDPtag, fm.SourceFolder.EntryId));
list.Add(new PropValueData(this.SourceLastModifiedTimestampPtag, fm.SourceFolder.FolderRec.LastModifyTimestamp));
if (fm.SourceFolder.WKFType != WellKnownFolderType.None)
{
list.Add(new PropValueData(this.SourceWKFTypePtag, (int)fm.SourceFolder.WKFType));
}
using (IDestinationFolder folder = destMailbox.GetFolder(array))
{
if (folder != null)
{
folder.SetProps(list.ToArray());
}
else
{
MrsTracer.Service.Warning("Something just deleted newly created folder from under us. Ignoring.", new object[0]);
}
}
if (fm.SourceFolder.WKFType != WellKnownFolderType.None && this.GetWellKnownFolder(fm.SourceFolder.WKFType) == null)
{
this.SetWellKnownFolder(fm.SourceFolder.WKFType, fm);
if (this.RootFolder == this.RootRec && (this.MbxWrapper.Flags & MailboxWrapperFlags.Archive) == (MailboxWrapperFlags)0 && (this.MbxWrapper.Flags & MailboxWrapperFlags.PST) == (MailboxWrapperFlags)0)
{
this.WriteWellKnownFolderReference(fm.SourceFolder.WKFType, fm.EntryId);
}
}
}
});
});
}
private void FindNamedFolders(NamedFolderMapping[] map)
{
foreach (NamedFolderMapping namedFolderMapping in map)
{
FolderMapping wellKnownFolder = this.GetWellKnownFolder(namedFolderMapping.ParentType);
if (wellKnownFolder != null)
{
FolderMapping folder = wellKnownFolder.FindChildByName(namedFolderMapping.FolderName, base.TargetMailboxCulture) as FolderMapping;
this.SetWellKnownFolder(namedFolderMapping.WKFType, folder);
}
}
}
protected FolderContentsMapper(FolderMapping folderMapping, ISourceFolder srcFolder, FolderHierarchy sourceHierarchy, IDestinationFolder destFolder, FolderHierarchy destHierarchy, ConflictResolutionOption conflictResolutionOption, FAICopyOption faiCopyOption, FolderContentsMapperFlags mapperFlags)
{
this.folderMapping = folderMapping;
this.srcFolder = srcFolder;
this.destFolder = destFolder;
this.destHierarchy = destHierarchy;
this.sourceHierarchy = sourceHierarchy;
this.conflictResolutionOption = conflictResolutionOption;
this.faiCopyOption = faiCopyOption;
this.sourceMapping = new EntryIdMap <MessageRec>();
this.targetMapping = new EntryIdMap <MessageRec>();
this.mapperFlags = mapperFlags;
}
public byte[] TranslateFolderId(byte[] sourceEntryId)
{
if (sourceEntryId == null)
{
return(null);
}
FolderMapping folderMapping = (FolderMapping)this.sourceHierarchy[sourceEntryId];
if (folderMapping == null || folderMapping.TargetFolder == null)
{
return(null);
}
return(folderMapping.TargetFolder.EntryId);
}
private void MapPublicFolderDumpster(FolderMapping sourceFolder, FolderMapping targetFolder)
{
if (!base.IsPublicFolderMailbox)
{
return;
}
FolderMapping folderMapping = (FolderMapping)sourceFolder.PublicFolderDumpster;
FolderMapping folderMapping2 = (FolderMapping)targetFolder.PublicFolderDumpster;
if (folderMapping != null && folderMapping2 != null)
{
folderMapping.TargetFolder = folderMapping2;
folderMapping2.SourceFolder = folderMapping;
}
}
private void MapFolderChainByName(FolderMapping fm, bool createIfNeeded)
{
if (fm.TargetFolder != null)
{
return;
}
this.MapFolderChainByName((FolderMapping)fm.Parent, createIfNeeded);
FolderMapping targetFolder = ((FolderMapping)fm.Parent).TargetFolder;
if (targetFolder == null)
{
return;
}
this.MapFolderByName(fm, targetFolder, createIfNeeded);
}
public void CopyFolderData(FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder)
{
MrsTracer.Service.Debug("Loading mappable folder properties", new object[0]);
FolderRecDataFlags dataToCopy = FolderRecDataFlags.SearchCriteria;
if (!base.MRSJob.CachedRequestJob.IsPublicFolderMailboxRestore)
{
bool flag;
this.CopyFolderProperties(fm, srcFolder, destFolder, dataToCopy, out flag);
}
if (fm.FolderType != FolderType.Search)
{
this.MergeFolderContents(fm, srcFolder, destFolder);
}
}
protected void ScheduleContentVerification()
{
base.Report.Append(MrsStrings.ReportVerifyingMailboxContents);
List <FolderSizeRec> verificationResults = new List <FolderSizeRec>();
this.MailboxMerger.SourceHierarchy.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper folderRecWrapper, FolderMap.EnumFolderContext ctx)
{
FolderMapping folderMapping = (FolderMapping)folderRecWrapper;
if (folderMapping.IsIncluded)
{
this.ScheduleWorkItem <FolderMapping, List <FolderSizeRec> >(new Action <FolderMapping, List <FolderSizeRec> >(this.VerifyFolderContents), folderMapping, verificationResults, WorkloadType.Unknown);
}
});
base.ScheduleWorkItem <List <FolderSizeRec> >(new Action <List <FolderSizeRec> >(this.OutputVerificationResults), verificationResults, WorkloadType.Unknown);
}
private void DiscoverWellKnownFolders()
{
this.wellKnownFolderMap.Clear();
this.SetWellKnownFolder(WellKnownFolderType.Root, (FolderMapping)this.RootRec);
List <WellKnownFolder> list = this.MbxWrapper.Mailbox.DiscoverWellKnownFolders((int)this.Flags);
if (list != null)
{
foreach (WellKnownFolder wellKnownFolder in list)
{
FolderMapping folder = (FolderMapping) base[wellKnownFolder.EntryId];
this.SetWellKnownFolder((WellKnownFolderType)wellKnownFolder.WKFType, folder);
}
}
this.FindNamedFolders(FolderHierarchyUtils.NamedFolderRefs);
}
internal void ResetFolder(FolderMapping folder)
{
MrsTracer.Service.Function("MailboxContentsCrawler.ResetFolder: '{0}'", new object[]
{
folder
});
base.CheckDisposed();
byte[] entryId = folder.EntryId;
this.crawledFolders.Remove(entryId);
FolderContentsCrawler folderContentsCrawler;
if (this.crawlers.TryGetValue(entryId, out folderContentsCrawler))
{
folderContentsCrawler.Dispose();
this.crawlers.Remove(entryId);
}
}
private void MarkPublicFolderDumpster(FolderRecWrapper sourceFolder)
{
if (!base.IsPublicFolderMailbox)
{
return;
}
FolderMapping folderMapping = (FolderMapping)sourceFolder;
if (!folderMapping.IsPublicFolderDumpster && ((folderMapping.Flags & FolderMappingFlags.Include) != FolderMappingFlags.None || (folderMapping.Flags & FolderMappingFlags.InheritedInclude) != FolderMappingFlags.None))
{
FolderMapping folderMapping2 = (FolderMapping)sourceFolder.PublicFolderDumpster;
if (folderMapping2 != null)
{
folderMapping2.Flags |= FolderMappingFlags.Include;
}
}
}
private void MapFolderByName(FolderMapping sourceFolder, FolderMapping parentTargetFolder, bool createIfNeeded)
{
FolderMapping folderMapping = (FolderMapping)parentTargetFolder.FindChildByName(sourceFolder.FolderName, base.TargetMailboxCulture);
if (folderMapping == null)
{
if (!createIfNeeded)
{
return;
}
folderMapping = new FolderMapping(sourceFolder.FolderName, sourceFolder.FolderType, sourceFolder.FolderClass);
folderMapping.Parent = parentTargetFolder;
}
sourceFolder.TargetFolder = folderMapping;
folderMapping.SourceFolder = sourceFolder;
this.MapPublicFolderDumpster(sourceFolder, folderMapping);
}
public void MergeFolderContentsPaged(FolderMapping folder, FolderContentsCrawler sourceFolderCrawler, IDestinationFolder destFolder, TimeSpan maxOperationDuration)
{
MrsTracer.Service.Function("MailboxMerger.MergeFolderContentsPaged({0})", new object[]
{
folder.FullFolderName
});
ISourceFolder wrappedObject = sourceFolderCrawler.WrappedObject;
if (this.ContentRestriction != null)
{
wrappedObject.SetContentsRestriction(this.ContentRestriction);
}
FolderContentsMapper folderContentsMapper = FolderContentsMapper.Create(folder, wrappedObject, this.SourceHierarchy, destFolder, this.DestHierarchy, this.GetConflictResolutionOption(folder), base.MRSJob.CachedRequestJob.AssociatedMessagesCopyOption ?? FAICopyOption.DoNotCopy, (base.MRSJob.CachedRequestJob.SyncProtocol == SyncProtocol.Imap) ? FolderContentsMapperFlags.ImapSync : FolderContentsMapperFlags.None);
DateTime utcNow = DateTime.UtcNow;
int alreadyCopiedCount;
ulong alreadyCopiedSize;
List <MessageRec> itemsToCopy;
List <MessageRec> list;
while (folderContentsMapper.ComputeMappingPaged(sourceFolderCrawler, (base.SyncState == null) ? null : base.SyncState.BadItems, out alreadyCopiedCount, out alreadyCopiedSize, out itemsToCopy, out list))
{
SyncProtocol syncProtocol = base.MRSJob.CachedRequestJob.SyncProtocol;
foreach (MessageRec messageRec in list)
{
destFolder.SetMessageProps(messageRec.EntryId, messageRec.AdditionalProps);
}
base.MailboxSizeTracker.TrackFolder(folder.EntryId, sourceFolderCrawler.TotalMessageCount, alreadyCopiedCount, alreadyCopiedSize);
base.MRSJob.MessagesWritten += base.MailboxSizeTracker.AlreadyCopiedCount;
base.MRSJob.MessageSizeWritten += base.MailboxSizeTracker.AlreadyCopiedSize;
base.MRSJob.TotalMessages = base.MailboxSizeTracker.MessageCount;
base.MRSJob.TotalMessageByteSize = base.MailboxSizeTracker.TotalMessageSize;
this.CopyMessageBatch(folderContentsMapper, itemsToCopy, folder);
DateTime utcNow2 = DateTime.UtcNow;
if (utcNow2 - utcNow >= maxOperationDuration)
{
MrsTracer.Service.Debug("MergeFolderContentsPaged times out for assigned duration {0}. Start:{1}, End:{2}", new object[]
{
maxOperationDuration,
utcNow,
utcNow2
});
return;
}
}
}
public override bool IsContentAvailableInTargetMailbox(FolderRecWrapper destinationFolderRec)
{
FolderMapping folderMapping = destinationFolderRec as FolderMapping;
if (folderMapping.IsSystemPublicFolder || destinationFolderRec.IsPublicFolderDumpster)
{
return(false);
}
byte[] array = destinationFolderRec.FolderRec[PropTag.ReplicaList] as byte[];
if (array != null)
{
StorePropertyDefinition replicaList = CoreFolderSchema.ReplicaList;
string[] stringArrayFromBytes = ReplicaListProperty.GetStringArrayFromBytes(array);
Guid a;
return(stringArrayFromBytes.Length > 0 && GuidHelper.TryParseGuid(stringArrayFromBytes[0], out a) && a == base.TargetMailboxGuid);
}
return(true);
}
private void CopyFolderPropertiesAndContents(FolderMapping folder, FolderContentsCrawler sourceFolderCrawler, bool shouldCopyProperties, TimeSpan maxOperationDuration)
{
PagedMergeJob.< > c__DisplayClass1 CS$ < > 8__locals1 = new PagedMergeJob.< > c__DisplayClass1();
CS$ < > 8__locals1.folder = folder;
CS$ < > 8__locals1.sourceFolderCrawler = sourceFolderCrawler;
CS$ < > 8__locals1.shouldCopyProperties = shouldCopyProperties;
CS$ < > 8__locals1.maxOperationDuration = maxOperationDuration;
CS$ < > 8__locals1.< > 4__this = this;
using (IDestinationFolder destFolder = base.MailboxMerger.DestMailbox.GetFolder(CS$ < > 8__locals1.folder.TargetFolder.EntryId))
{
if (destFolder == null)
{
base.Report.Append(MrsStrings.ReportTargetFolderDeleted(CS$ < > 8__locals1.folder.TargetFolder.FullFolderName, TraceUtils.DumpEntryId(CS$ < > 8__locals1.folder.TargetFolder.EntryId), CS$ < > 8__locals1.folder.FullFolderName));
return;
}
ExecutionContext.Create(new DataContext[]
{
new FolderRecWrapperDataContext(CS$ < > 8__locals1.folder)
}).Execute(delegate
