public override void ValidateAndPopulateRequestJob(List <ReportEntry> entries)
{
base.ConfigureMailboxProviders();
if (base.CachedRequestJob.TargetIsLocal || !base.CachedRequestJob.SkipInitialConnectionValidation)
{
this.MailboxMerger.ConnectDestinationMailbox(MailboxConnectFlags.ValidateOnly);
base.CachedRequestJob.TimeTracker.SetTimestamp(RequestJobTimestamp.LastSuccessfulTargetConnection, new DateTime?(DateTime.UtcNow));
base.CachedRequestJob.TimeTracker.SetTimestamp(RequestJobTimestamp.TargetConnectionFailure, null);
MailboxServerInformation mailboxServerInformation = this.MailboxMerger.DestMailbox.GetMailboxServerInformation();
MailboxInformation mailboxInformation = this.MailboxMerger.DestMailbox.GetMailboxInformation();
if (mailboxInformation != null && mailboxInformation.ServerVersion != 0)
{
base.CachedRequestJob.TargetVersion = mailboxInformation.ServerVersion;
base.CachedRequestJob.TargetServer = ((mailboxServerInformation != null) ? mailboxServerInformation.MailboxServerName : null);
}
}
this.AfterTargetConnect();
if (base.CachedRequestJob.SourceIsLocal || !base.CachedRequestJob.SkipInitialConnectionValidation)
{
this.MailboxMerger.ConnectSourceMailbox(MailboxConnectFlags.ValidateOnly);
base.CachedRequestJob.TimeTracker.SetTimestamp(RequestJobTimestamp.LastSuccessfulSourceConnection, new DateTime?(DateTime.UtcNow));
base.CachedRequestJob.TimeTracker.SetTimestamp(RequestJobTimestamp.SourceConnectionFailure, null);
MailboxServerInformation mailboxServerInformation2 = this.MailboxMerger.SourceMailbox.GetMailboxServerInformation();
MailboxInformation mailboxInformation2 = this.MailboxMerger.SourceMailbox.GetMailboxInformation();
if (mailboxInformation2 != null && mailboxInformation2.ServerVersion != 0)
{
base.CachedRequestJob.SourceVersion = mailboxInformation2.ServerVersion;
base.CachedRequestJob.SourceServer = ((mailboxServerInformation2 != null) ? mailboxServerInformation2.MailboxServerName : null);
}
}
}
MailboxServerInformation IMailbox.GetMailboxServerInformation()
{
MailboxServerInformation result = null;
base.CreateContext("IMailbox.GetMailboxServerInformation", new DataContext[0]).Execute(delegate
{
result = this.WrappedObject.GetMailboxServerInformation();
}, true);
return(result);
}
public void UpdateLastConnectedServerInfo(out MailboxServerInformation serverInfo, out bool hasDatabaseFailedOver)
{
serverInfo = this.Mailbox.GetMailboxServerInformation();
hasDatabaseFailedOver = false;
if (serverInfo != null)
{
if (this.LastConnectedServerInfo != null && serverInfo.MailboxServerGuid != Guid.Empty && this.LastConnectedServerInfo.MailboxServerGuid != serverInfo.MailboxServerGuid)
{
this.LastConnectedServerInfo = null;
hasDatabaseFailedOver = true;
return;
}
this.LastConnectedServerInfo = serverInfo;
}
}
private static void ConnectAndValidateSource(ISourceMailbox sourceDatabase, out MailboxServerInformation sourceMailboxServerInfo, out MailboxInformation sourceDatabaseInfo)
{
sourceDatabase.Connect(MailboxConnectFlags.None);
sourceMailboxServerInfo = sourceDatabase.GetMailboxServerInformation();
sourceDatabaseInfo = sourceDatabase.GetMailboxInformation();
MrsTracer.Service.Debug("Switching source public folder database {0} to SyncSource mode.", new object[]
{
sourceDatabaseInfo
});
bool flag;
sourceDatabase.SetInTransitStatus(InTransitStatus.SyncSource, out flag);
if (!flag)
{
throw new OfflinePublicFolderMigrationNotSupportedException();
}
}
public override void ValidateAndPopulateRequestJob(List <ReportEntry> entries)
{
this.ConfigureProviders(false);
MailboxServerInformation mailboxServerInformation = null;
MailboxInformation mailboxInformation = null;
this.ConnectSource(this.folderMover, out mailboxServerInformation, out mailboxInformation);
if (mailboxInformation != null && mailboxInformation.ServerVersion != 0)
{
base.CachedRequestJob.SourceVersion = mailboxInformation.ServerVersion;
base.CachedRequestJob.SourceServer = ((mailboxServerInformation != null) ? mailboxServerInformation.MailboxServerName : null);
}
this.ConnectDestination(this.folderMover, out mailboxServerInformation, out mailboxInformation);
if (mailboxInformation != null && mailboxInformation.ServerVersion != 0)
{
base.CachedRequestJob.TargetVersion = mailboxInformation.ServerVersion;
base.CachedRequestJob.TargetServer = ((mailboxServerInformation != null) ? mailboxServerInformation.MailboxServerName : null);
}
}
public override void ValidateAndPopulateRequestJob(List <ReportEntry> entries)
{
this.InternalConfigureProviders(false);
MailboxServerInformation mailboxServerInformation;
MailboxInformation mailboxInformation;
PublicFolderMigrationJob.ConnectAndValidateSource(this.sourceDatabases, out mailboxServerInformation, out mailboxInformation);
base.CachedRequestJob.TimeTracker.SetTimestamp(RequestJobTimestamp.LastSuccessfulSourceConnection, new DateTime?(DateTime.UtcNow));
base.CachedRequestJob.TimeTracker.SetTimestamp(RequestJobTimestamp.SourceConnectionFailure, null);
MailboxServerInformation mailboxServerInformation2 = null;
MailboxInformation mailboxInformation2 = null;
foreach (PublicFolderMigrator publicFolderMigrator in this.publicFolderMigrators.Values)
{
MailboxServerInformation mailboxServerInformation3;
MailboxInformation mailboxInformation3;
PublicFolderMigrationJob.ConnectAndValidateDestination(publicFolderMigrator.DestMailbox, MailboxConnectFlags.ValidateOnly, out mailboxServerInformation3, out mailboxInformation3);
bool flag = publicFolderMigrator.TargetMailboxGuid == this.publicFolderConfiguration.GetHierarchyMailboxInformation().HierarchyMailboxGuid;
if (flag)
{
MrsTracer.Service.Debug("PublicFolderMigrator for hierarchy mailbox created, with dumpster creation by {0}.", new object[]
{
publicFolderMigrator.DestMailbox.IsCapabilitySupported(MRSProxyCapabilities.CanStoreCreatePFDumpster) ? "Store" : "MRS"
});
mailboxServerInformation2 = mailboxServerInformation3;
mailboxInformation2 = mailboxInformation3;
}
}
base.CachedRequestJob.TimeTracker.SetTimestamp(RequestJobTimestamp.LastSuccessfulTargetConnection, new DateTime?(DateTime.UtcNow));
base.CachedRequestJob.TimeTracker.SetTimestamp(RequestJobTimestamp.TargetConnectionFailure, null);
if (mailboxInformation != null && mailboxInformation.ServerVersion != 0)
{
base.CachedRequestJob.SourceVersion = mailboxInformation.ServerVersion;
base.CachedRequestJob.SourceServer = ((mailboxServerInformation != null) ? mailboxServerInformation.MailboxServerName : null);
}
if (mailboxInformation2 != null && mailboxInformation2.ServerVersion != 0)
{
base.CachedRequestJob.TargetVersion = mailboxInformation2.ServerVersion;
base.CachedRequestJob.TargetServer = ((mailboxServerInformation2 != null) ? mailboxServerInformation2.MailboxServerName : null);
}
}
private static void ConnectAndValidateDestination(IDestinationMailbox destinationMailboxes, MailboxConnectFlags connectFlags, out MailboxServerInformation destinationHierarchyMailboxServerInfo, out MailboxInformation destinationHierarchyMailboxInfo)
{
destinationMailboxes.Connect(connectFlags);
destinationHierarchyMailboxServerInfo = destinationMailboxes.GetMailboxServerInformation();
destinationHierarchyMailboxInfo = destinationMailboxes.GetMailboxInformation();
}
internal ConnectivityRec(ServerKind serverKind, MailboxInformation mailboxInfo, MailboxServerInformation serverInfo)
{
this.ServerKind = serverKind;
this.ServerName = serverInfo.MailboxServerName;
this.ServerVersion = new ServerVersion(serverInfo.MailboxServerVersion);
if (serverInfo.ProxyServerName != null)
{
this.ProxyName = serverInfo.ProxyServerName;
this.ProxyVersion = serverInfo.ProxyServerVersion.ServerVersion;
}
if (mailboxInfo != null)
{
this.ProviderName = mailboxInfo.ProviderName;
}
}
protected override void MakeConnections()
{
Exception sourceConnectFailure = null;
Exception targetConnectFailure = null;
int sourceVersion = 0;
int targetVersion = 0;
string sourceServerName = null;
string targetServerName = null;
CommonUtils.CatchKnownExceptions(delegate
{
MrsTracer.Service.Debug("Attempting to connect to the destination mailbox {0}.", new object[]
{
this.MailboxMerger.TargetTracingID
});
this.MailboxMerger.ConnectDestinationMailbox(MailboxConnectFlags.None);
}, delegate(Exception failure)
{
MrsTracer.Service.Warning("Failed to connect to destination mailbox: {0}", new object[]
{
CommonUtils.FullExceptionMessage(failure)
});
targetConnectFailure = failure;
});
if (targetConnectFailure == null)
{
MailboxServerInformation mailboxServerInformation = this.MailboxMerger.DestMailbox.GetMailboxServerInformation();
MailboxInformation mailboxInformation = this.MailboxMerger.DestMailbox.GetMailboxInformation();
this.MailboxMerger.TargetServerInfo = mailboxServerInformation;
if (mailboxServerInformation != null)
{
ConnectivityRec connectivityRec = new ConnectivityRec(ServerKind.Target, mailboxInformation, mailboxServerInformation);
base.Report.Append(MrsStrings.ReportDestinationMailboxConnection(this.MailboxMerger.TargetTracingID, mailboxServerInformation.ServerInfoString, (mailboxInformation != null) ? mailboxInformation.MdbName : "(null)"), connectivityRec);
targetServerName = mailboxServerInformation.MailboxServerName;
targetVersion = mailboxServerInformation.MailboxServerVersion;
}
if (!this.MailboxMerger.DestMailbox.MailboxExists())
{
throw new MailboxDoesNotExistPermanentException(this.MailboxMerger.TargetTracingID);
}
MrsTracer.Service.Debug("Destination mailbox {0} exists.", new object[]
{
this.MailboxMerger.TargetTracingID
});
base.TimeTracker.SetTimestamp(RequestJobTimestamp.LastSuccessfulTargetConnection, new DateTime?(DateTime.UtcNow));
base.TimeTracker.SetTimestamp(RequestJobTimestamp.TargetConnectionFailure, null);
this.MailboxMerger.LoadSyncState(base.Report);
}
if (targetConnectFailure == null)
{
this.AfterTargetConnect();
}
CommonUtils.CatchKnownExceptions(delegate
{
MrsTracer.Service.Debug("Connecting to the source mailbox {0}.", new object[]
{
this.MailboxMerger.SourceTracingID
});
this.MailboxMerger.ConnectSourceMailbox(MailboxConnectFlags.None);
}, delegate(Exception failure)
{
MrsTracer.Service.Warning("Failed to connect to source mailbox: {0}", new object[]
{
CommonUtils.FullExceptionMessage(failure)
});
sourceConnectFailure = failure;
});
if (sourceConnectFailure == null)
{
base.TimeTracker.SetTimestamp(RequestJobTimestamp.LastSuccessfulSourceConnection, new DateTime?(DateTime.UtcNow));
base.TimeTracker.SetTimestamp(RequestJobTimestamp.SourceConnectionFailure, null);
MailboxServerInformation mailboxServerInformation2 = this.MailboxMerger.SourceMailbox.GetMailboxServerInformation();
MailboxInformation mailboxInformation2 = this.MailboxMerger.SourceMailbox.GetMailboxInformation();
this.MailboxMerger.SourceServerInfo = mailboxServerInformation2;
if (mailboxServerInformation2 != null)
{
ConnectivityRec connectivityRec2 = new ConnectivityRec(ServerKind.Source, mailboxInformation2, mailboxServerInformation2);
base.Report.Append(MrsStrings.ReportSourceMailboxConnection(this.MailboxMerger.SourceTracingID, mailboxServerInformation2.ServerInfoString, (mailboxInformation2 != null) ? mailboxInformation2.MdbName : "(null)"), connectivityRec2);
sourceServerName = mailboxServerInformation2.MailboxServerName;
sourceVersion = mailboxServerInformation2.MailboxServerVersion;
}
}
if (sourceConnectFailure != null || targetConnectFailure != null)
{
base.CheckRequestIsValid();
if (sourceConnectFailure != null)
{
throw sourceConnectFailure;
}
if (targetConnectFailure != null)
{
throw targetConnectFailure;
}
}
base.SaveRequest(true, delegate(TransactionalRequestJob rj)
{
this.TimeTracker.SetTimestamp(RequestJobTimestamp.Failure, null);
this.TimeTracker.SetTimestamp(RequestJobTimestamp.Suspended, null);
rj.FailureCode = null;
rj.FailureType = null;
rj.FailureSide = null;
rj.Message = LocalizedString.Empty;
rj.SourceServer = sourceServerName;
rj.SourceVersion = sourceVersion;
rj.TargetServer = targetServerName;
rj.TargetVersion = targetVersion;
rj.Status = RequestStatus.InProgress;
this.TimeTracker.CurrentState = RequestState.InitialSeeding;
RequestJobLog.Write(rj);
});
if (!string.IsNullOrEmpty(base.CachedRequestJob.ContentFilter))
{
RestrictionData contentRestriction;
string text;
ContentFilterBuilder.ProcessContentFilter(base.CachedRequestJob.ContentFilter, base.CachedRequestJob.ContentFilterLCID, null, this.MailboxMerger.SourceMailboxWrapper, out contentRestriction, out text);
this.MailboxMerger.ContentRestriction = contentRestriction;
}
if (this.MailboxMerger.SupportsRuleAPIs)
{
this.MailboxMerger.SourceMailbox.ConfigMailboxOptions(MailboxOptions.IgnoreExtendedRuleFAIs);
}
this.MailboxMerger.ExchangeSourceAndTargetVersions();
base.ScheduleWorkItem(new Action(this.StartMerge), WorkloadType.Unknown);
}
