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)
