public bool CompareRootFolders() { ISourceFolder folder = base.SourceMailbox.GetFolder(null); if (folder == null) { throw new RootFolderNotFoundPermananentException(); } FolderRec folderRec; using (folder) { folderRec = folder.GetFolderRec(null, GetFolderRecFlags.None); } IDestinationFolder folder2 = base.DestMailbox.GetFolder(null); if (folder2 == null) { throw new RootFolderNotFoundPermananentException(); } FolderRec folderRec2; using (folder2) { folderRec2 = folder2.GetFolderRec(null, GetFolderRecFlags.None); } if (!CommonUtils.IsSameEntryId(folderRec.EntryId, folderRec2.EntryId)) { MrsTracer.Service.Warning("Root folder IDs don't match on source and destination mailboxes. Restarting the move.", new object[0]); return(false); } return(true); }
public ManifestContentChangesFetcher(ISourceFolder folder, MapiFolder mapiFolder, MailboxProviderBase mailbox, bool isPagedEnumeration) { this.folder = folder; this.mapiFolder = mapiFolder; this.mailbox = mailbox; this.isPagedEnumeration = isPagedEnumeration; }
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 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); }
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 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); } }
public void FolderExportMessages(ISourceFolder folder, CopyMessagesFlags flags, byte[][] entryIds) { this.RunExportThread(delegate { using (BufferedTransmitter bufferedTransmitter = new BufferedTransmitter(this, this.service.ExportBufferSizeFromMrsKB, false, this.service.UseBufferring, this.service.UseCompression)) { using (AsynchronousTransmitter asynchronousTransmitter = new AsynchronousTransmitter(bufferedTransmitter, false)) { using (FxProxyTransmitter fxProxyTransmitter = new FxProxyTransmitter(asynchronousTransmitter, false)) { folder.ExportMessages(fxProxyTransmitter, flags, entryIds); } } } }); }
public void FolderExport(ISourceFolder folder, CopyPropertiesFlags flags, PropTag[] excludeTags) { this.RunExportThread(delegate { using (BufferedTransmitter bufferedTransmitter = new BufferedTransmitter(this, this.service.ExportBufferSizeFromMrsKB, false, this.service.UseBufferring, this.service.UseCompression)) { using (AsynchronousTransmitter asynchronousTransmitter = new AsynchronousTransmitter(bufferedTransmitter, false)) { using (FxProxyTransmitter fxProxyTransmitter = new FxProxyTransmitter(asynchronousTransmitter, false)) { folder.CopyTo(fxProxyTransmitter, flags, excludeTags); } } } }); }
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); } } } } } } }); }
public override FolderMap GetSourceFolderMap(GetFolderMapFlags flags) { base.SourceMailboxWrapper.LoadFolderMap(flags, delegate { List <FolderRecWrapper> list = new List <FolderRecWrapper>(this.hierarchyFolderEntryIds.Count); foreach (byte[] entryId in this.hierarchyFolderEntryIds) { byte[] sessionSpecificEntryId = base.SourceMailbox.GetSessionSpecificEntryId(entryId); using (ISourceFolder folder = base.SourceMailbox.GetFolder(sessionSpecificEntryId)) { list.Add(new FolderRecWrapper(folder.GetFolderRec(null, GetFolderRecFlags.None))); } } return(new PublicFolderMap(list)); }); return(base.SourceMailboxWrapper.FolderMap); }
ISourceFolder ISourceMailbox.GetFolder(byte[] entryId) { ISourceFolder result = null; base.CreateContext("ISourceMailbox.GetFolder", new DataContext[] { new EntryIDsDataContext(entryId) }).Execute(delegate { result = ((ISourceMailbox)this.WrappedObject).GetFolder(entryId); }, true); if (result == null) { return(null); } return(new SourceFolderWrapper(result, base.CreateContext, base.ProviderInfo)); }
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; } } }
protected void CopyFolder(FolderMapping fm) { base.RefreshRequestIfNeeded(); base.TimeTracker.CurrentState = RequestState.CopyingMessages; base.TestIntegration.Barrier("PostponeWriteMessages", new Action(base.RefreshRequestIfNeeded)); base.CheckServersHealth(); ExecutionContext.Create(new DataContext[] { new FolderRecWrapperDataContext(fm) }).Execute(delegate { if (this.CachedRequestJob.IsPublicFolderMailboxRestore && fm.TargetFolder == null) { this.Warnings.Add(MrsStrings.FolderIsMissing(HexConverter.ByteArrayToHexString(fm.EntryId))); return; } using (ISourceFolder folder = this.MailboxMerger.SourceMailbox.GetFolder(fm.EntryId)) { if (folder == null) { this.Report.Append(MrsStrings.ReportSourceFolderDeleted(fm.FullFolderName, TraceUtils.DumpEntryId(fm.EntryId))); } else { using (IDestinationFolder folder2 = this.MailboxMerger.DestMailbox.GetFolder(fm.TargetFolder.EntryId)) { if (folder2 == null) { this.Report.Append(MrsStrings.ReportTargetFolderDeleted(fm.TargetFolder.FullFolderName, TraceUtils.DumpEntryId(fm.TargetFolder.EntryId), fm.FullFolderName)); } else { this.Report.Append(MrsStrings.ReportMergingFolder(fm.FullFolderName, fm.TargetFolder.FullFolderName)); this.CopyFolderData(fm, folder, folder2); folder2.Flush(); } } } } }); base.SaveState(SaveStateFlags.Lazy, null); }
public override void CopyFolderProperties(FolderRecWrapper folderRec, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped) { base.CopyFolderProperties(folderRec, sourceFolder, destFolder, dataToCopy, out wasPropertyCopyingSkipped); MrsTracer.Service.Debug("Stamping additional properties on the target folder", new object[0]); List <PropValueData> list = new List <PropValueData>(3); list.Add(new PropValueData(this.DestHierarchy.SourceEntryIDPtag, folderRec.EntryId)); list.Add(new PropValueData(this.DestHierarchy.SourceLastModifiedTimestampPtag, folderRec.FolderRec.LastModifyTimestamp)); WellKnownFolderType wellKnownFolderType = WellKnownFolderType.None; if (this.SourceHierarchy != null) { wellKnownFolderType = this.SourceHierarchy.GetWellKnownFolderType(folderRec.EntryId); } if (wellKnownFolderType != WellKnownFolderType.None) { list.Add(new PropValueData(this.DestHierarchy.SourceWKFTypePtag, (int)wellKnownFolderType)); } destFolder.SetProps(list.ToArray()); }
private void ExportExtendedAcls(AclFlags extendedAclFlags, ISourceFolder srcFolder, IFolderProxy targetFolder) { base.VerifyCapability(MRSProxyCapabilities.SetItemProperties, CapabilityCheck.BothMRSAndOtherProvider); if (extendedAclFlags.HasFlag(AclFlags.FolderAcl)) { PropValueData[][] extendedAcl = srcFolder.GetExtendedAcl(AclFlags.FolderAcl); if (extendedAcl != null) { targetFolder.SetItemProperties(new FolderAcl(AclFlags.FolderAcl, extendedAcl)); } } if (extendedAclFlags.HasFlag(AclFlags.FreeBusyAcl)) { PropValueData[][] extendedAcl2 = srcFolder.GetExtendedAcl(AclFlags.FreeBusyAcl); if (extendedAcl2 != null) { targetFolder.SetItemProperties(new FolderAcl(AclFlags.FreeBusyAcl, extendedAcl2)); } } }
protected override void BeforeDataCopy() { base.MailboxMerger.SourceHierarchy.EnumerateFolderHierarchy(EnumHierarchyFlags.NormalFolders | EnumHierarchyFlags.RootFolder, delegate(FolderRecWrapper folderRec, FolderMap.EnumFolderContext context) { FolderMapping folderMapping = (FolderMapping)folderRec; if (!folderMapping.IsIncluded) { return; } using (ISourceFolder folder = base.MailboxMerger.SourceMailbox.GetFolder(folderMapping.EntryId)) { if (folder != null) { FolderRec folderRec2 = folder.GetFolderRec(base.MailboxMerger.GetAdditionalFolderPtags(), GetFolderRecFlags.None); base.MailboxMerger.CatchupFolder(folderRec2, folder); } } }); base.MailboxMerger.ICSSyncState.ProviderState = base.MailboxMerger.SourceMailbox.GetMailboxSyncState(); base.MailboxMerger.SaveICSSyncState(true); }
public void MergeFolderContents(FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder) { MrsTracer.Service.Function("MailboxMerger.MergeFolderContents({0})", new object[] { fm.FullFolderName }); if (this.ContentRestriction != null) { srcFolder.SetContentsRestriction(this.ContentRestriction); } FolderContentsMapper folderContentsMapper = FolderContentsMapper.Create(fm, srcFolder, this.SourceHierarchy, destFolder, this.DestHierarchy, this.GetConflictResolutionOption(fm), base.MRSJob.CachedRequestJob.AssociatedMessagesCopyOption ?? FAICopyOption.DoNotCopy, (base.MRSJob.CachedRequestJob.SyncProtocol == SyncProtocol.Imap) ? FolderContentsMapperFlags.ImapSync : FolderContentsMapperFlags.None); int num; ulong num2; List <MessageRec> list; List <MessageRec> list2; folderContentsMapper.ComputeMapping((base.SyncState == null) ? null : base.SyncState.BadItems, out num, out num2, out list, out list2); SyncProtocol syncProtocol = base.MRSJob.CachedRequestJob.SyncProtocol; foreach (MessageRec messageRec in list2) { destFolder.SetMessageProps(messageRec.EntryId, messageRec.AdditionalProps); } base.MailboxSizeTracker.TrackFolder(fm.EntryId, list, num, num2); int num3; ulong num4; base.MailboxSizeTracker.GetFolderSize(fm.EntryId, out num3, out num4); base.Report.Append(MrsStrings.ReportFolderMergeStats(num3 - num, new ByteQuantifiedSize(num4 - num2).ToString(), num, new ByteQuantifiedSize(num2).ToString())); base.MRSJob.TotalMessages = base.MailboxSizeTracker.MessageCount; base.MRSJob.TotalMessageByteSize = base.MailboxSizeTracker.TotalMessageSize; base.MRSJob.MessagesWritten = base.MailboxSizeTracker.AlreadyCopiedCount; base.MRSJob.MessageSizeWritten = base.MailboxSizeTracker.AlreadyCopiedSize; this.CopyMessageBatch(folderContentsMapper, list, fm); base.MailboxSizeTracker.TrackFolder(fm.EntryId, null, num3, num4); }
public override void CopyFolderProperties(FolderRecWrapper sourceFolderRecWrapper, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped) { wasPropertyCopyingSkipped = false; if (this.sessionSpecificEntryIds.ContainsKey(sourceFolderRecWrapper.EntryId) && destFolder != null) { if (base.SupportsPerUserReadUnreadDataTransfer) { using (IFxProxy fxProxy = destFolder.GetFxProxy(FastTransferFlags.PassThrough)) { using (IFxProxy fxProxy2 = base.CreateFxProxyTransmissionPipeline(fxProxy)) { sourceFolder.CopyTo(fxProxy2, CopyPropertiesFlags.CopyFolderPerUserData, Array <PropTag> .Empty); } } } base.CopyFolderProperties(sourceFolderRecWrapper, sourceFolder, destFolder, FolderRecDataFlags.Rules, out wasPropertyCopyingSkipped); } }
public void FinalSyncCopyMailboxData() { if (base.MRSJob.TestIntegration.RemoteExchangeGuidOverride == Guid.Empty) { using (IFxProxy fxProxy = base.DestMailbox.GetFxProxy()) { using (IFxProxy fxProxy2 = base.CreateFxProxyTransmissionPipeline(fxProxy)) { base.SourceMailbox.CopyTo(fxProxy2, new PropTag[] { PropTag.ContainerHierarchy, PropTag.ContainerContents }); } } if (this.ServerSupportsInferencePropertiesMove(base.SourceMailboxWrapper.MailboxVersion) && this.ServerSupportsInferencePropertiesMove(base.DestMailboxWrapper.MailboxVersion) && base.MRSJob.GetConfig <bool>("CopyInferenceProperties")) { byte[] badItemId = BitConverter.GetBytes(base.SourceMailbox.GetHashCode()); CommonUtils.ProcessKnownExceptions(delegate { List <PropValueData> list = new List <PropValueData>(2); foreach (PropValueData propValueData in this.SourceMailbox.GetProps(MailboxMover.inferencePropertiesToMove)) { if (((PropTag)propValueData.PropTag).ValueType() != PropType.Error) { list.Add(propValueData); } } badItemId = BadMessageRec.ComputeKey(list.ToArray()); if (!this.SyncState.BadItems.ContainsKey(badItemId)) { this.DestMailbox.SetProps(list.ToArray()); } }, delegate(Exception failure) { if (MapiUtils.IsBadItemIndicator(failure)) { List <BadMessageRec> list = new List <BadMessageRec>(1); list.Add(BadMessageRec.InferenceData(failure, badItemId)); this.ReportBadItems(list); return(true); } return(false); }); } } if (base.SupportsPerUserReadUnreadDataTransfer) { base.Report.Append(MrsStrings.ReportCopyPerUserReadUnreadDataStarted); using (ISourceFolder folder = base.SourceMailbox.GetFolder(null)) { using (IDestinationFolder folder2 = base.DestMailbox.GetFolder(null)) { using (IFxProxy fxProxy3 = folder2.GetFxProxy(FastTransferFlags.PassThrough)) { using (IFxProxy fxProxy4 = base.CreateFxProxyTransmissionPipeline(fxProxy3)) { folder.CopyTo(fxProxy4, CopyPropertiesFlags.CopyMailboxPerUserData, Array <PropTag> .Empty); } } } } base.Report.Append(MrsStrings.ReportCopyPerUserReadUnreadDataCompleted); } }
protected override void CatchupFolderHierarchy() { if (!this.PrimaryHierarchyMbxWrapper.Mailbox.IsConnected()) { this.PrimaryHierarchyMbxWrapper.Mailbox.Connect(MailboxConnectFlags.None); } bool flag = false; bool flag2 = false; Guid hierarchyMailboxGuid = this.publicFolderConfiguration.GetHierarchyMailboxInformation().HierarchyMailboxGuid; if (hierarchyMailboxGuid == base.CachedRequestJob.SourceExchangeGuid) { flag = true; } else if (hierarchyMailboxGuid == base.CachedRequestJob.TargetExchangeGuid) { flag2 = true; } foreach (byte[] array in this.foldersToMove) { if (flag) { using (IFolder folder = ((ISourceMailbox)this.PrimaryHierarchyMbxWrapper.Mailbox).GetFolder(array)) { using (IDestinationFolder folder2 = this.publicFolderMover.DestMailbox.GetFolder(this.publicFolderMover.DestMailbox.GetSessionSpecificEntryId(array))) { if (folder2 == null) { if (folder != null) { MrsTracer.Service.Error("Inconsistency of hierarchy seen at target mailbox...May be a delay in hierarchy synchronization", new object[0]); throw new DestinationFolderHierarchyInconsistentTransientException(); } MrsTracer.Service.Debug("Folder {0} unavailable at both source and destination mailbox during catchup", new object[] { HexConverter.ByteArrayToHexString(array) }); } } continue; } } if (flag2) { using (IFolder folder3 = ((IDestinationMailbox)this.PrimaryHierarchyMbxWrapper.Mailbox).GetFolder(array)) { using (ISourceFolder folder4 = this.publicFolderMover.SourceMailbox.GetFolder(this.publicFolderMover.SourceMailbox.GetSessionSpecificEntryId(array))) { if (folder4 == null) { if (folder3 != null) { MrsTracer.Service.Error("Inconsistency of hierarchy seen at source mailbox...May be a delay in hierarchy synchronization", new object[0]); throw new SourceFolderHierarchyInconsistentTransientException(); } MrsTracer.Service.Debug("Folder {0} unavailable at both source and destination mailbox during catchup", new object[] { HexConverter.ByteArrayToHexString(array) }); } } continue; } } using (IFolder folder5 = ((IDestinationMailbox)this.PrimaryHierarchyMbxWrapper.Mailbox).GetFolder(array)) { if (folder5 == null) { MrsTracer.Service.Debug("Folder {0} unavailable at hierarchy mailbox during catchup", new object[] { HexConverter.ByteArrayToHexString(array) }); } else { using (ISourceFolder folder6 = this.publicFolderMover.SourceMailbox.GetFolder(this.publicFolderMover.SourceMailbox.GetSessionSpecificEntryId(array))) { if (folder6 == null) { MrsTracer.Service.Error("Inconsistency of hierarchy seen at source mailbox...May be a delay in hierarchy synchronization", new object[0]); throw new SourceFolderHierarchyInconsistentTransientException(); } } using (IDestinationFolder folder7 = this.publicFolderMover.DestMailbox.GetFolder(this.publicFolderMover.DestMailbox.GetSessionSpecificEntryId(array))) { if (folder7 == null) { MrsTracer.Service.Error("Inconsistency of hierarchy seen at target mailbox...May be a delay in hierarchy synchronization", new object[0]); throw new DestinationFolderHierarchyInconsistentTransientException(); } } } } } base.SyncStage = SyncStage.CreatingInitialSyncCheckpoint; base.OverallProgress = 15; base.TimeTracker.CurrentState = RequestState.CreatingInitialSyncCheckpoint; base.SaveState(SaveStateFlags.Regular, delegate(TransactionalRequestJob moveRequest) { moveRequest.RestartFromScratch = false; }); base.ScheduleWorkItem(new Action(base.CatchupFolders), WorkloadType.Unknown); }
public TitaniumContentChangesFetcher(ISourceFolder folder, MapiFolder mapiFolder, MailboxProviderBase mailbox) { this.folder = folder; this.mapiFolder = mapiFolder; this.mailbox = mailbox; }
protected virtual void CopyFolderData(FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder) { this.MailboxMerger.CopyFolderData(fm, srcFolder, destFolder); }
public override void CopyFolderProperties(FolderRecWrapper sourceFolderRecWrapper, ISourceFolder sourceFolder, IDestinationFolder destFolder, FolderRecDataFlags dataToCopy, out bool wasPropertyCopyingSkipped) { Guid empty = Guid.Empty; bool isRoot = base.IsRoot; bool flag = false; wasPropertyCopyingSkipped = false; FolderMapping folderMapping = sourceFolderRecWrapper as FolderMapping; while (folderMapping.WKFType != WellKnownFolderType.Root) { if (folderMapping.IsLegacyPublicFolder) { return; } folderMapping = (folderMapping.Parent as FolderMapping); } if (destFolder == null) { if (!isRoot || ((FolderMapping)sourceFolderRecWrapper).IsSystemPublicFolder) { MrsTracer.Service.Debug("Skipping final property copying for \"{0}\" folder since it's contents don't reside in this mailbox", new object[] { sourceFolderRecWrapper.FullFolderName }); return; } throw new FolderCopyFailedPermanentException(sourceFolderRecWrapper.FullFolderName); } else { PropValueData[] props = destFolder.GetProps(new PropTag[] { PropTag.ReplicaList, PropTag.IpmWasteBasketEntryId }); IDataConverter <PropValue, PropValueData> dataConverter = new PropValueConverter(); PropValue nativeRepresentation = dataConverter.GetNativeRepresentation(props[0]); byte[] array = nativeRepresentation.Value as byte[]; if (!nativeRepresentation.IsNull() && !nativeRepresentation.IsError() && array != null) { StorePropertyDefinition replicaList = CoreFolderSchema.ReplicaList; string[] stringArrayFromBytes = ReplicaListProperty.GetStringArrayFromBytes(array); if (stringArrayFromBytes.Length > 0 && GuidHelper.TryParseGuid(stringArrayFromBytes[0], out empty)) { flag = (empty == base.TargetMailboxGuid); } } FolderStateSnapshot folderStateSnapshot = base.ICSSyncState[sourceFolderRecWrapper.EntryId]; FolderState state = folderStateSnapshot.State; if (sourceFolder.GetFolderRec(this.GetAdditionalFolderPtags(), GetFolderRecFlags.None).IsGhosted) { folderStateSnapshot.State |= FolderState.IsGhosted; } else { folderStateSnapshot.State &= ~FolderState.IsGhosted; } if (state != folderStateSnapshot.State) { base.SaveICSSyncState(false); } if (!isRoot && !flag) { return; } List <PropValueData> list = new List <PropValueData>(2); bool flag2 = false; if (flag) { PropValue nativeRepresentation2 = dataConverter.GetNativeRepresentation(sourceFolder.GetProps(new PropTag[] { PropTag.PfProxy })[0]); if (!nativeRepresentation2.IsNull() && !nativeRepresentation2.IsError()) { byte[] array2 = nativeRepresentation2.Value as byte[]; if (array2 != null && array2.Length == 16 && new Guid(array2) != Guid.Empty) { Guid a = Guid.Empty; bool flag3 = base.Flags.HasFlag(MailboxCopierFlags.CrossOrg); if (flag3) { a = destFolder.LinkMailPublicFolder(LinkMailPublicFolderFlags.EntryId, sourceFolderRecWrapper.EntryId); } else { a = destFolder.LinkMailPublicFolder(LinkMailPublicFolderFlags.ObjectGuid, array2); } if (a != Guid.Empty) { list.Add(new PropValueData(PropTag.PfProxy, a.ToByteArray())); list.Add(new PropValueData(PropTag.PfProxyRequired, true)); flag2 = true; } else { base.Report.Append(new ReportEntry(MrsStrings.ReportFailedToLinkADPublicFolder(sourceFolderRecWrapper.FullFolderName, BitConverter.ToString(array2), BitConverter.ToString(sourceFolderRecWrapper.EntryId)), ReportEntryType.Warning)); } } } } if (!flag2) { list.Add(new PropValueData(PropTag.PfProxy, Guid.Empty.ToByteArray())); list.Add(new PropValueData(PropTag.PfProxyRequired, false)); } List <PropValueData> list2 = new List <PropValueData>(9); if (isRoot) { if (!flag) { dataToCopy &= (FolderRecDataFlags.SecurityDescriptors | FolderRecDataFlags.FolderAcls | FolderRecDataFlags.ExtendedAclInformation); } list2.AddRange(list); } else { byte[] sessionSpecificEntryId = this.hierarchyMailbox.GetSessionSpecificEntryId(sourceFolderRecWrapper.EntryId); using (IDestinationFolder folder = this.hierarchyMailbox.GetFolder(sessionSpecificEntryId)) { if (folder == null) { MrsTracer.Service.Error("Something deleted destination hierarchy folder from under us", new object[0]); throw new UnexpectedErrorPermanentException(-2147221238); } if (list.Count > 0) { folder.SetProps(list.ToArray()); } } } base.CopyFolderProperties(sourceFolderRecWrapper, sourceFolder, destFolder, dataToCopy, out wasPropertyCopyingSkipped); PropTag[] pta = new PropTag[] { PropTag.DisablePeruserRead, PropTag.OverallAgeLimit, PropTag.RetentionAgeLimit, PropTag.PfQuotaStyle, PropTag.PfOverHardQuotaLimit, PropTag.PfStorageQuota, PropTag.PfMsgSizeLimit }; foreach (PropValueData propValueData in sourceFolder.GetProps(pta)) { PropValue nativeRepresentation3 = dataConverter.GetNativeRepresentation(propValueData); if (!nativeRepresentation3.IsNull() && !nativeRepresentation3.IsError()) { if (propValueData.PropTag == 1721303043 && (int)propValueData.Value > 0) { propValueData.Value = (int)EnhancedTimeSpan.FromDays((double)((int)propValueData.Value)).TotalSeconds; } list2.Add(propValueData); } } if (list2.Count > 0) { destFolder.SetProps(list2.ToArray()); } return; } }
public SourceFolderWrapper(ISourceFolder folder, CommonUtils.CreateContextDelegate createContext, ProviderInfo mailboxProviderInfo) : base(folder, createContext) { base.ProviderInfo = mailboxProviderInfo; }
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 }); }
private void ApplyFolderChanges(SyncContext ctx, FolderChangesManifest folderChanges, FolderMapping fm, ISourceFolder srcFolder, IDestinationFolder destFolder) { int num = 0; int num2 = 0; int num3 = 0; int num4 = 0; int num5 = 0; FolderContentsMapper folderContentsMapper = FolderContentsMapper.Create(fm, srcFolder, this.SourceHierarchy, destFolder, this.DestHierarchy, base.MRSJob.CachedRequestJob.ConflictResolutionOption ?? ConflictResolutionOption.KeepSourceItem, base.MRSJob.CachedRequestJob.AssociatedMessagesCopyOption ?? FAICopyOption.DoNotCopy, (base.MRSJob.CachedRequestJob.SyncProtocol == SyncProtocol.Imap) ? FolderContentsMapperFlags.ImapSync : FolderContentsMapperFlags.None); List <MessageRec> list; byte[][] array; byte[][] array2; byte[][] array3; int skipped; folderContentsMapper.ComputeIncrementalMapping(folderChanges, (base.SyncState == null) ? null : base.SyncState.BadItems, out list, out array, out array2, out array3, out skipped); this.CopyMessageBatch(folderContentsMapper, list, fm); destFolder.DeleteMessages(array); destFolder.SetReadFlagsOnMessages(SetReadFlags.None, array2); destFolder.SetReadFlagsOnMessages(SetReadFlags.ClearRead, array3); if (list != null) { foreach (MessageRec messageRec in list) { if (messageRec.IsNew) { num++; } else { num2++; } } } if (array != null) { num3 += array.Length; } if (array2 != null) { num4 += array2.Length; } if (array3 != null) { num5 += array3.Length; } ctx.CopyMessagesCount += new CopyMessagesCount(num, num2, num3, num4, num5, skipped); }
public ImapFolderContentsMapper(FolderMapping folderMapping, ISourceFolder srcFolder, FolderHierarchy sourceHierarchy, IDestinationFolder destFolder, FolderHierarchy destHierarchy, ConflictResolutionOption conflictResolutionOption, FAICopyOption faiCopyOption, FolderContentsMapperFlags mapperFlags) : base(folderMapping, srcFolder, sourceHierarchy, destFolder, destHierarchy, conflictResolutionOption, faiCopyOption, mapperFlags) { }
protected override void CatchupFolderHierarchy() { if (!this.PrimaryHierarchyMbxWrapper.Mailbox.IsConnected()) { this.PrimaryHierarchyMbxWrapper.Mailbox.Connect(MailboxConnectFlags.None); } FolderRecDataFlags folderRecDataFlags = FolderRecDataFlags.SearchCriteria; if (!base.CachedRequestJob.SkipFolderPromotedProperties) { folderRecDataFlags |= FolderRecDataFlags.PromotedProperties; } if (!base.CachedRequestJob.SkipFolderViews) { folderRecDataFlags |= FolderRecDataFlags.Views; } if (!base.CachedRequestJob.SkipFolderRestrictions) { folderRecDataFlags |= FolderRecDataFlags.Restrictions; } List <WellKnownFolder> list = this.folderMover.SourceMailbox.DiscoverWellKnownFolders(0); List <WellKnownFolder> destinationWellKnownFolders = this.folderMover.DestMailbox.DiscoverWellKnownFolders(0); foreach (byte[] array in this.foldersToMove) { using (IFolder folder = ((ISourceMailbox)this.PrimaryHierarchyMbxWrapper.Mailbox).GetFolder(array)) { using (IDestinationFolder folder2 = this.folderMover.DestMailbox.GetFolder(this.folderMover.DestMailbox.GetSessionSpecificEntryId(array))) { if (folder2 == null) { if (folder == null) { MrsTracer.Service.Debug("Folder {0} unavailable at both source and destination mailbox during catchup", new object[] { HexConverter.ByteArrayToHexString(array) }); } else { List <FolderRecWrapper> list2 = new List <FolderRecWrapper>(); byte[] entryId = array; for (;;) { using (ISourceFolder folder3 = this.folderMover.SourceMailbox.GetFolder(entryId)) { if (folder3 != null) { FolderRecWrapper folderRecWrapper = new FolderRecWrapper(folder3.GetFolderRec(null, GetFolderRecFlags.None)); if (folderRecWrapper.ParentId != null) { list2.Insert(0, folderRecWrapper); bool flag = false; foreach (WellKnownFolder wellKnownFolder in list) { if (CommonUtils.IsSameEntryId(wellKnownFolder.EntryId, folderRecWrapper.ParentId)) { flag = true; break; } } if (!flag) { entryId = folderRecWrapper.ParentId; continue; } } } } break; } foreach (FolderRecWrapper folderRecWrapper2 in list2) { byte[] entryId2 = folderRecWrapper2.FolderRec.EntryId; byte[] parentId = folderRecWrapper2.FolderRec.ParentId; byte[] sessionSpecificEntryId = this.folderMover.DestMailbox.GetSessionSpecificEntryId(entryId2); bool flag2 = false; byte[] destinationFolderIdFromSourceFolderId = AuxFolderMoveJob.GetDestinationFolderIdFromSourceFolderId(list, destinationWellKnownFolders, this.folderMover.DestMailbox, parentId, out flag2); using (IDestinationFolder folder4 = this.folderMover.DestMailbox.GetFolder(sessionSpecificEntryId)) { if (folder4 == null) { using (ISourceFolder folder5 = this.folderMover.SourceMailbox.GetFolder(entryId2)) { if (folder5 == null) { MrsTracer.Service.Warning("Source folder '{0}' {1} disappeared, skipping", new object[] { folderRecWrapper2.FolderName, folderRecWrapper2.EntryId }); break; } folderRecWrapper2.EnsureDataLoaded(folder5, folderRecDataFlags, this.folderMover); this.folderMover.TranslateFolderData(folderRecWrapper2); CreateFolderFlags createFolderFlags = CreateFolderFlags.None; folderRecWrapper2.FolderRec.EntryId = sessionSpecificEntryId; folderRecWrapper2.FolderRec.ParentId = destinationFolderIdFromSourceFolderId; byte[] array2; this.folderMover.CreateFolder(null, folderRecWrapper2, createFolderFlags, out array2); folderRecWrapper2.FolderRec.EntryId = entryId2; folderRecWrapper2.FolderRec.ParentId = parentId; } } } } } } } } } base.SyncStage = SyncStage.CreatingInitialSyncCheckpoint; base.OverallProgress = 15; base.TimeTracker.CurrentState = RequestState.CreatingInitialSyncCheckpoint; base.SaveState(SaveStateFlags.Regular, delegate(TransactionalRequestJob moveRequest) { moveRequest.RestartFromScratch = false; }); base.ScheduleWorkItem(new Action(base.CatchupFolders), WorkloadType.Unknown); }
internal FolderMapping GetNextFolderToCopy(out FolderContentsCrawler folderContentsCrawler, out bool shouldCopyProperties) { MrsTracer.Service.Function("MailboxContentsCrawler.GetNextFolderToCopy", new object[0]); base.CheckDisposed(); folderContentsCrawler = null; shouldCopyProperties = false; for (int i = 0; i <= this.folderCount; i++) { if (!this.folderEnumerator.MoveNext()) { MrsTracer.Service.Debug("Tail is reached, move to head", new object[0]); this.folderEnumerator.Reset(); if (!this.folderEnumerator.MoveNext()) { break; } } FolderMapping folderMapping = this.folderEnumerator.Current; if (folderMapping.FolderType != FolderType.Search && folderMapping.IsIncluded && !this.crawledFolders.ContainsKey(folderMapping.EntryId)) { FolderContentsCrawler folderContentsCrawler2; if (!this.crawlers.TryGetValue(folderMapping.EntryId, out folderContentsCrawler2) && this.crawlers.Count < this.maxFoldersOpened) { MrsTracer.Service.Debug("Add crawler for the folder: '{0}'", new object[] { folderMapping.FullFolderName }); ISourceFolder folder = this.sourceMalibox.GetFolder(folderMapping.EntryId); if (folder != null) { folderContentsCrawler2 = new FolderContentsCrawler(folder, this.pageSize, this.maxPageSize) { MailboxCopier = this.mailboxCopier }; using (DisposeGuard disposeGuard = folderContentsCrawler2.Guard()) { this.crawlers.Add(folderMapping.EntryId, folderContentsCrawler2); disposeGuard.Success(); shouldCopyProperties = true; } } } if (folderContentsCrawler2 != null) { if (folderContentsCrawler2.HasMoreMessages) { MrsTracer.Service.Debug("Return the folder to copy: '{0}'", new object[] { folderMapping.FullFolderName }); folderContentsCrawler = folderContentsCrawler2; return(folderMapping); } MrsTracer.Service.Debug("The folder has completed crawling: '{0}'", new object[] { folderMapping.FullFolderName }); this.crawledFolders.Add(folderMapping.EntryId, folderMapping); folderContentsCrawler2.Dispose(); this.crawlers.Remove(folderMapping.EntryId); } } } MrsTracer.Service.Debug("No more folders", new object[0]); return(null); }