public static bool ShouldItemBeIgnored(MessageRec msgRec, EntryIdMap <BadItemMarker> badItemMarkers, FAICopyOption faiCopyOption, out string faiMessageClass) { faiMessageClass = null; if (msgRec.IsFAI) { if (faiCopyOption == FAICopyOption.DoNotCopy) { return(true); } faiMessageClass = (msgRec[PropTag.MessageClass] as string); if (!string.IsNullOrEmpty(faiMessageClass) && FolderContentsMapper.IgnoredFaiMessageClasses.Contains(faiMessageClass)) { return(true); } } if (badItemMarkers != null && badItemMarkers.ContainsKey(msgRec.EntryId)) { BadItemMarker badItemMarker = badItemMarkers[msgRec.EntryId]; if (FolderContentsMapper.SkippedBadItemKinds.Contains(badItemMarker.Kind)) { return(true); } } return(false); }
public bool ComputeMappingPaged(FolderContentsCrawler folderCrawler, EntryIdMap <BadItemMarker> badItemMarkers, out int skippedItemCount, out ulong skippedItemSize, out List <MessageRec> itemsToCopy, out List <MessageRec> targetMessagePropsChanges) { MrsTracer.Service.Function("FolderContentsMapper.ComputeMappingPaged", new object[0]); MrsTracer.Service.Debug("Loading source folder contents", new object[0]); IReadOnlyCollection <MessageRec> messagesNextPage = folderCrawler.GetMessagesNextPage(); if (messagesNextPage.Count == 0) { itemsToCopy = null; targetMessagePropsChanges = null; skippedItemCount = 0; skippedItemSize = 0UL; return(false); } List <byte[]> list = new List <byte[]>(messagesNextPage.Count); foreach (MessageRec messageRec in messagesNextPage) { list.Add(messageRec.EntryId); } MrsTracer.Service.Debug("Looking up target messages", new object[0]); List <MessageRec> targetMessages = this.destFolder.LookupMessages(this.destHierarchy.SourceEntryIDPtag, list, this.GetTargetPTagsInitialSync()); this.ComputeMapping(messagesNextPage, targetMessages, badItemMarkers, out skippedItemCount, out skippedItemSize, out itemsToCopy, out targetMessagePropsChanges); return(true); }
private void MapSourceToTargetMessageBySourceEntryId(MessageRec sourceMR, EntryIdMap <MessageRec> targetBySourceEntryId, out MessageRec targetMR) { targetMR = null; byte[] keyPlusLMTHash = this.GetKeyPlusLMTHash(sourceMR, PropTag.EntryId, PropTag.LastModificationTime); if (keyPlusLMTHash != null) { targetBySourceEntryId.TryGetValue(keyPlusLMTHash, out targetMR); } }
protected override MailboxChangesManifest EnumerateSourceHierarchyChanges(MailboxCopierBase mbxCtx, bool catchup, SyncContext syncContext) { if (catchup) { if (!mbxCtx.IsRoot) { return(null); } return(base.EnumerateSourceHierarchyChanges(mbxCtx, catchup, syncContext)); } else { if (mbxCtx.IsRoot) { return(base.EnumerateSourceHierarchyChanges(mbxCtx, catchup, syncContext)); } FolderMap destinationFolderMap = base.GetRootMailboxContext().GetDestinationFolderMap(GetFolderMapFlags.None); EntryIdMap <FolderRecWrapper> primaryMailboxFolderRecWrappers = new EntryIdMap <FolderRecWrapper>(); destinationFolderMap.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper primaryFolderRecWrapper, FolderMap.EnumFolderContext enumFolderContext) { if (mbxCtx.IsContentAvailableInTargetMailbox(primaryFolderRecWrapper)) { byte[] key = (byte[])primaryFolderRecWrapper.FolderRec[PropTag.LTID]; primaryMailboxFolderRecWrappers[key] = primaryFolderRecWrapper; } }); EntryIdMap <FolderRecWrapper> secondaryMailboxFolderRecWrappers = new EntryIdMap <FolderRecWrapper>(); syncContext.TargetFolderMap.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper secondaryFolderRecWrapper, FolderMap.EnumFolderContext enumFolderContext) { if (mbxCtx.IsContentAvailableInTargetMailbox(secondaryFolderRecWrapper)) { byte[] key = (byte[])secondaryFolderRecWrapper.FolderRec[PropTag.LTID]; secondaryMailboxFolderRecWrappers[key] = secondaryFolderRecWrapper; } }); MailboxChangesManifest mailboxChangesManifest = new MailboxChangesManifest(); mailboxChangesManifest.ChangedFolders = new List <byte[]>(); mailboxChangesManifest.DeletedFolders = new List <byte[]>(); foreach (KeyValuePair <byte[], FolderRecWrapper> keyValuePair in primaryMailboxFolderRecWrappers) { FolderRecWrapper folderRecWrapper; if (!secondaryMailboxFolderRecWrappers.TryGetValue(keyValuePair.Key, out folderRecWrapper) || folderRecWrapper.FolderRec.LastModifyTimestamp != keyValuePair.Value.FolderRec.LastModifyTimestamp) { mailboxChangesManifest.ChangedFolders.Add(mbxCtx.SourceMailbox.GetSessionSpecificEntryId(keyValuePair.Key)); } } foreach (KeyValuePair <byte[], FolderRecWrapper> keyValuePair2 in secondaryMailboxFolderRecWrappers) { FolderRecWrapper folderRecWrapper2; if (!primaryMailboxFolderRecWrappers.TryGetValue(keyValuePair2.Key, out folderRecWrapper2)) { mailboxChangesManifest.DeletedFolders.Add(mbxCtx.SourceMailbox.GetSessionSpecificEntryId(keyValuePair2.Key)); } } return(mailboxChangesManifest); } }
public EntryIdMap <WellKnownFolderType> GetEntryIdToWkfTypeMap() { EntryIdMap <WellKnownFolderType> entryIdMap = new EntryIdMap <WellKnownFolderType>(); foreach (KeyValuePair <byte[], WellKnownFolderType> keyValuePair in this.wellKnownFolderTypes) { entryIdMap[keyValuePair.Key] = keyValuePair.Value; } return(entryIdMap); }
EntryIdMap <byte[]> IFxProxyPool.GetFolderData() { EntryIdMap <byte[]> result = null; using (base.CreateCostHandle()) { result = base.WrappedObject.GetFolderData(); } return(result); }
EntryIdMap <byte[]> IFxProxyPool.GetFolderData() { EntryIdMap <byte[]> result = null; base.CreateContext("IFxProxyPool.GetFolderData", new DataContext[0]).Execute(delegate { result = this.WrappedObject.GetFolderData(); }, true); return(result); }
public void ComputeMapping(EntryIdMap <BadItemMarker> badItemMarkers, out int skippedItemCount, out ulong skippedItemSize, out List <MessageRec> itemsToCopy, out List <MessageRec> targetMessagePropsChanges) { MrsTracer.Service.Function("FolderContentsMapper.ComputeMapping", new object[0]); MrsTracer.Service.Debug("Loading source folder contents", new object[0]); List <MessageRec> sourceMessages = this.srcFolder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages | EnumerateMessagesFlags.IncludeExtendedData, this.GetSourcePTagsInitialSync()); MrsTracer.Service.Debug("Loading target folder contents", new object[0]); List <MessageRec> targetMessages = this.destFolder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages, this.GetTargetPTagsInitialSync()); this.ComputeMapping(sourceMessages, targetMessages, badItemMarkers, out skippedItemCount, out skippedItemSize, out itemsToCopy, out targetMessagePropsChanges); }
protected virtual void MapSourceToTargetMessage(MessageRec sourceMR, EntryIdMap <MessageRec> targetBySourceEntryId, EntryIdMap <MessageRec> targetBySecondaryKey, HashSet <byte[]> duplicateTargetSecondaryKeys, HashSet <byte[]> duplicateSourceSecondaryKeys, out MessageRec targetMR) { targetMR = null; this.MapSourceToTargetMessageBySourceEntryId(sourceMR, targetBySourceEntryId, out targetMR); if (targetMR == null) { byte[] keyPlusLMTHash = this.GetKeyPlusLMTHash(sourceMR, PropTag.SearchKey, PropTag.LastModificationTime); if (keyPlusLMTHash != null && !duplicateSourceSecondaryKeys.Contains(keyPlusLMTHash)) { targetBySecondaryKey.TryGetValue(keyPlusLMTHash, out targetMR); } } }
EntryIdMap <byte[]> IFxProxyPool.GetFolderData() { EntryIdMap <byte[]> entryIdMap = new EntryIdMap <byte[]>(); foreach (KeyValuePair <byte[], byte[]> keyValuePair in base.WrappedObject.GetFolderData()) { if (keyValuePair.Key.Length == 46) { entryIdMap.Add(this.sourceMailbox.GetSessionSpecificEntryId(keyValuePair.Key), keyValuePair.Value); } } return(entryIdMap); }
protected void RefreshFolderCache(EasHierarchySyncState state) { IReadOnlyCollection <Add> folders = state.Folders; EntryIdMap <Add> entryIdMap = new EntryIdMap <Add>(folders.Count); this.defaultCalendarId = null; foreach (Add add in folders) { EasFolderType easFolderType = add.GetEasFolderType(); if (easFolderType == EasFolderType.Calendar) { this.defaultCalendarId = EasMailbox.GetEntryId(add.ServerId); } EasFolderType easFolderType2 = easFolderType; if (easFolderType2 == EasFolderType.UserGeneric) { goto IL_8B; } bool flag; switch (easFolderType2) { case EasFolderType.Contacts: case EasFolderType.UserContacts: flag = !ConfigBase <MRSConfigSchema> .GetConfig <bool>("DisableContactSync"); goto IL_9D; case EasFolderType.UserMail: case EasFolderType.UserCalendar: goto IL_8B; } flag = EasMailbox.folderTypeMap.ContainsKey(easFolderType); IL_9D: if (flag) { entryIdMap.Add(EasMailbox.GetEntryId(add.ServerId), add); continue; } MrsTracer.Provider.Debug("EasMailbox.RefreshFolderCache: ignore {0} folder '{1}' since it is not supported yet", new object[] { easFolderType, add.DisplayName }); continue; IL_8B: flag = true; goto IL_9D; } this.EasFolderCache = entryIdMap; }
protected override MailboxChangesManifest RunManualHierarchySync(bool catchup, SyncHierarchyManifestState hierState) { MrsTracer.Provider.Function("EasSourceMailbox.RunManualHierarchySync", new object[0]); base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None); EasHierarchySyncState easHierarchySyncState = EasHierarchySyncState.Deserialize(hierState.ProviderSyncState); hierState.ProviderSyncState = null; EasHierarchySyncState easHierarchySyncState2 = base.RefreshFolderCache(); EntryIdMap <EasHierarchySyncState.EasFolderData> entryIdMap = new EntryIdMap <EasHierarchySyncState.EasFolderData>(); foreach (EasHierarchySyncState.EasFolderData easFolderData in easHierarchySyncState.FolderData) { entryIdMap[EasMailbox.GetEntryId(easFolderData.ServerId)] = easFolderData; } EntryIdMap <EasHierarchySyncState.EasFolderData> entryIdMap2 = new EntryIdMap <EasHierarchySyncState.EasFolderData>(); foreach (EasHierarchySyncState.EasFolderData easFolderData2 in easHierarchySyncState2.FolderData) { entryIdMap2[EasMailbox.GetEntryId(easFolderData2.ServerId)] = easFolderData2; } MailboxChangesManifest mailboxChangesManifest = new MailboxChangesManifest(); mailboxChangesManifest.DeletedFolders = new List <byte[]>(); foreach (byte[] array in entryIdMap.Keys) { if (!entryIdMap2.ContainsKey(array)) { mailboxChangesManifest.DeletedFolders.Add(array); } } mailboxChangesManifest.ChangedFolders = new List <byte[]>(); foreach (KeyValuePair <byte[], EasHierarchySyncState.EasFolderData> keyValuePair in entryIdMap2) { byte[] key = keyValuePair.Key; EasHierarchySyncState.EasFolderData value = keyValuePair.Value; EasHierarchySyncState.EasFolderData easFolderData3; if (entryIdMap.TryGetValue(key, out easFolderData3)) { if (easFolderData3.ParentId != value.ParentId || easFolderData3.DisplayName != value.DisplayName) { mailboxChangesManifest.ChangedFolders.Add(key); } } else { mailboxChangesManifest.ChangedFolders.Add(key); } } return(mailboxChangesManifest); }
protected override void MapSourceToTargetMessage(MessageRec sourceMR, EntryIdMap <MessageRec> targetBySourceEntryId, EntryIdMap <MessageRec> targetBySecondaryKey, HashSet <byte[]> duplicateTargetSecondaryKeys, HashSet <byte[]> duplicateSourceSecondaryKeys, out MessageRec targetMR) { targetMR = null; byte[] array = ImapFolderContentsMapper.GetImapSyncPropertiesHash(sourceMR, this.sourceHierarchy); if (array != null) { targetBySecondaryKey.TryGetValue(array, out targetMR); } if (targetMR == null) { array = ImapFolderContentsMapper.GetSyncMessageIdHash(sourceMR, MessageRecType.Source, this.sourceHierarchy); targetBySecondaryKey.TryGetValue(array, out targetMR); } }
public void PrefetchSourceMessageIdsFromTargetMessageIds(EntryIdMap <List <byte[]> > destMessagesToTranslate) { this.prefetchedSourceEntryIdMap.Clear(); PropTag sourceEntryIDPtag = this.Merger.DestHierarchy.SourceEntryIDPtag; PropTag[] additionalPtagsToLoad = new PropTag[] { sourceEntryIDPtag }; foreach (KeyValuePair <byte[], List <byte[]> > keyValuePair in destMessagesToTranslate) { byte[] key = keyValuePair.Key; List <byte[]> value = keyValuePair.Value; foreach (byte[] key2 in value) { this.prefetchedSourceEntryIdMap[key2] = null; } using (IDestinationFolder folder = this.Merger.DestMailbox.GetFolder(key)) { if (folder == null) { MrsTracer.Service.Warning("Destination folder {0} disappeared", new object[] { TraceUtils.DumpEntryId(key) }); } else { List <MessageRec> list = folder.LookupMessages(PropTag.EntryId, value, additionalPtagsToLoad); foreach (MessageRec messageRec in list) { byte[] array = messageRec[sourceEntryIDPtag] as byte[]; if (array == null) { MrsTracer.Service.Warning("Destination message {0} doesn't have mapped source message", new object[] { TraceUtils.DumpEntryId(messageRec.EntryId) }); } else { this.prefetchedSourceEntryIdMap[messageRec.EntryId] = array; } } } } } }
EntryIdMap <byte[]> IFxProxyPool.GetFolderData() { EntryIdMap <byte[]> folderData = base.WrappedObject.GetFolderData(); EntryIdMap <byte[]> entryIdMap = new EntryIdMap <byte[]>(); foreach (KeyValuePair <byte[], byte[]> keyValuePair in folderData) { byte[] array = keyValuePair.Key; if (CommonUtils.IsSameEntryId(array, this.mapper.folderMapping.TargetFolder.EntryId)) { array = this.mapper.folderMapping.EntryId; } entryIdMap.Add(array, keyValuePair.Value); } return(entryIdMap); }
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); }
List <MessageRec> IFolder.LookupMessages(PropTag ptagToLookup, List <byte[]> keysToLookup, PropTag[] additionalPtagsToLoad) { MrsTracer.Provider.Function("StorageFolder.LookupMessages: {0}", new object[] { this.DisplayNameForTracing }); EntryIdMap <MessageRec> result = new EntryIdMap <MessageRec>(); ItemQueryType[] array = new ItemQueryType[] { ItemQueryType.None, ItemQueryType.Associated }; int capacity = 3 + ((additionalPtagsToLoad == null) ? 0 : additionalPtagsToLoad.Length); List <PropertyDefinition> columns = new List <PropertyDefinition>(capacity) { CoreObjectSchema.EntryId, CoreItemSchema.Size, CoreObjectSchema.CreationTime }; int idxEntryId = 0; int idxMessageSize = 1; int idxCreationTime = 2; int idxExtraProperties = 3; if (additionalPtagsToLoad != null && additionalPtagsToLoad.Length > 0) { columns.AddRange(this.Mailbox.ConvertPropTagsToDefinitions(additionalPtagsToLoad)); } ItemQueryType[] array2 = array; for (int i = 0; i < array2.Length; i++) { StorageFolder.< > c__DisplayClassb CS$ < > 8__locals2 = new StorageFolder.< > c__DisplayClassb(); CS$ < > 8__locals2.queryType = array2[i]; if (result.Count >= keysToLookup.Count) { break; } bool doingFAI = CS$ < > 8__locals2.queryType == ItemQueryType.Associated; ExecutionContext.Create(new DataContext[] { new OperationDataContext("StorageFolder.GetContentsTable", OperationType.None), new SimpleValueDataContext("QueryType", CS$ < > 8__locals2.queryType) }).Execute(delegate
public ReplayActionsQueue GetAndTranslateActions(string replaySyncState, int maxNumberOfActions, MergeSyncContext syncContext, out string retrieveSyncState, out bool moreActions) { MrsTracer.Service.Function("MailboxMerger.GetAndTranslateActions", new object[0]); List <ReplayAction> actions = base.DestMailbox.GetActions(replaySyncState, maxNumberOfActions); moreActions = (actions.Count == maxNumberOfActions); retrieveSyncState = ((actions.Count == 0) ? replaySyncState : actions[actions.Count - 1].Watermark); ReplayActionsQueue replayActionsQueue = new ReplayActionsQueue(actions.Count); foreach (ReplayAction action in actions) { replayActionsQueue.Enqueue(action); } EntryIdMap <List <byte[]> > entryIdMap = new EntryIdMap <List <byte[]> >(); foreach (ReplayAction replayAction in actions) { if (!replayAction.Ignored) { foreach (KeyValuePair <byte[], byte[]> keyValuePair in replayAction.GetMessageEntryIdsToTranslate()) { byte[] key = keyValuePair.Key; byte[] value = keyValuePair.Value; List <byte[]> list; if (!entryIdMap.TryGetValue(key, out list)) { list = new List <byte[]>(); entryIdMap.Add(key, list); } list.Add(value); } } } syncContext.PrefetchSourceMessageIdsFromTargetMessageIds(entryIdMap); foreach (ReplayAction replayAction2 in actions) { if (!replayAction2.Ignored) { replayAction2.TranslateEntryIds(syncContext); } } return(replayActionsQueue); }
EntryIdMap <byte[]> IFxProxyPool.GetFolderData() { EntryIdMap <byte[]> entryIdMap = new EntryIdMap <byte[]>(); if (this.folderIds != null) { foreach (byte[] array in this.folderIds) { using (TFolderEntry tfolderEntry = this.OpenFolder(array)) { entryIdMap[array] = ((tfolderEntry != null) ? this.FolderGetObjectData(tfolderEntry) : null); } } } byte[] array2 = this.MessageGetObjectData(default(TMessageEntry)); if (array2 != null) { entryIdMap[CommonUtils.MessageData] = array2; } return(entryIdMap); }
public MailboxChanges(EntryIdMap <FolderChangesManifest> folderChanges) { this.hierarchyChanges = new MailboxChangesManifest(); this.folderChanges = folderChanges; }
public void ComputeFolderMapping(FolderHierarchy targetHierarchy, bool createMissingFolderRecs) { if (!this.folderFilterApplied) { this.SetFolderFilter(null, false, null, string.Empty, false, Guid.Empty); } EntryIdMap <FolderMapping> targetBySourceEntryID = new EntryIdMap <FolderMapping>(); targetHierarchy.EnumerateSubtree(EnumHierarchyFlags.AllFolders, targetHierarchy.RootFolder, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; byte[] array = folderMapping.FolderRec[targetHierarchy.SourceEntryIDPtag] as byte[]; if (array != null && !targetBySourceEntryID.ContainsKey(array)) { targetBySourceEntryID.Add(array, folderMapping); } }); base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; FolderMapping wellKnownFolder; if (folderMapping.WKFType != WellKnownFolderType.None) { wellKnownFolder = targetHierarchy.GetWellKnownFolder(folderMapping.WKFType); if (wellKnownFolder != null) { folderMapping.TargetFolder = wellKnownFolder; wellKnownFolder.SourceFolder = folderMapping; this.MapPublicFolderDumpster(folderMapping, wellKnownFolder); return; } } if (targetBySourceEntryID.TryGetValue(folderMapping.EntryId, out wellKnownFolder)) { folderMapping.TargetFolder = wellKnownFolder; wellKnownFolder.SourceFolder = folderMapping; this.MapPublicFolderDumpster(folderMapping, wellKnownFolder); } }); base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; if (folderMapping.TargetFolder != null) { this.MapSubtreeByName(folderMapping, createMissingFolderRecs); ctx.Result = EnumHierarchyResult.SkipSubtree; } }); FolderMapping ipmSubtree = this.GetWellKnownFolder(WellKnownFolderType.IpmSubtree); if (ipmSubtree != null) { base.EnumerateFolderHierarchy(EnumHierarchyFlags.AllFolders, delegate(FolderRecWrapper fRec, FolderMap.EnumFolderContext ctx) { FolderMapping folderMapping = (FolderMapping)fRec; if (folderMapping.IsIncluded && folderMapping.TargetFolder == null) { this.MapFolderByName(folderMapping, ipmSubtree.TargetFolder, createMissingFolderRecs); if (folderMapping.TargetFolder != null) { this.MapSubtreeByName(folderMapping, createMissingFolderRecs); } ctx.Result = EnumHierarchyResult.SkipSubtree; } }); } }
public static void LookupBadMessagesInMailbox(ISourceMailbox mailbox, List <MessageRec> messages, out EntryIdMap <MessageRec> lookedUpMsgs, out EntryIdMap <FolderRec> folderRecs) { EntryIdMap <EntryIdMap <MessageRec> > entryIdMap = new EntryIdMap <EntryIdMap <MessageRec> >(); folderRecs = new EntryIdMap <FolderRec>(); lookedUpMsgs = new EntryIdMap <MessageRec>(); foreach (MessageRec messageRec in messages) { EntryIdMap <MessageRec> entryIdMap2; if (!entryIdMap.TryGetValue(messageRec.FolderId, out entryIdMap2)) { entryIdMap2 = new EntryIdMap <MessageRec>(); entryIdMap.Add(messageRec.FolderId, entryIdMap2); } entryIdMap2[messageRec.EntryId] = null; } MrsTracer.Common.Debug("Looking up {0} messages in {1} folders.", new object[] { messages.Count, entryIdMap.Count }); foreach (KeyValuePair <byte[], EntryIdMap <MessageRec> > keyValuePair in entryIdMap) { using (ISourceFolder folder = mailbox.GetFolder(keyValuePair.Key)) { if (folder == null) { MrsTracer.Common.Warning("Folder {0} disappeared.", new object[] { TraceUtils.DumpEntryId(keyValuePair.Key) }); } else { FolderRec folderRec = folder.GetFolderRec(null, GetFolderRecFlags.None); folderRecs[folderRec.EntryId] = folderRec; EntryIdMap <MessageRec> value = keyValuePair.Value; MrsTracer.Common.Debug("Looking up {0} messages in folder '{1}'.", new object[] { value.Count, folderRec.FolderName }); int num = 0; if (mailbox.IsCapabilitySupported(MRSProxyCapabilities.SimpleExport)) { List <byte[]> keysToLookup = new List <byte[]>(value.Keys); List <MessageRec> list = folder.LookupMessages(PropTag.EntryId, keysToLookup, BadMessageRec.BadItemPtags); if (list == null) { goto IL_230; } using (List <MessageRec> .Enumerator enumerator3 = list.GetEnumerator()) { while (enumerator3.MoveNext()) { MessageRec messageRec2 = enumerator3.Current; lookedUpMsgs[messageRec2.EntryId] = messageRec2; num++; } goto IL_230; } } List <MessageRec> list2 = folder.EnumerateMessages(EnumerateMessagesFlags.RegularMessages, BadMessageRec.BadItemPtags); foreach (MessageRec messageRec3 in list2) { if (value.ContainsKey(messageRec3.EntryId)) { lookedUpMsgs[messageRec3.EntryId] = messageRec3; num++; } } IL_230: MrsTracer.Common.Debug("Found {0} messages.", new object[] { num }); } } } MrsTracer.Common.Debug("Looked up {0} messages.", new object[] { lookedUpMsgs.Count }); }
List <MessageRec> IFolder.LookupMessages(PropTag ptagToLookup, List <byte[]> keysToLookup, PropTag[] additionalPtagsToLoad) { EntryIdMap <MessageRec> result = new EntryIdMap <MessageRec>(); ContentsTableFlags[] array = new ContentsTableFlags[] { ContentsTableFlags.None, ContentsTableFlags.Associated }; List <PropTag> pta = new List <PropTag>(5); int idxEntryId = pta.Count; pta.Add(PropTag.EntryId); int idxMessageSize = pta.Count; pta.Add(PropTag.MessageSize); int idxCreationTime = pta.Count; pta.Add(PropTag.CreationTime); int idxExtraPtags = pta.Count; if (additionalPtagsToLoad != null) { pta.AddRange(additionalPtagsToLoad); } for (int i = 0; i < array.Length; i++) { if (result.Count >= keysToLookup.Count) { break; } ContentsTableFlags flags = ContentsTableFlags.DeferredErrors | array[i]; bool doingFAI = (flags & ContentsTableFlags.Associated) != ContentsTableFlags.None; ExecutionContext.Create(new DataContext[] { new OperationDataContext("MapiFolder.GetContentsTable", OperationType.None), new SimpleValueDataContext("Flags", flags) }).Execute(delegate { MapiTable msgTable; using (this.Mailbox.RHTracker.Start()) { msgTable = this.Folder.GetContentsTable(flags); } using (msgTable) { if (ptagToLookup != PropTag.EntryId) { using (this.Mailbox.RHTracker.Start()) { msgTable.SortTable(new SortOrder(ptagToLookup, SortFlags.Ascend), SortTableFlags.None); } } msgTable.SetColumns(pta); using (List <byte[]> .Enumerator enumerator = keysToLookup.GetEnumerator()) { while (enumerator.MoveNext()) { byte[] key = enumerator.Current; if (!result.ContainsKey(key)) { ExecutionContext.Create(new DataContext[] { new EntryIDsDataContext(key) }).Execute(delegate { try { using (this.Mailbox.RHTracker.Start()) { if (!msgTable.FindRow(Restriction.EQ(ptagToLookup, key), BookMark.Beginning, FindRowFlag.None)) { return; } } } catch (MapiExceptionNotFound) { return; } PropValue[][] array2; using (this.Mailbox.RHTracker.Start()) { array2 = msgTable.QueryRows(1); } if (array2.Length == 1) { PropValue[] array3 = array2[0]; if (array3.Length != pta.Count) { return; } PropValueData[] array4 = null; if (additionalPtagsToLoad != null && additionalPtagsToLoad.Length > 0) { array4 = new PropValueData[additionalPtagsToLoad.Length]; for (int j = idxExtraPtags; j < array3.Length; j++) { array4[j - idxExtraPtags] = DataConverter <PropValueConverter, PropValue, PropValueData> .GetData(array3[j]); } } MessageRec value = new MessageRec(array3[idxEntryId].GetBytes(), this.FolderId, MapiUtils.GetDateTimeOrDefault(array3[idxCreationTime]), array3[idxMessageSize].GetInt(1000), doingFAI ? MsgRecFlags.Associated : MsgRecFlags.None, array4); result.Add(key, value); return; } }); } } } } }); } MrsTracer.Provider.Debug("MapiFolder.LookupMessages returns {0} items.", new object[] { result.Count }); return(new List <MessageRec>(result.Values)); }
public void ComputeIncrementalMapping(FolderChangesManifest folderChanges, EntryIdMap <BadItemMarker> badItemMarkers, out List <MessageRec> itemsToCopy, out byte[][] deletedTargetEntryIDs, out byte[][] readTargetEntryIDs, out byte[][] unreadTargetEntryIDs, out int skippedItemCount) { MrsTracer.Service.Function("FolderContentsMapper.ComputeIncrementalMapping", new object[0]); skippedItemCount = 0; itemsToCopy = null; deletedTargetEntryIDs = null; readTargetEntryIDs = null; unreadTargetEntryIDs = null; List <byte[]> list = new List <byte[]>(); List <byte[]> list2 = new List <byte[]>(); List <byte[]> list3 = new List <byte[]>(); if (folderChanges.ChangedMessages != null) { foreach (MessageRec messageRec in folderChanges.ChangedMessages) { list2.Add(messageRec.EntryId); if (!messageRec.IsDeleted) { list.Add(messageRec.EntryId); } else { list3.Add(messageRec.EntryId); } } } if (folderChanges.ReadMessages != null) { list2.AddRange(folderChanges.ReadMessages); } if (folderChanges.UnreadMessages != null) { list2.AddRange(folderChanges.UnreadMessages); } if (list2.Count == 0) { return; } list2.Sort(ArrayComparer <byte> .Comparer); List <PropTag> list4 = new List <PropTag>(); list4.Add(PropTag.SearchKey); list4.Add(PropTag.LastModificationTime); list4.Add(PropTag.MessageClass); List <MessageRec> list5 = null; if (list.Count > 0) { MrsTracer.Service.Debug("Loading changed source messages", new object[0]); list.Sort(ArrayComparer <byte> .Comparer); list5 = this.srcFolder.LookupMessages(PropTag.EntryId, list, list4.ToArray()); } EntryIdMap <MessageRec> entryIdMap = new EntryIdMap <MessageRec>(); if (this.conflictResolutionOption != ConflictResolutionOption.KeepAll) { list4.Add(this.destHierarchy.SourceEntryIDPtag); list4.Add(this.destHierarchy.SourceLastModifiedTimestampPtag); MrsTracer.Service.Debug("Looking up target messages", new object[0]); List <MessageRec> list6 = this.destFolder.LookupMessages(this.destHierarchy.SourceEntryIDPtag, list2, list4.ToArray()); foreach (MessageRec messageRec2 in list6) { byte[] array = messageRec2[this.destHierarchy.SourceEntryIDPtag] as byte[]; if (array != null) { this.targetMapping[array] = messageRec2; } byte[] keyPlusLMTHash = this.GetKeyPlusLMTHash(messageRec2, this.destHierarchy.SourceEntryIDPtag, this.destHierarchy.SourceLastModifiedTimestampPtag); if (keyPlusLMTHash != null) { entryIdMap[keyPlusLMTHash] = messageRec2; } } } if (list5 == null) { MrsTracer.Service.Debug("ChangedSourceIds {0}, SourceMessages looked up is null", new object[] { list.Count }); } else { if (list5.Count != list.Count) { MrsTracer.Service.Debug("ChangedSourceIds {0}, SourceMessages looked up {1}", new object[] { list.Count, list5.Count }); } itemsToCopy = new List <MessageRec>(); foreach (MessageRec messageRec3 in list5) { string text; if (FolderContentsMapper.ShouldItemBeIgnored(messageRec3, badItemMarkers, this.faiCopyOption, out text)) { skippedItemCount++; } else { MessageRec messageRec4 = null; this.MapSourceToTargetMessageBySourceEntryId(messageRec3, entryIdMap, out messageRec4); if (!this.ShouldItemBeCopied(messageRec3, messageRec4, null)) { skippedItemCount++; } else { if (messageRec4 == null) { messageRec3.Flags |= MsgRecFlags.New; } itemsToCopy.Add(messageRec3); this.sourceMapping[messageRec3.EntryId] = messageRec3; } } } } if (list3.Count > 0) { deletedTargetEntryIDs = this.RemapSourceIDsToTargetIDs(list3); } if (folderChanges.ReadMessages != null && folderChanges.ReadMessages.Count > 0) { readTargetEntryIDs = this.RemapSourceIDsToTargetIDs(folderChanges.ReadMessages); } if (folderChanges.UnreadMessages != null && folderChanges.UnreadMessages.Count > 0) { unreadTargetEntryIDs = this.RemapSourceIDsToTargetIDs(folderChanges.UnreadMessages); } }
private void RegisterUniqueTargetSecondaryKeys(MessageRec message, List <byte[]> secondaryKeys, EntryIdMap <MessageRec> messageMap, HashSet <byte[]> duplicateKeys) { foreach (byte[] array in secondaryKeys) { if (array != null && !duplicateKeys.Contains(array)) { if (!messageMap.ContainsKey(array)) { messageMap.Add(array, message); } else { MrsTracer.Service.Debug("Duplicate SecondaryKey found for target message {0}", new object[] { TraceUtils.DumpEntryId(message.EntryId) }); messageMap.Remove(array); duplicateKeys.Add(array); } } } }
public SimpleTranslatingProxyPool(IFxProxyPool destinationProxyPool, EntryIdMap <byte[]> sourceMap) : base(destinationProxyPool, true) { this.sourceMap = sourceMap; }
public FxProxyPoolGetFolderDataResponseMessage(EntryIdMap <byte[]> folderData) { this.folderData = folderData; }
public void ComputeMapping(IReadOnlyCollection <MessageRec> sourceMessages, IReadOnlyCollection <MessageRec> targetMessages, EntryIdMap <BadItemMarker> badItemMarkers, out int skippedItemCount, out ulong skippedItemSize, out List <MessageRec> itemsToCopy, out List <MessageRec> targetMessagePropsChanges) { itemsToCopy = new List <MessageRec>(sourceMessages.Count); targetMessagePropsChanges = new List <MessageRec>(); skippedItemCount = 0; skippedItemSize = 0UL; if (sourceMessages.Count == 0) { MrsTracer.Service.Debug("No more contents in source folder", new object[0]); return; } EntryIdMap <MessageRec> entryIdMap = new EntryIdMap <MessageRec>(); HashSet <byte[]> hashSet = new HashSet <byte[]>(ArrayComparer <byte> .EqualityComparer); EntryIdMap <MessageRec> entryIdMap2 = new EntryIdMap <MessageRec>(); Dictionary <string, List <MessageRec> > dictionary = null; Dictionary <string, List <MessageRec> > dictionary2 = null; if (this.faiCopyOption == FAICopyOption.MapByMessageClass) { dictionary = this.CreateFaiMap(sourceMessages, badItemMarkers); dictionary2 = this.CreateFaiMap(targetMessages, badItemMarkers); } foreach (MessageRec messageRec in targetMessages) { byte[] keyPlusLMTHash = this.GetKeyPlusLMTHash(messageRec, this.destHierarchy.SourceEntryIDPtag, this.destHierarchy.SourceLastModifiedTimestampPtag); if (keyPlusLMTHash != null) { entryIdMap2[keyPlusLMTHash] = messageRec; } List <byte[]> secondaryKeys = this.GetSecondaryKeys(messageRec, MessageRecType.Target); this.RegisterUniqueTargetSecondaryKeys(messageRec, secondaryKeys, entryIdMap, hashSet); } HashSet <byte[]> uniqueSecondaryKeys = new HashSet <byte[]>(ArrayComparer <byte> .EqualityComparer); HashSet <byte[]> hashSet2 = new HashSet <byte[]>(ArrayComparer <byte> .EqualityComparer); foreach (MessageRec message in sourceMessages) { List <byte[]> secondaryKeys2 = this.GetSecondaryKeys(message, MessageRecType.Source); this.IdentifyDuplicateSecondaryKeys(message, secondaryKeys2, uniqueSecondaryKeys, hashSet2); } foreach (MessageRec messageRec2 in sourceMessages) { string text; if (FolderContentsMapper.ShouldItemBeIgnored(messageRec2, badItemMarkers, this.faiCopyOption, out text)) { skippedItemCount++; skippedItemSize += (ulong)((long)messageRec2.MessageSize); } else { MessageRec messageRec3 = null; List <MessageRec> list; List <MessageRec> list2; if (this.faiCopyOption == FAICopyOption.MapByMessageClass && messageRec2.IsFAI && !string.IsNullOrEmpty(text) && dictionary.TryGetValue(text, out list) && list.Count == 1 && dictionary2.TryGetValue(text, out list2) && list2.Count == 1) { messageRec3 = list2[0]; MrsTracer.Service.Debug("Mapped FAI message with message class '{0}'", new object[] { text }); } if (messageRec3 == null) { this.MapSourceToTargetMessage(messageRec2, entryIdMap2, entryIdMap, hashSet, hashSet2, out messageRec3); } MessageRec item = null; if (this.ShouldTargetMessagePropsBeUpdated(messageRec2, messageRec3, out item)) { skippedItemCount++; skippedItemSize += (ulong)((long)messageRec2.MessageSize); targetMessagePropsChanges.Add(item); } else if (this.ShouldItemBeCopied(messageRec2, messageRec3, hashSet)) { itemsToCopy.Add(messageRec2); this.sourceMapping[messageRec2.EntryId] = messageRec2; if (messageRec3 != null) { this.targetMapping[messageRec2.EntryId] = messageRec3; } } else { skippedItemCount++; skippedItemSize += (ulong)((long)messageRec2.MessageSize); } } } }
private Dictionary <string, List <MessageRec> > CreateFaiMap(IReadOnlyCollection <MessageRec> messages, EntryIdMap <BadItemMarker> badItemMarkers) { Dictionary <string, List <MessageRec> > dictionary = new Dictionary <string, List <MessageRec> >(StringComparer.OrdinalIgnoreCase); foreach (MessageRec messageRec in messages) { string text; if (messageRec.IsFAI && !FolderContentsMapper.ShouldItemBeIgnored(messageRec, badItemMarkers, this.faiCopyOption, out text) && !string.IsNullOrEmpty(text)) { List <MessageRec> list; if (!dictionary.TryGetValue(text, out list)) { list = new List <MessageRec>(1); dictionary.Add(text, list); } list.Add(messageRec); } } return(dictionary); }