protected override void CleanupDestinationMailbox(MailboxCopierBase mbxCtx, bool moveIsSuccessful) { if (base.CachedRequestJob.Direction == RequestDirection.Push) { mbxCtx.DestMailbox.UpdateRemoteHostName(null); } }
protected override MailboxChangesManifest EnumerateSourceHierarchyChanges(MailboxCopierBase mbxCtx, bool catchup, SyncContext syncContext) { return(new MailboxChangesManifest { ChangedFolders = new List <byte[]>(), DeletedFolders = new List <byte[]>() }); }
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); } }
protected override void SetSourceInTransitStatus(MailboxCopierBase mbxCtx, InTransitStatus status, out bool sourceSupportsOnlineMove) { mbxCtx.SourceMailbox.SetInTransitStatus(status | InTransitStatus.ForPublicFolderMove, out sourceSupportsOnlineMove); if (!sourceSupportsOnlineMove) { MrsTracer.Service.Debug("Source does not support online move for aux folder move job.", new object[0]); throw new OnlineMoveNotSupportedPermanentException(base.CachedRequestJob.SourceExchangeGuid.ToString()); } }
protected override void CleanupDestinationMailbox(MailboxCopierBase mbxCtx, bool moveIsSuccessful) { if (mbxCtx.IsRoot && moveIsSuccessful) { IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(false, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.publicFolderConfiguration.OrganizationId), 450, "CleanupDestinationMailbox", "f:\\15.00.1497\\sources\\dev\\mrs\\src\\Service\\MRSJobs\\PublicFolderMigrationJob.cs"); Organization orgContainer = tenantOrTopologyConfigurationSession.GetOrgContainer(); orgContainer.DefaultPublicFolderMailbox = orgContainer.DefaultPublicFolderMailbox.Clone(); orgContainer.DefaultPublicFolderMailbox.SetHierarchyMailbox(orgContainer.DefaultPublicFolderMailbox.HierarchyMailboxGuid, PublicFolderInformation.HierarchyType.MailboxGuid); tenantOrTopologyConfigurationSession.Save(orgContainer); } }
private void InternalConfigureProviders(bool continueAfterConfiguringProviders) { if (this.publicFolderConfiguration.GetHierarchyMailboxInformation().Type != PublicFolderInformation.HierarchyType.InTransitMailboxGuid) { throw new PublicFolderMailboxesNotProvisionedForMigrationException(); } RequestStatisticsBase cachedRequestJob = base.CachedRequestJob; bool flag = cachedRequestJob.RequestStyle == RequestStyle.CrossOrg; LocalMailboxFlags localMailboxFlags = LocalMailboxFlags.LegacyPublicFolders; if (flag) { localMailboxFlags |= LocalMailboxFlags.PureMAPI; } this.sourceDatabases = new MapiSourceMailbox(localMailboxFlags); if (flag) { this.sourceDatabases.ConfigRPCHTTP(cachedRequestJob.RemoteMailboxLegacyDN, null, cachedRequestJob.RemoteMailboxServerLegacyDN, cachedRequestJob.OutlookAnywhereHostName, cachedRequestJob.RemoteCredential, true, cachedRequestJob.AuthenticationMethod != null && cachedRequestJob.AuthenticationMethod.Value == AuthenticationMethod.Ntlm); } else { ((IMailbox)this.sourceDatabases).Config(base.GetReservation(cachedRequestJob.SourceDatabase.ObjectGuid, ReservationFlags.Read), cachedRequestJob.SourceDatabase.ObjectGuid, cachedRequestJob.SourceDatabase.ObjectGuid, CommonUtils.GetPartitionHint(cachedRequestJob.OrganizationId), cachedRequestJob.SourceDatabase.ObjectGuid, MailboxType.SourceMailbox, null); } LocalizedString tracingId = flag ? MrsStrings.RPCHTTPPublicFoldersId(cachedRequestJob.RemoteMailboxLegacyDN) : MrsStrings.PublicFoldersId(cachedRequestJob.OrganizationId.ToString()); this.sourceDatabases.ConfigPublicFolders(cachedRequestJob.SourceDatabase); this.SourceDatabasesWrapper = new SourceMailboxWrapper(this.sourceDatabases, MailboxWrapperFlags.Source, tracingId); foreach (MailboxCopierBase mailboxCopierBase in this.GetAllCopiers()) { PublicFolderMigrator publicFolderMigrator = (PublicFolderMigrator)mailboxCopierBase; publicFolderMigrator.SetSourceDatabasesWrapper(this.SourceDatabasesWrapper); } base.ConfigureProviders(continueAfterConfiguringProviders); MailboxCopierBase rootMailboxContext = base.GetRootMailboxContext(); foreach (MailboxCopierBase mailboxCopierBase2 in this.GetAllCopiers()) { PublicFolderMigrator publicFolderMigrator2 = (PublicFolderMigrator)mailboxCopierBase2; if (!publicFolderMigrator2.IsRoot) { publicFolderMigrator2.SetHierarchyMailbox(rootMailboxContext.DestMailbox); } if (flag) { publicFolderMigrator2.ConfigTranslators(new PrincipalTranslator(this.SourceDatabasesWrapper.PrincipalMapper, publicFolderMigrator2.DestMailboxWrapper.PrincipalMapper), null); } } }
protected override void SetDestinationInTransitStatus(MailboxCopierBase mbxCtx) { InTransitStatus inTransitStatus = InTransitStatus.MoveDestination | InTransitStatus.OnlineMove | InTransitStatus.ForPublicFolderMove; if (base.CachedRequestJob.AllowLargeItems) { inTransitStatus |= InTransitStatus.AllowLargeItems; } bool flag; mbxCtx.DestMailbox.SetInTransitStatus(inTransitStatus, out flag); if (!flag) { MrsTracer.Service.Debug("Destination does not support online move for public folder move job.", new object[0]); throw new OnlineMoveNotSupportedPermanentException(base.CachedRequestJob.TargetExchangeGuid.ToString()); } }
public void EnumerateMappableData(MailboxCopierBase mbxCopier) { if (this.FieldIsLoaded(FolderRecDataFlags.PromotedProperties) && !this.FieldIsMapped(FolderRecDataFlags.PromotedProperties)) { mbxCopier.NamedPropTranslator.EnumeratePropTags(this.FolderRec.GetPromotedProperties()); } if (this.FieldIsLoaded(FolderRecDataFlags.Views) && !this.FieldIsMapped(FolderRecDataFlags.Views) && this.FolderRec.Views != null) { foreach (SortOrderData sortOrder in this.FolderRec.Views) { mbxCopier.NamedPropTranslator.EnumerateSortOrder(sortOrder); } } if (this.FieldIsLoaded(FolderRecDataFlags.Restrictions) && !this.FieldIsMapped(FolderRecDataFlags.Restrictions) && this.FolderRec.Restrictions != null) { foreach (RestrictionData rest in this.FolderRec.Restrictions) { mbxCopier.NamedPropTranslator.EnumerateRestriction(this.FolderRec, BadItemKind.CorruptFolderRestriction, rest); } } if (this.FieldIsLoaded(FolderRecDataFlags.SearchCriteria) && !this.FieldIsMapped(FolderRecDataFlags.SearchCriteria) && this.FolderType == FolderType.Search) { mbxCopier.NamedPropTranslator.EnumerateRestriction(this.FolderRec, BadItemKind.CorruptSearchFolderCriteria, this.SearchFolderRestriction); } if (mbxCopier.PrincipalTranslator != null && this.FieldIsLoaded(FolderRecDataFlags.SecurityDescriptors) && !this.FieldIsMapped(FolderRecDataFlags.SecurityDescriptors)) { mbxCopier.PrincipalTranslator.EnumerateSecurityDescriptor(this.FolderNTSD); mbxCopier.PrincipalTranslator.EnumerateSecurityDescriptor(this.FolderFreeBusyNTSD); } if (this.FieldIsLoaded(FolderRecDataFlags.Rules) && !this.FieldIsMapped(FolderRecDataFlags.Rules)) { mbxCopier.NamedPropTranslator.EnumerateRules(this.Rules); if (mbxCopier.PrincipalTranslator != null) { mbxCopier.PrincipalTranslator.EnumerateRules(this.Rules); } } if (mbxCopier.PrincipalTranslator != null && ((this.FieldIsLoaded(FolderRecDataFlags.FolderAcls) && !this.FieldIsMapped(FolderRecDataFlags.FolderAcls)) || (this.FieldIsLoaded(FolderRecDataFlags.ExtendedAclInformation) && !this.FieldIsMapped(FolderRecDataFlags.ExtendedAclInformation)))) { mbxCopier.PrincipalTranslator.EnumerateFolderACL(this.FolderACL); mbxCopier.PrincipalTranslator.EnumerateFolderACL(this.FolderFreeBusyACL); } }
protected override void OnMoveCompleted(MailboxCopierBase mbxCtx) { CommonUtils.CatchKnownExceptions(delegate { Guid hierarchyMailboxGuid = this.publicFolderConfiguration.GetHierarchyMailboxInformation().HierarchyMailboxGuid; if (mbxCtx.TargetMailboxGuid != hierarchyMailboxGuid) { MrsTracer.Service.Debug("Attempting to start hierarchy sync to content mailbox {0}.", new object[] { mbxCtx.TargetTracingID }); PublicFolderSyncJobRpc.StartSyncHierarchy(this.publicFolderConfiguration.OrganizationId, mbxCtx.TargetMailboxGuid, mbxCtx.TargetServerInfo.MailboxServerName, true); } }, delegate(Exception e) { MrsTracer.Service.Error("Failed to start hierarchy sync to content mailbox {0} - {1}", new object[] { mbxCtx.TargetTracingID, e }); }); }
internal MailboxContentsCrawler(MailboxCopierBase mailboxCopier, IReadOnlyCollection <FolderMapping> foldersToCopy) { ArgumentValidator.ThrowIfNull("mailboxCopier", mailboxCopier); this.mailboxCopier = mailboxCopier; this.Initialize(mailboxCopier.SourceMailbox, foldersToCopy, ConfigBase <MRSConfigSchema> .GetConfig <int>("MaxFolderOpened"), ConfigBase <MRSConfigSchema> .GetConfig <int>("CrawlerPageSize"), ConfigBase <MRSConfigSchema> .GetConfig <int>("EnumerateMessagesPageSize")); }
public void TranslateMappableData(MailboxCopierBase mbxCopier) { if (this.FieldIsLoaded(FolderRecDataFlags.PromotedProperties) && !this.FieldIsMapped(FolderRecDataFlags.PromotedProperties)) { PropTag[] promotedProperties = this.FolderRec.GetPromotedProperties(); mbxCopier.NamedPropTranslator.TranslatePropTags(promotedProperties); this.FolderRec.SetPromotedProperties(promotedProperties); this.MappedData |= FolderRecDataFlags.PromotedProperties; } if (this.FieldIsLoaded(FolderRecDataFlags.Views) && !this.FieldIsMapped(FolderRecDataFlags.Views) && this.FolderRec.Views != null) { foreach (SortOrderData so in this.FolderRec.Views) { mbxCopier.NamedPropTranslator.TranslateSortOrder(so); } this.MappedData |= FolderRecDataFlags.Views; } if (this.FieldIsLoaded(FolderRecDataFlags.Restrictions) && !this.FieldIsMapped(FolderRecDataFlags.Restrictions) && this.FolderRec.Restrictions != null) { foreach (RestrictionData restrictionData in this.FolderRec.Restrictions) { mbxCopier.NamedPropTranslator.TranslateRestriction(restrictionData); if (mbxCopier.FolderIdTranslator != null) { mbxCopier.FolderIdTranslator.TranslateRestriction(restrictionData); } } this.MappedData |= FolderRecDataFlags.Restrictions; } if (this.FieldIsLoaded(FolderRecDataFlags.SearchCriteria) && !this.FieldIsMapped(FolderRecDataFlags.SearchCriteria)) { if (this.FolderType == FolderType.Search) { mbxCopier.NamedPropTranslator.TranslateRestriction(this.SearchFolderRestriction); if (mbxCopier.FolderIdTranslator != null) { mbxCopier.FolderIdTranslator.TranslateRestriction(this.SearchFolderRestriction); this.SearchFolderScopeIDs = mbxCopier.FolderIdTranslator.TranslateFolderIds(this.SearchFolderScopeIDs); } } this.MappedData |= FolderRecDataFlags.SearchCriteria; } if (mbxCopier.PrincipalTranslator != null && this.FieldIsLoaded(FolderRecDataFlags.SecurityDescriptors) && !this.FieldIsMapped(FolderRecDataFlags.SecurityDescriptors)) { mbxCopier.PrincipalTranslator.TranslateSecurityDescriptor(this.FolderNTSD, TranslateSecurityDescriptorFlags.None); mbxCopier.PrincipalTranslator.TranslateSecurityDescriptor(this.FolderFreeBusyNTSD, TranslateSecurityDescriptorFlags.None); this.MappedData |= FolderRecDataFlags.SecurityDescriptors; } if (this.Rules != null && this.FieldIsLoaded(FolderRecDataFlags.Rules) && !this.FieldIsMapped(FolderRecDataFlags.Rules)) { mbxCopier.NamedPropTranslator.TranslateRules(this.Rules); if (!mbxCopier.SourceMailbox.IsCapabilitySupported(MRSProxyCapabilities.InMailboxExternalRules) && mbxCopier.DestMailbox.IsCapabilitySupported(MRSProxyCapabilities.InMailboxExternalRules)) { this.PatchRulesForDownlevelSources(this.Rules, mbxCopier.GetSourceFolderMap(GetFolderMapFlags.None)); } if (mbxCopier.SourceMailbox.IsCapabilitySupported(MRSProxyCapabilities.InMailboxExternalRules) && !mbxCopier.DestMailbox.IsCapabilitySupported(MRSProxyCapabilities.InMailboxExternalRules)) { this.PatchRulesForDownlevelDestinations(this.Rules); } if (mbxCopier.FolderIdTranslator != null) { mbxCopier.FolderIdTranslator.TranslateRules(this.Rules); } if (mbxCopier.PrincipalTranslator != null) { mbxCopier.PrincipalTranslator.TranslateRules(this.Rules); } this.MappedData |= FolderRecDataFlags.Rules; } if (mbxCopier.PrincipalTranslator != null && ((this.FieldIsLoaded(FolderRecDataFlags.FolderAcls) && !this.FieldIsMapped(FolderRecDataFlags.FolderAcls)) || (this.FieldIsLoaded(FolderRecDataFlags.ExtendedAclInformation) && !this.FieldIsMapped(FolderRecDataFlags.ExtendedAclInformation)))) { mbxCopier.PrincipalTranslator.TranslateFolderACL(this.FolderACL); mbxCopier.PrincipalTranslator.TranslateFolderACL(this.FolderFreeBusyACL); this.MappedData |= (this.FieldIsLoaded(FolderRecDataFlags.ExtendedAclInformation) ? FolderRecDataFlags.ExtendedAclInformation : FolderRecDataFlags.FolderAcls); } }
protected override void PostMoveMarkRehomeOnRelatedRequests(MailboxCopierBase mbxCtx) { mbxCtx.SyncState.CompletedCleanupTasks |= PostMoveCleanupStatusFlags.SetRelatedRequestsRehome; }
protected override void PostMoveCleanupSourceMailbox(MailboxCopierBase mbxCtx) { mbxCtx.SyncState.CompletedCleanupTasks |= PostMoveCleanupStatusFlags.SourceMailboxCleanup; }
protected override void VerifyFolderContents(MailboxCopierBase mbxCtx, FolderRecWrapper folderRecWrapper, List <FolderSizeRec> verificationResults) { throw new NotImplementedException(); }
protected override void CleanupDestinationMailbox(MailboxCopierBase mbxCtx, bool moveIsSuccessful) { }
protected override void OnMoveCompleted(MailboxCopierBase mbxCtx) { }
public override void EnsureDataLoaded(IFolder folder, FolderRecDataFlags dataToLoad, MailboxCopierBase mbxCtx) { if (mbxCtx.IsPublicFolderMigration) { switch (this.WKFType) { case WellKnownFolderType.Root: case WellKnownFolderType.NonIpmSubtree: case WellKnownFolderType.IpmSubtree: case WellKnownFolderType.EFormsRegistry: dataToLoad &= ~(FolderRecDataFlags.SecurityDescriptors | FolderRecDataFlags.FolderAcls | FolderRecDataFlags.ExtendedAclInformation); break; default: if (this.IsLegacyPublicFolder) { dataToLoad &= ~(FolderRecDataFlags.SecurityDescriptors | FolderRecDataFlags.FolderAcls | FolderRecDataFlags.ExtendedAclInformation); } break; } } base.EnsureDataLoaded(folder, dataToLoad, mbxCtx); }
public virtual void EnsureDataLoaded(IFolder folder, FolderRecDataFlags dataToLoad, MailboxCopierBase mbxCtx) { FolderRecDataFlags folderRecDataFlags = dataToLoad & FolderRecDataFlags.ExtendedData; if (folderRecDataFlags != FolderRecDataFlags.None && !this.FieldIsLoaded(folderRecDataFlags)) { GetFolderRecFlags getFolderRecFlags = GetFolderRecFlags.None; if (this.FolderType == FolderType.Generic) { if ((dataToLoad & FolderRecDataFlags.PromotedProperties) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.PromotedProperties)) { getFolderRecFlags |= GetFolderRecFlags.PromotedProperties; } if ((dataToLoad & FolderRecDataFlags.Restrictions) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.Restrictions)) { getFolderRecFlags |= GetFolderRecFlags.Restrictions; } } if ((this.FolderType == FolderType.Generic || this.FolderType == FolderType.Search) && (dataToLoad & FolderRecDataFlags.Views) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.Views)) { getFolderRecFlags |= GetFolderRecFlags.Views; } if (getFolderRecFlags != GetFolderRecFlags.None) { FolderRec folderRec = folder.GetFolderRec(null, getFolderRecFlags); this.FolderRec.SetPromotedProperties(folderRec.GetPromotedProperties()); this.FolderRec.Views = folderRec.Views; this.FolderRec.ICSViews = folderRec.ICSViews; this.FolderRec.Restrictions = folderRec.Restrictions; } this.LoadedData |= folderRecDataFlags; } if ((dataToLoad & FolderRecDataFlags.SearchCriteria) != FolderRecDataFlags.None && !this.IsSpoolerQueue && !this.FieldIsLoaded(FolderRecDataFlags.SearchCriteria)) { this.ReadSearchCriteria(folder, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.SearchCriteria; } if ((dataToLoad & FolderRecDataFlags.Rules) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.Rules)) { this.ReadRules(folder, FolderRecWrapper.extraTags, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.Rules; MrsTracer.Service.Debug("Rules loaded: {0}", new object[] { new RulesDataContext(this.Rules) }); } if ((dataToLoad & FolderRecDataFlags.SecurityDescriptors) != FolderRecDataFlags.None && !this.FieldIsLoaded(FolderRecDataFlags.SecurityDescriptors)) { this.FolderNTSD = this.ReadSD(folder, SecurityProp.NTSD, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.FolderFreeBusyNTSD = this.ReadSD(folder, SecurityProp.FreeBusyNTSD, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.SecurityDescriptors; MrsTracer.Service.Debug("FolderSDs loaded: NTSD {0}, FreeBusyNTSD {1}", new object[] { CommonUtils.GetSDDLString(this.FolderNTSD), CommonUtils.GetSDDLString(this.FolderFreeBusyNTSD) }); } if (dataToLoad.HasFlag(FolderRecDataFlags.FolderAcls) && !this.FieldIsLoaded(FolderRecDataFlags.FolderAcls)) { this.FolderACL = this.ReadACL(folder, SecurityProp.NTSD, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.FolderFreeBusyACL = this.ReadACL(folder, SecurityProp.FreeBusyNTSD, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.FolderAcls; MrsTracer.Service.Debug("FolderAcls are loaded: ACL {0}, FreeBusyACL {1}", new object[] { new PropValuesDataContext(this.FolderACL).ToString(), new PropValuesDataContext(this.FolderFreeBusyACL).ToString() }); } if (dataToLoad.HasFlag(FolderRecDataFlags.ExtendedAclInformation) && !this.FieldIsLoaded(FolderRecDataFlags.ExtendedAclInformation)) { this.FolderACL = this.ReadExtendedAcl(folder, AclFlags.FolderAcl, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.FolderFreeBusyACL = this.ReadExtendedAcl(folder, AclFlags.FreeBusyAcl, new Action <List <BadMessageRec> >(mbxCtx.ReportBadItems), new Func <byte[], IFolder>(mbxCtx.SourceMailboxWrapper.GetFolder)); this.LoadedData |= FolderRecDataFlags.ExtendedAclInformation; MrsTracer.Service.Debug("FolderExtendedAcls are loaded: Acl {0}, FreeBusyAcl {1}", new object[] { new PropValuesDataContext(this.FolderACL).ToString(), new PropValuesDataContext(this.FolderFreeBusyACL).ToString() }); } }
protected override void UpdateSourceMailbox() { ReportEntry[] entries = null; MailboxCopierBase rootCtx = base.GetRootMailboxContext(); ADUser srcUser = rootCtx.SourceMailbox.GetADUser(); ADUser destUser = null; ConfigurableObjectXML configObj; CommonUtils.CatchKnownExceptions(delegate { destUser = rootCtx.DestMailbox.GetADUser(); configObj = ConfigurableObjectXML.Create(destUser); this.Report.Append(MrsStrings.ReportTargetMailboxAfterFinalization2(destUser.ToString(), destUser.OriginatingServer), configObj, ReportEntryFlags.Target | ReportEntryFlags.After); }, delegate(Exception failure) { this.Report.Append(MrsStrings.ReportUnableToLoadDestinationUser(CommonUtils.GetFailureType(failure)), failure, ReportEntryFlags.Cleanup | ReportEntryFlags.Target); FailureLog.Write(this.RequestJobGuid, failure, false, RequestState.Cleanup, SyncStage.CleanupUnableToLoadTargetMailbox, null, null); destUser = (ADUser)srcUser.Clone(); }); if (base.CachedRequestJob.PrimaryIsMoving) { SmtpAddress?smtpAddress = null; foreach (ProxyAddress proxyAddress in destUser.EmailAddresses) { SmtpProxyAddress smtpProxyAddress = proxyAddress as SmtpProxyAddress; if (smtpProxyAddress != null) { SmtpAddress value = new SmtpAddress(smtpProxyAddress.SmtpAddress); if (StringComparer.OrdinalIgnoreCase.Equals(value.Domain, base.CachedRequestJob.TargetDeliveryDomain)) { smtpAddress = new SmtpAddress?(value); break; } } } if (smtpAddress == null) { LocalizedString localizedString = MrsStrings.ReportUnableToComputeTargetAddress(base.CachedRequestJob.TargetDeliveryDomain, destUser.PrimarySmtpAddress.ToString()); base.Report.Append(localizedString); base.Warnings.Add(localizedString); FailureLog.Write(base.RequestJobGuid, new MailboxReplicationTransientException(localizedString), false, RequestState.Cleanup, SyncStage.CleanupUnableToComputeTargetAddress, null, null); smtpAddress = new SmtpAddress?(destUser.PrimarySmtpAddress); } SmtpProxyAddress smtpProxyAddress2 = new SmtpProxyAddress(smtpAddress.Value.ToString(), true); destUser.ExternalEmailAddress = smtpProxyAddress2; List <PropertyUpdateXML> list = new List <PropertyUpdateXML>(); PropertyUpdateXML.Add(list, ADRecipientSchema.ExternalEmailAddress, smtpProxyAddress2, PropertyUpdateOperation.Replace); if (rootCtx.SyncState.ExternalLegacyExchangeDN != null) { PropertyUpdateXML.Add(list, ADRecipientSchema.LegacyExchangeDN, rootCtx.SyncState.ExternalLegacyExchangeDN, PropertyUpdateOperation.Replace); this.AddX500ProxyAddressIfNeeded(list, srcUser, srcUser.LegacyExchangeDN, srcUser.Identity.ToString()); } if (rootCtx.SyncState.InternalLegacyExchangeDN != null) { this.AddX500ProxyAddressIfNeeded(list, srcUser, rootCtx.SyncState.InternalLegacyExchangeDN, destUser.Identity.ToString()); } destUser.LinkedMasterAccount = XMLSerializableBase.Serialize(list.ToArray(), false); } try { Guid?newMailboxContainerGuid = null; CrossTenantObjectId newUnifiedMailboxId = null; MrsTracer.Service.Debug("Updating source mailbox...", new object[0]); UpdateMovedMailboxOperation op; Guid newArchiveDatabaseGuid; ArchiveStatusFlags archiveStatus; string archiveDomain; if (base.CachedRequestJob.PrimaryOnly) { op = UpdateMovedMailboxOperation.MorphToMailUser; newArchiveDatabaseGuid = ((srcUser.ArchiveDatabase != null) ? srcUser.ArchiveDatabase.ObjectGuid : Guid.Empty); archiveStatus = ((srcUser.ArchiveDatabase != null) ? ArchiveStatusFlags.Active : ArchiveStatusFlags.None); archiveDomain = null; } else if (base.CachedRequestJob.ArchiveOnly) { op = UpdateMovedMailboxOperation.UpdateArchiveOnly; newArchiveDatabaseGuid = Guid.Empty; archiveStatus = ArchiveStatusFlags.None; archiveDomain = ((srcUser.Database != null) ? base.CachedRequestJob.ArchiveDomain : null); newMailboxContainerGuid = srcUser.MailboxContainerGuid; newUnifiedMailboxId = srcUser.UnifiedMailbox; } else { op = UpdateMovedMailboxOperation.MorphToMailUser; newArchiveDatabaseGuid = Guid.Empty; archiveDomain = null; archiveStatus = ArchiveStatusFlags.None; } UpdateMovedMailboxFlags updateMovedMailboxFlags = UpdateMovedMailboxFlags.None; if (base.CachedRequestJob.SkipMailboxReleaseCheck) { updateMovedMailboxFlags |= UpdateMovedMailboxFlags.SkipMailboxReleaseCheck; } rootCtx.SourceMailbox.UpdateMovedMailbox(op, destUser, base.CachedRequestJob.SourceDomainControllerToUpdate ?? srcUser.OriginatingServer, out entries, Guid.Empty, newArchiveDatabaseGuid, archiveDomain, archiveStatus, updateMovedMailboxFlags, newMailboxContainerGuid, newUnifiedMailboxId); } finally { base.AppendReportEntries(entries); } CommonUtils.CatchKnownExceptions(delegate { srcUser = rootCtx.SourceMailbox.GetADUser(); configObj = ConfigurableObjectXML.Create(srcUser); this.Report.Append(MrsStrings.ReportSourceMailUserAfterFinalization2(srcUser.ToString(), srcUser.OriginatingServer), configObj, ReportEntryFlags.Source | ReportEntryFlags.After); }, null); }
protected override void UpdateMovedMailbox() { ReportEntry[] entries = null; ADUser aduser = base.GetRootMailboxContext().SourceMailbox.GetADUser(); ConfigurableObjectXML configObject = ConfigurableObjectXML.Create(aduser); base.Report.Append(MrsStrings.ReportSourceMailboxBeforeFinalization2(aduser.ToString(), aduser.OriginatingServer), configObject, ReportEntryFlags.Source | ReportEntryFlags.Before); ADUser aduser2 = base.GetRootMailboxContext().DestMailbox.GetADUser(); configObject = ConfigurableObjectXML.Create(aduser2); base.Report.Append(MrsStrings.ReportTargetMailUserBeforeFinalization2(aduser2.ToString(), aduser2.OriginatingServer), configObject, ReportEntryFlags.Target | ReportEntryFlags.Before); bool isFromDatacenter = aduser.IsFromDatacenter; bool isFromDatacenter2 = aduser2.IsFromDatacenter; if (base.CachedRequestJob.PrimaryIsMoving) { CommonUtils.ValidateTargetDeliveryDomain(aduser2.EmailAddresses, base.CachedRequestJob.TargetDeliveryDomain); MailboxCopierBase rootMailboxContext = base.GetRootMailboxContext(); if (!isFromDatacenter && isFromDatacenter2) { rootMailboxContext.SyncState.ExternalLegacyExchangeDN = FreeBusyFolder.GetExternalLegacyDN(aduser); } else if (isFromDatacenter && !isFromDatacenter2) { string mdbLegDN = base.GetRootMailboxContext().DestMailbox.GetMailboxInformation().MdbLegDN; rootMailboxContext.SyncState.InternalLegacyExchangeDN = FreeBusyFolder.GetInternalLegacyDN(aduser2, mdbLegDN); } List <PropertyUpdateXML> list = new List <PropertyUpdateXML>(); if (rootMailboxContext.SyncState.ExternalLegacyExchangeDN != null) { this.AddX500ProxyAddressIfNeeded(list, aduser2, rootMailboxContext.SyncState.ExternalLegacyExchangeDN, aduser.Identity.ToString()); } if (rootMailboxContext.SyncState.InternalLegacyExchangeDN != null) { PropertyUpdateXML.Add(list, ADRecipientSchema.LegacyExchangeDN, rootMailboxContext.SyncState.InternalLegacyExchangeDN, PropertyUpdateOperation.Replace); this.AddX500ProxyAddressIfNeeded(list, aduser2, aduser2.LegacyExchangeDN, aduser2.Identity.ToString()); } aduser.LinkedMasterAccount = XMLSerializableBase.Serialize(list.ToArray(), false); } MrsTracer.Service.Debug("Updating destination mailbox...", new object[0]); UpdateMovedMailboxOperation op; Guid newDatabaseGuid; Guid newArchiveDatabaseGuid; ArchiveStatusFlags archiveStatus; string archiveDomain; if (base.CachedRequestJob.PrimaryOnly) { op = UpdateMovedMailboxOperation.MorphToMailbox; newDatabaseGuid = base.CachedRequestJob.TargetMDBGuid; newArchiveDatabaseGuid = ((aduser2.ArchiveDatabase != null) ? aduser2.ArchiveDatabase.ObjectGuid : Guid.Empty); archiveStatus = ArchiveStatusFlags.None; archiveDomain = ((aduser2.ArchiveDatabase == null) ? base.CachedRequestJob.ArchiveDomain : null); } else if (base.CachedRequestJob.ArchiveOnly) { op = UpdateMovedMailboxOperation.UpdateArchiveOnly; newDatabaseGuid = Guid.Empty; newArchiveDatabaseGuid = base.CachedRequestJob.TargetArchiveMDBGuid; archiveStatus = ((aduser2.Database == null) ? ArchiveStatusFlags.Active : ArchiveStatusFlags.None); archiveDomain = null; } else { op = UpdateMovedMailboxOperation.MorphToMailbox; newDatabaseGuid = base.CachedRequestJob.TargetMDBGuid; newArchiveDatabaseGuid = base.CachedRequestJob.TargetArchiveMDBGuid; archiveDomain = null; archiveStatus = ArchiveStatusFlags.None; } UpdateMovedMailboxFlags updateMovedMailboxFlags = UpdateMovedMailboxFlags.None; if (base.CachedRequestJob.SkipMailboxReleaseCheck) { updateMovedMailboxFlags |= UpdateMovedMailboxFlags.SkipMailboxReleaseCheck; } if (base.CachedRequestJob.SkipProvisioningCheck) { updateMovedMailboxFlags |= UpdateMovedMailboxFlags.SkipProvisioningCheck; } try { base.GetRootMailboxContext().DestMailbox.UpdateMovedMailbox(op, aduser, base.CachedRequestJob.DestDomainControllerToUpdate, out entries, newDatabaseGuid, newArchiveDatabaseGuid, archiveDomain, archiveStatus, updateMovedMailboxFlags, null, null); } finally { base.AppendReportEntries(entries); } }
protected override void CleanupCanceledJob() { base.CheckDisposed(); MrsTracer.Service.Debug("Deleting messages and dumpster folder.", new object[0]); using (List <MailboxCopierBase> .Enumerator enumerator = this.GetAllCopiers().GetEnumerator()) { while (enumerator.MoveNext()) { MailboxCopierBase mbxCtx = enumerator.Current; CommonUtils.CatchKnownExceptions(delegate { if (!mbxCtx.IsDestinationConnected) { mbxCtx.ConnectDestinationMailbox(MailboxConnectFlags.None); } SyncStateError syncStateError = mbxCtx.LoadSyncState(this.Report); if (syncStateError != SyncStateError.None && this.CanBeCanceledOrSuspended()) { MrsTracer.Service.Debug("Deleting folders at destination mailbox {0}", new object[] { mbxCtx.TargetTracingID }); MrsTracer.Service.Debug(MrsStrings.ReportCleanUpFoldersDestination("CleanupCanceledJob"), new object[0]); this.CleanUpFoldersAtDestination(); } mbxCtx.ClearSyncState(SyncStateClearReason.JobCanceled); bool flag; mbxCtx.DestMailbox.SetInTransitStatus(InTransitStatus.NotInTransit, out flag); }, delegate(Exception failure) { LocalizedString localizedString = CommonUtils.FullExceptionMessage(failure); this.Report.Append(MrsStrings.ReportDestinationMailboxCleanupFailed2(CommonUtils.GetFailureType(failure)), failure, ReportEntryFlags.Cleanup | ReportEntryFlags.Target); MailboxReplicationService.LogEvent(MRSEventLogConstants.Tuple_DestinationMailboxCleanupFailed, new object[] { this.RequestJobIdentity, mbxCtx.TargetTracingID, this.CachedRequestJob.TargetMDBName, localizedString }); }); } } MoveHistoryEntryInternal mhei; base.RemoveRequest(true, out mhei); using (List <MailboxCopierBase> .Enumerator enumerator2 = this.GetAllCopiers().GetEnumerator()) { while (enumerator2.MoveNext()) { AuxFolderMoveJob.< > c__DisplayClass138 CS$ < > 8__locals3 = new AuxFolderMoveJob.< > c__DisplayClass138(); CS$ < > 8__locals3.mbxCtx = enumerator2.Current; bool resetInTransitSuccess = false; CommonUtils.CatchKnownExceptions(delegate { if (!CS$ < > 8__locals3.mbxCtx.IsSourceConnected) { CS$ < > 8__locals3.mbxCtx.ConnectSourceMailbox(MailboxConnectFlags.None); } bool flag; CS$ < > 8__locals3.mbxCtx.SourceMailbox.SetInTransitStatus(InTransitStatus.NotInTransit, out flag); resetInTransitSuccess = true; if (CS$ < > 8__locals3.mbxCtx.IsRoot && mhei != null) { CS$ < > 8__locals3.mbxCtx.SourceMailbox.AddMoveHistoryEntry(mhei, this.GetConfig <int>("MaxMoveHistoryLength")); } }, delegate(Exception failure)