public static IEnumerable <string> GetMigrationMailboxLegacyDN(TenantPartitionHint tenantPartitionHint, string localServer, QueryFilter optionalFilter = null)
{
IRecipientSession recipientSession = MigrationHelperBase.CreateRecipientSession(tenantPartitionHint);
string connectionInformation = string.Format("Accessing migration mailboxes for organization: {0}", tenantPartitionHint);
List <QueryFilter> filters = new List <QueryFilter>(3);
filters.Add(OrganizationMailbox.OrganizationMailboxFilterBase);
filters.Add(new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.RawCapabilities, OrganizationCapability.Migration));
if (optionalFilter != null)
{
filters.Add(optionalFilter);
}
IEnumerable <ADUser> users = MigrationHelperBase.GetRecipients <ADUser>(recipientSession, QueryFilter.AndTogether(filters.ToArray()), (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation), (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation), connectionInformation);
foreach (ADUser user in users)
{
string serverName = null;
if (user.Database != null)
{
serverName = MigrationHelperBase.GetServerFqdn(user.Database.ObjectGuid);
}
if (string.Equals(serverName, localServer, StringComparison.OrdinalIgnoreCase))
{
yield return(user.LegacyExchangeDN);
}
}
yield break;
}
private ISourceMailbox GetSourceMailbox()
{
ISourceMailbox result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
ExchangePrincipal exchangePrincipal;
if (!PublicFolderSession.TryGetPublicFolderMailboxPrincipal(this.OrganizationId, PublicFolderSession.HierarchyMailboxGuidAlias, true, out exchangePrincipal))
{
throw new StoragePermanentException(PublicFolderSession.GetNoPublicFoldersProvisionedError(this.OrganizationId));
}
ISourceMailbox sourceMailbox = new RemoteSourceMailbox(exchangePrincipal.MailboxInfo.Location.ServerFqdn, null, null, this.isSingleFolderSync ? ProxyControlFlags.SkipWLMThrottling : ProxyControlFlags.None, PublicFolderSynchronizerContext.RequiredCapabilities, false, LocalMailboxFlags.None);
disposeGuard.Add <ISourceMailbox>(sourceMailbox);
TenantPartitionHint partitionHint = CommonUtils.GetPartitionHint(this.OrganizationId);
if (this.Logger != null)
{
this.Logger.LogEvent(LogEventType.Verbose, string.Format("Connecting to Primary Hierarchy. [Mailbox:{0}; Server:{1}; Database:{2}; PartitionHint:{3}]", new object[]
{
exchangePrincipal.MailboxInfo.MailboxGuid,
exchangePrincipal.MailboxInfo.Location.ServerFqdn,
exchangePrincipal.MailboxInfo.GetDatabaseGuid(),
partitionHint
}));
}
sourceMailbox.Config(null, exchangePrincipal.MailboxInfo.MailboxGuid, exchangePrincipal.MailboxInfo.MailboxGuid, partitionHint, exchangePrincipal.MailboxInfo.GetDatabaseGuid(), MailboxType.SourceMailbox, null);
sourceMailbox.Connect(MailboxConnectFlags.PublicFolderHierarchyReplication);
disposeGuard.Success();
result = sourceMailbox;
}
return(result);
}
private static void FixTenantInfo(RequestJobXML requestJobXML)
{
if (!CommonUtils.IsMultiTenantEnabled())
{
requestJobXML.OrganizationId = OrganizationId.ForestWideOrgId;
return;
}
if (requestJobXML.OrganizationId == OrganizationId.ForestWideOrgId && requestJobXML.ExternalDirectoryOrganizationId == Guid.Empty && requestJobXML.PartitionHint == null)
{
return;
}
if (requestJobXML.OrganizationId != OrganizationId.ForestWideOrgId && requestJobXML.PartitionHint == null)
{
if (requestJobXML.ExternalDirectoryOrganizationId != Guid.Empty)
{
requestJobXML.OrganizationId = OrganizationId.FromExternalDirectoryOrganizationId(requestJobXML.ExternalDirectoryOrganizationId);
}
requestJobXML.PartitionHint = TenantPartitionHint.FromOrganizationId(requestJobXML.OrganizationId);
requestJobXML.ExternalDirectoryOrganizationId = requestJobXML.PartitionHint.GetExternalDirectoryOrganizationId();
return;
}
if (requestJobXML.PartitionHint != null)
{
if (requestJobXML.ExternalDirectoryOrganizationId == Guid.Empty)
{
requestJobXML.ExternalDirectoryOrganizationId = requestJobXML.PartitionHint.GetExternalDirectoryOrganizationId();
}
requestJobXML.OrganizationId = OrganizationId.FromExternalDirectoryOrganizationId(requestJobXML.ExternalDirectoryOrganizationId);
}
}
internal static void ApplyOrganization(TransactionalRequestJob dataObject, OrganizationId organizationId)
{
dataObject.OrganizationId = organizationId;
if (organizationId != OrganizationId.ForestWideOrgId)
{
dataObject.PartitionHint = TenantPartitionHint.FromOrganizationId(organizationId);
dataObject.ExternalDirectoryOrganizationId = dataObject.PartitionHint.GetExternalDirectoryOrganizationId();
}
}
public override void RunNow(Guid mailboxGuid, string parameters)
{
StoreMailboxData mailboxData;
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=TBA", null, null, null, null))
{
try
{
PropValue[][] mailboxTableInfo = exRpcAdmin.GetMailboxTableInfo(base.DatabaseInfo.Guid, mailboxGuid, new PropTag[]
{
PropTag.MailboxType,
PropTag.PersistableTenantPartitionHint,
PropTag.LastLogonTime
});
if (mailboxTableInfo.Length != 1 || mailboxTableInfo[0].Length < 1)
{
throw new InvalidOperationException("Failed to get the mailbox property");
}
PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(mailboxTableInfo[0], PropTag.PersistableTenantPartitionHint);
TenantPartitionHint tenantPartitionHint = null;
if (mailboxProperty.PropTag == PropTag.PersistableTenantPartitionHint)
{
byte[] bytes = mailboxProperty.GetBytes();
if (bytes != null && bytes.Length != 0)
{
tenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(bytes);
}
}
if (string.IsNullOrEmpty(parameters))
{
MailboxInformation mailboxInformation = MailboxInformation.Create(mailboxGuid.ToByteArray(), base.DatabaseInfo.Guid, mailboxGuid.ToString(), ControlData.Empty, mailboxTableInfo[0], MailboxInformation.GetLastLogonTime(mailboxTableInfo[0]), tenantPartitionHint);
mailboxData = mailboxInformation.MailboxData;
}
else
{
mailboxData = new MailboxDataForDemandJob(mailboxGuid, base.DatabaseInfo.Guid, null, parameters, tenantPartitionHint);
}
}
catch (MapiExceptionNotFound arg)
{
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedStoreDatabaseDriver, MapiExceptionNotFound>((long)this.GetHashCode(), "{0}: Mailbox does not exist on the store: {1}", this, arg);
if (string.IsNullOrEmpty(parameters))
{
mailboxData = new StoreMailboxData(mailboxGuid, base.DatabaseInfo.Guid, mailboxGuid.ToString(), null);
}
else
{
mailboxData = new MailboxDataForDemandJob(mailboxGuid, base.DatabaseInfo.Guid, null, parameters);
}
}
}
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedStoreDatabaseDriver, Guid>((long)this.GetHashCode(), "{0}: RunNow: about to start processing mailbox {1} on this database.", this, mailboxGuid);
base.RunNow(mailboxData);
}
protected override IConfigDataProvider CreateSession()
{
base.CurrentOrganizationId = this.ResolveCurrentOrganization();
this.partitionMailbox = MigrationObjectTaskBase <MigrationConfigIdParameter> .ResolvePartitionMailbox(this.Partition, base.TenantGlobalCatalogSession, base.ServerSettings, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADUser>), new Task.ErrorLoggerDelegate(base.WriteError), base.CurrentOrganizationId == OrganizationId.ForestWideOrgId && MapiTaskHelper.IsDatacenter);
TenantPartitionHint partitionHint = TenantPartitionHint.FromOrganizationId(base.CurrentOrganizationId);
MigrationLogger.Initialize();
MigrationLogContext.Current.Source = "Set-MigrationConfig";
MigrationLogContext.Current.Organization = base.CurrentOrganizationId.OrganizationalUnit;
return(MigrationSessionDataProvider.CreateDataProvider("SetMigrationConfig", MigrationHelperBase.CreateRecipientSession(partitionHint), this.partitionMailbox));
}
private static string GetTenantId(IStoreSession session)
{
string result = string.Empty;
byte[] valueOrDefault = session.Mailbox.GetValueOrDefault <byte[]>(MailboxSchema.PersistableTenantPartitionHint, null);
if (valueOrDefault != null && valueOrDefault.Length > 0)
{
TenantPartitionHint tenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(valueOrDefault);
Guid externalDirectoryOrganizationId = tenantPartitionHint.GetExternalDirectoryOrganizationId();
result = (Guid.Empty.Equals(externalDirectoryOrganizationId) ? string.Empty : externalDirectoryOrganizationId.ToString());
}
return(result);
}
public static ReservationBase CreateReservation(Guid mailboxGuid, TenantPartitionHint partitionHint, Guid resourceId, ReservationFlags flags, string clientName)
{
ReservationBase result;
lock (ReservationManager.Locker)
{
ReservationBase reservationBase = ReservationBase.CreateReservation(mailboxGuid, partitionHint, resourceId, flags, clientName);
ReservationManager.reservations.TryInsertSliding(reservationBase.ReservationId, reservationBase, ConfigBase <MRSConfigSchema> .GetConfig <TimeSpan>("ReservationExpirationInterval"));
reservationBase.AddReleaseAction(new Action <ReservationBase>(ReservationManager.ReleaseReservation));
result = reservationBase;
}
return(result);
}
public PublicFolderMailboxSynchronizer(OrganizationId organizationId, Guid mailboxGuid, string serverFqdn, bool onlyRefCounting)
{
ArgumentValidator.ThrowIfNull("organizationId", organizationId);
ArgumentValidator.ThrowIfEmpty("mailboxGuid", mailboxGuid);
ArgumentValidator.ThrowIfNull("server", serverFqdn);
this.tenantPartitionHint = TenantPartitionHint.FromOrganizationId(organizationId);
this.mailboxGuid = mailboxGuid;
this.serverFqdn = serverFqdn;
if (!onlyRefCounting)
{
this.ScheduleSynchronizeHierarchy(TimeSpan.FromMilliseconds(0.0));
}
}
public static TenantPartitionHintAdapter FromPersistableTenantPartitionHint(byte[] persistedData)
{
TenantPartitionHint partitionHint;
if (persistedData == null)
{
partitionHint = TenantPartitionHint.FromOrganizationId(OrganizationId.ForestWideOrgId);
}
else
{
partitionHint = TenantPartitionHint.FromPersistablePartitionHint(persistedData);
}
return(TenantPartitionHintAdapter.FromPartitionHint(partitionHint));
}
public static IRecipientSession CreateRecipientSession(TenantPartitionHint partitionHint)
{
ADSessionSettings sessionSettings;
if (partitionHint != null)
{
sessionSettings = partitionHint.GetTenantScopedADSessionSettingsServiceOnly();
}
else
{
sessionSettings = ADSessionSettings.FromRootOrgScopeSet();
}
return(DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, true, ConsistencyMode.IgnoreInvalid, sessionSettings, 189, "CreateRecipientSession", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\Management\\Migration\\MigrationHelperBase.cs"));
}
// Token: 0x06001575 RID: 5493 RVA: 0x00079F80 File Offset: 0x00078180
public static ADUser GetADUserFromMailboxGuid(Guid mailboxGuid, TenantPartitionHint partitionHint)
{
IRecipientSession adRecipientSession;
try
{
adRecipientSession = ADHelper.GetAdRecipientSession(partitionHint);
}
catch (ADTransientException ex)
{
MailboxProcessorAssistantType.Tracer.TraceError <string>(0L, "Caught AD exception: {0}", ex.Message);
throw;
}
return(adRecipientSession.FindByExchangeGuidIncludingArchive(mailboxGuid) as ADUser);
}
// Token: 0x06001561 RID: 5473 RVA: 0x00079BAC File Offset: 0x00077DAC
public MailboxProcessorMailboxData(DatabaseInfo databaseInfo, Guid mailboxGuid, int mailboxNumber, PropValue[] row) : base(mailboxGuid, mailboxNumber, databaseInfo.Guid)
{
MailboxProcessorAssistantType.TraceInformation(0L, "Retrieving mailbox information for database {0}", new object[]
{
databaseInfo.Guid
});
this.DatabaseName = databaseInfo.DatabaseName;
PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(row, PropTag.MailboxMiscFlags);
if (mailboxProperty.PropTag == PropTag.MailboxMiscFlags)
{
MailboxMiscFlags @int = (MailboxMiscFlags)mailboxProperty.GetInt();
this.IsMoveDestination = ((@int & MailboxMiscFlags.CreatedByMove) == MailboxMiscFlags.CreatedByMove);
this.IsArchive = ((@int & MailboxMiscFlags.ArchiveMailbox) == MailboxMiscFlags.ArchiveMailbox);
}
else
{
MailboxProcessorAssistantType.TraceInformation(0L, "Cannot retrieve property MailboxMiscFlags for Mailbox with GUID {0}", new object[]
{
mailboxGuid
});
this.IsMoveDestination = false;
this.IsArchive = false;
}
PropValue mailboxProperty2 = MailboxTableQuery.GetMailboxProperty(row, PropTag.PersistableTenantPartitionHint);
this.TenantPartitionHint = null;
if (mailboxProperty2.PropTag == PropTag.PersistableTenantPartitionHint)
{
byte[] bytes = mailboxProperty2.GetBytes();
if (bytes != null && bytes.Length != 0)
{
this.TenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(bytes);
}
}
else
{
MailboxProcessorAssistantType.TraceInformation(0L, "Cannot retrieve property PersistableTenantPartitionHint for Mailbox with GUID {0}", new object[]
{
mailboxGuid
});
}
MailboxProcessorAssistantType.TraceInformation(0L, "Found mailbox with GUID {0}. Is archive: {1}", new object[]
{
mailboxGuid,
this.IsArchive
});
}
public static void GetManagementMailboxData(TenantPartitionHint tenantPartitionHint, out string mailboxLegacyDN, out string serverName)
{
IRecipientSession session = MigrationHelperBase.CreateRecipientSession(tenantPartitionHint);
string connectionInformation = string.Format("Accessing management mailbox for organization: {0}", tenantPartitionHint);
ADUser recipient = MigrationHelperBase.GetRecipient <ADUser>(session, MigrationHelperBase.ManagementMailboxFilter, (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation), (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MultipleMigrationMailboxesFoundException>(connectionInformation), (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation), connectionInformation);
serverName = null;
if (recipient.Database != null)
{
serverName = MigrationHelperBase.GetServerFqdn(recipient.Database.ObjectGuid);
}
mailboxLegacyDN = recipient.LegacyExchangeDN;
if (serverName == null)
{
throw MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation);
}
}
public void ReserveResource(Guid mailboxGuid, TenantPartitionHint partitionHint, ADObjectId resourceId, ReservationFlags flags)
{
string serverFQDN = null;
if (!(resourceId.ObjectGuid == MRSResource.Id.ObjectGuid))
{
DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(resourceId, null, null, FindServerFlags.None);
if (databaseInformation.ServerVersion < Server.E15MinVersion)
{
return;
}
if (!databaseInformation.IsOnThisServer)
{
serverFQDN = databaseInformation.ServerFqdn;
}
}
this.AddReservation(ReservationWrapper.CreateReservation(serverFQDN, null, mailboxGuid, partitionHint, resourceId.ObjectGuid, flags));
}
public static ReservationBase CreateReservation(Guid mailboxGuid, TenantPartitionHint partitionHint, Guid resourceId, ReservationFlags flags, string clientName)
{
ReservationBase result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
SettingsContextBase settingsContextBase = new MailboxSettingsContext(mailboxGuid, null);
if (partitionHint != null)
{
settingsContextBase = new OrganizationSettingsContext(OrganizationId.FromExternalDirectoryOrganizationId(partitionHint.GetExternalDirectoryOrganizationId()), settingsContextBase);
}
ReservationBase reservationBase;
if (resourceId == MRSResource.Id.ObjectGuid)
{
reservationBase = new MRSReservation();
}
else
{
if (flags.HasFlag(ReservationFlags.Read))
{
reservationBase = new ReadReservation();
}
else
{
reservationBase = new WriteReservation();
}
settingsContextBase = new DatabaseSettingsContext(resourceId, settingsContextBase);
}
disposeGuard.Add <ReservationBase>(reservationBase);
settingsContextBase = new GenericSettingsContext("WorkloadType", reservationBase.WorkloadType.ToString(), settingsContextBase);
reservationBase.MailboxGuid = mailboxGuid;
reservationBase.PartitionHint = partitionHint;
reservationBase.ResourceId = resourceId;
reservationBase.Flags = flags;
reservationBase.ClientName = clientName;
using (settingsContextBase.Activate())
{
reservationBase.ReserveResources();
}
disposeGuard.Success();
result = reservationBase;
}
return(result);
}
private void LoadMailboxOwner(byte[] tenantPartitionHintBlob, string nonLocalizedAssistantName)
{
if (this.mailboxOwner == null)
{
this.InvokeAndMapException(delegate
{
ExTraceGlobals.EventDispatcherTracer.TraceDebug <MailboxDispatcher>((long)this.GetHashCode(), "{0}: Looking up ExchangePrincipal...", this);
ADSessionSettings adSettings;
if (tenantPartitionHintBlob != null && tenantPartitionHintBlob.Length != 0)
{
adSettings = ADSessionSettings.FromTenantPartitionHint(TenantPartitionHint.FromPersistablePartitionHint(tenantPartitionHintBlob));
}
else
{
adSettings = ADSessionSettings.FromRootOrgScopeSet();
}
this.mailboxOwner = ExchangePrincipal.FromLocalServerMailboxGuid(adSettings, this.DatabaseInfo.Guid, this.MailboxGuid);
}, nonLocalizedAssistantName);
}
}
public MoveJob(PropValue[] properties, Guid requestQueueGuid)
{
this.JobType = MapiUtils.GetValue <MRSJobType>(properties[9], MRSJobType.Unknown);
if (!RequestJobXML.IsKnownJobType(this.JobType))
{
MrsTracer.Service.Debug("Skipping unknown jobType {0}", new object[]
{
(int)this.JobType
});
return;
}
this.RequestGuid = MapiUtils.GetValue <Guid>(properties[26], Guid.Empty);
this.ExchangeGuid = MapiUtils.GetValue <Guid>(properties[5], Guid.Empty);
this.ArchiveGuid = MapiUtils.GetValue <Guid>(properties[6], Guid.Empty);
this.CancelRequest = MapiUtils.GetValue <bool>(properties[4], false);
this.MrsServerName = MapiUtils.GetValue <string>(properties[2], null);
this.Status = MapiUtils.GetValue <RequestStatus>(properties[0], RequestStatus.None);
this.JobState = MapiUtils.GetValue <JobProcessingState>(properties[1], JobProcessingState.NotReady);
this.LastUpdateTimeStamp = MapiUtils.GetValue <DateTime>(properties[7], DateTime.MinValue);
this.Flags = MapiUtils.GetValue <RequestFlags>(properties[10], RequestFlags.None);
this.SourceDatabaseGuid = MapiUtils.GetValue <Guid>(properties[11], Guid.Empty);
this.TargetDatabaseGuid = MapiUtils.GetValue <Guid>(properties[12], Guid.Empty);
this.SourceArchiveDatabaseGuid = MapiUtils.GetValue <Guid>(properties[15], Guid.Empty);
this.TargetArchiveDatabaseGuid = MapiUtils.GetValue <Guid>(properties[16], Guid.Empty);
this.Priority = MapiUtils.GetValue <int>(properties[17], -1);
this.DoNotPickUntilTimestamp = MapiUtils.GetValue <DateTime>(properties[13], DateTime.MinValue);
this.RequestType = MapiUtils.GetValue <MRSRequestType>(properties[14], MRSRequestType.Move);
this.MessageID = MapiUtils.GetValue <byte[]>(properties[27], null);
this.SourceExchangeGuid = MapiUtils.GetValue <Guid>(properties[18], Guid.Empty);
this.TargetExchangeGuid = MapiUtils.GetValue <Guid>(properties[19], Guid.Empty);
this.RehomeRequest = MapiUtils.GetValue <bool>(properties[20], false);
this.InternalFlags = MapiUtils.GetValue <RequestJobInternalFlags>(properties[21], RequestJobInternalFlags.None);
this.PoisonCount = MapiUtils.GetValue <int>(properties[23], 0);
this.FailureType = MapiUtils.GetValue <string>(properties[24], null);
this.WorkloadType = MapiUtils.GetValue <RequestWorkloadType>(properties[25], RequestWorkloadType.None);
byte[] value = MapiUtils.GetValue <byte[]>(properties[22], null);
this.PartitionHint = ((value != null && value.Length > 0) ? TenantPartitionHint.FromPersistablePartitionHint(value) : null);
this.RequestQueueGuid = requestQueueGuid;
this.IsActiveOnThisMRSInstance = MRSService.JobIsActive(this.RequestGuid);
this.isInteractive = MoveJob.IsInteractive(this.RequestType, this.WorkloadType);
}
public static byte[] ConvertTenantHint(byte[] originalSignature, MailboxSignatureFlags originalSignatureFlags, TenantPartitionHint tenantHint)
{
MailboxSignatureSectionsContainer mailboxSignatureSectionsContainer;
if (originalSignatureFlags == MailboxSignatureFlags.GetLegacy)
{
mailboxSignatureSectionsContainer = MailboxSignatureSectionsContainer.Create(MailboxSignatureSectionType.BasicInformation, new MailboxSignatureConverter.MailboxBasicInformationSectionCreator(originalSignature));
}
else
{
mailboxSignatureSectionsContainer = MailboxSignatureSectionsContainer.Parse(originalSignature, NullMailboxSignatureSectionProcessor.Instance);
}
if (tenantHint == null)
{
tenantHint = TenantPartitionHint.FromOrganizationId(OrganizationId.ForestWideOrgId);
}
byte[] persistablePartitionHint = tenantHint.GetPersistablePartitionHint();
int num = TenantHintHelper.SerializeTenantHint(persistablePartitionHint, null, 0);
byte[] array = new byte[num];
TenantHintHelper.SerializeTenantHint(persistablePartitionHint, array, 0);
mailboxSignatureSectionsContainer.UpdateSection(new MailboxSignatureSectionMetadata(MailboxSignatureSectionType.TenantHint, 1, 1, persistablePartitionHint.Length), array);
return(mailboxSignatureSectionsContainer.Serialize());
}
public TenantRelocationSyncData(OrganizationId sourceTenantOrganizationId, OrganizationId targetTenantOrganizationId, ADObjectId resourcePartitionRoot, TenantPartitionHint partitionHint, bool largeTenantModeEnabled)
{
if (targetTenantOrganizationId.ConfigurationUnit == null)
{
throw new ArgumentNullException("targetTenantConfigurationUnit");
}
ADObjectId domainId = sourceTenantOrganizationId.OrganizationalUnit.DomainId;
ADObjectId domainId2 = targetTenantOrganizationId.OrganizationalUnit.DomainId;
PartitionId partitionId = sourceTenantOrganizationId.OrganizationalUnit.GetPartitionId();
PartitionId partitionId2 = targetTenantOrganizationId.OrganizationalUnit.GetPartitionId();
this.Source = new TenantRelocationSyncPartitionData(sourceTenantOrganizationId, domainId, partitionId);
this.Target = new TenantRelocationSyncPartitionData(targetTenantOrganizationId, domainId2, partitionId2);
this.ResourcePartitionRoot = resourcePartitionRoot;
this.ResourcePartitionConfigNc = this.ResourcePartitionRoot.GetChildId("Configuration");
this.SourceTenantPartitionHint = partitionHint;
this.SourceConfigContainer = this.Source.TenantConfigurationUnit.Parent;
this.LargeTenantModeEnabled = largeTenantModeEnabled;
}
// Token: 0x06000024 RID: 36 RVA: 0x000030E0 File Offset: 0x000012E0
public void HandleEvent(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item)
{
MailboxTransportSubmissionAssistant.IdentifyProbeMessage(mapiEvent);
Thread currentThread = Thread.CurrentThread;
try
{
Interlocked.Increment(ref this.concurrentEvents);
this.SubmissionsInProgress[currentThread] = new SubmissionsInProgress.Entry(ExDateTime.UtcNow, this.databaseInfo.Guid, mapiEvent);
using (new SenderGuidTraceFilter(this.databaseInfo.Guid, mapiEvent.MailboxGuid))
{
bool flag = true;
MailboxTransportSubmissionAssistant.LatencyRecord latencyRecord;
LatencyTracker latencyTracker;
if (MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.TryGetValue(mapiEvent.EventCounter, out latencyRecord))
{
MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.Remove(mapiEvent.EventCounter);
latencyTracker = latencyRecord.LatencyTracker;
LatencyTracker.EndTrackLatency(latencyRecord.LatencyComponent, latencyTracker, true);
flag = false;
}
else
{
latencyTracker = LatencyTracker.CreateInstance(LatencyComponent.MailboxTransportSubmissionService);
LatencyTracker.TrackPreProcessLatency(LatencyComponent.SubmissionAssistant, latencyTracker, mapiEvent.CreateTime);
}
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker);
string text = this.FormatMapiEventInfo(mapiEvent);
this.LogMapiEventIntoCrimsonChannelPeriodically(text);
this.SubmissionsInProgress[Thread.CurrentThread].LatencyTracker = latencyTracker;
if (MailboxTransportSubmissionAssistant.ShouldLogNotifyEvents && (flag || MailboxTransportSubmissionAssistant.ShouldLogTemporaryFailures))
{
LatencyFormatter latencyFormatter = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, mapiEvent.CreateTime, mapiEvent.CreateTime, true, false, false);
MsgTrackMapiSubmitInfo msgTrackInfo = new MsgTrackMapiSubmitInfo(text, null, string.Empty, StoreDriverSubmission.LocalIPAddress, Components.Configuration.LocalServer.TransportServer.Name, string.Empty, string.Empty, MailboxTransportSubmissionAssistant.ItemEntryId(mapiEvent), latencyFormatter.FormatAndUpdatePerfCounters(), null, false, true);
MessageTrackingLog.TrackNotify(msgTrackInfo, false);
}
MSExchangeSubmission.PendingSubmissions.Increment();
new HashSet <string>();
DateTime createTime = mapiEvent.CreateTime;
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePfdPass <int, Guid, long>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "PFD EMS {0} SubmitMail for mailbox {1} at entry {2}", 22427, mapiEvent.MailboxGuid, mapiEvent.EventCounter);
LatencyFormatter latencyFormatter2 = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, createTime, createTime, false, true, false);
bool isPublicFolder = mapiEvent.ExtendedEventFlags.HasFlag(MapiExtendedEventFlags.PublicFolderMailbox);
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker);
ISubmissionProvider submissionProvider = (ISubmissionProvider)Components.StoreDriverSubmission;
MailSubmissionResult mailSubmissionResult = submissionProvider.SubmitMessage(Components.Configuration.LocalServer.TransportServer.ExchangeLegacyDN, mapiEvent.MailboxGuid, this.databaseInfo.Guid, this.databaseInfo.DatabaseName, mapiEvent.EventCounter, mapiEvent.ItemEntryId, mapiEvent.ParentEntryId, Components.Configuration.LocalServer.TransportServer.Fqdn, new IPAddress(StoreDriverSubmission.LocalIPAddress.GetAddressBytes()), mapiEvent.CreateTime, isPublicFolder, (mapiEvent.TenantHint == null) ? null : TenantPartitionHint.FromPersistablePartitionHint(mapiEvent.TenantHint), latencyFormatter2.FormatAndUpdatePerfCounters(), MailboxTransportSubmissionService.QuarantineHandler, MailboxTransportSubmissionService.SubmissionPoisonHandler, latencyTracker);
MailSubmissionResult result = mailSubmissionResult;
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker);
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker);
this.LogAndUpdateCounters(mapiEvent, latencyTracker, createTime, result);
this.HandleEventError(mapiEvent, result, latencyTracker, text);
}
}
finally
{
MSExchangeSubmission.PendingSubmissions.Decrement();
Interlocked.Decrement(ref this.concurrentEvents);
this.SubmissionsInProgress.Remove(currentThread);
}
}
public MailSubmissionResult SubmitMessage(string serverDN, Guid mailboxGuid, Guid mdbGuid, string databaseName, long eventCounter, byte[] entryId, byte[] parentEntryId, string serverFqdn, IPAddress networkAddressBytes, DateTime originalCreateTime, bool isPublicFolder, TenantPartitionHint tenantHint, string mailboxHopLatency, QuarantineHandler quarantineHandler, SubmissionPoisonHandler submissionPoisonHandler, LatencyTracker latencyTracker)
{
ArgumentValidator.ThrowIfNullOrEmpty("serverDN", serverDN);
ArgumentValidator.ThrowIfEmpty("mailboxGuid", mailboxGuid);
ArgumentValidator.ThrowIfEmpty("mdbGuid", mdbGuid);
ArgumentValidator.ThrowIfNullOrEmpty("databaseName", databaseName);
ArgumentValidator.ThrowIfNull("entryId", entryId);
ArgumentValidator.ThrowIfInvalidValue <int>("entryId", entryId.Length, (int value) => value > 0);
ArgumentValidator.ThrowIfNull("parentEntryId", parentEntryId);
ArgumentValidator.ThrowIfInvalidValue <int>("parentEntryId", parentEntryId.Length, (int value) => value > 0);
ArgumentValidator.ThrowIfNullOrEmpty("serverFqdn", serverFqdn);
ArgumentValidator.ThrowIfNull("networkAddressBytes", networkAddressBytes);
ArgumentValidator.ThrowIfNullOrEmpty("mailboxHopLatency", mailboxHopLatency);
ArgumentValidator.ThrowIfNull("quarantineHandler", quarantineHandler);
ArgumentValidator.ThrowIfNull("submissionPoisonHandler", submissionPoisonHandler);
bool shouldDeprioritize = false;
if (SubmissionConfiguration.Instance.App.SenderRateDeprioritizationEnabled)
{
long num = this.rateTrackerForDeprioritization.IncrementSenderRate(mailboxGuid, originalCreateTime);
if (num > (long)SubmissionConfiguration.Instance.App.SenderRateDeprioritizationThreshold)
{
shouldDeprioritize = true;
}
}
bool shouldThrottle = false;
if (SubmissionConfiguration.Instance.App.SenderRateThrottlingEnabled)
{
long num2 = this.rateTrackerForThrottling.IncrementSenderRate(mailboxGuid, originalCreateTime);
if (num2 > (long)SubmissionConfiguration.Instance.App.SenderRateThrottlingThreshold)
{
shouldThrottle = true;
this.rateTrackerForThrottling.ResetSenderRate(mailboxGuid, originalCreateTime);
}
}
MapiSubmissionInfo submissionInfo = new MapiSubmissionInfo(serverDN, mailboxGuid, entryId, parentEntryId, eventCounter, serverFqdn, networkAddressBytes, mdbGuid, databaseName, originalCreateTime, isPublicFolder, tenantHint, mailboxHopLatency, latencyTracker, shouldDeprioritize, shouldThrottle, this.storeDriverTracer);
return(this.SubmitMessageImpl(submissionInfo, submissionPoisonHandler, quarantineHandler));
}
public static DirectoryIdentity CreateMailboxIdentity(Guid guid, TenantPartitionHint tph, DirectoryObjectType objectType = DirectoryObjectType.Mailbox)
{
return(DirectoryIdentity.CreateMailboxIdentity(guid, TenantPartitionHintAdapter.FromPartitionHint(tph), objectType));
}
void IMailbox.Config(IReservation reservation, Guid primaryMailboxGuid, Guid physicalMailboxGuid, TenantPartitionHint partitionHint, Guid mdbGuid, MailboxType mbxType, Guid?mailboxContainerGuid)
{
throw new NotImplementedException();
}
internal static MailboxInformation Create(byte[] mailboxGuid, Guid databaseGuid, string displayName, ControlData controlData, PropValue[] mailboxProperties, DateTime lastLogonTime, TenantPartitionHint tenantPartitionHint = null)
{
MailboxInformation mailboxInformation = new MailboxInformation(new Guid(mailboxGuid), databaseGuid, displayName, true, lastLogonTime, tenantPartitionHint);
if (controlData != null)
{
mailboxInformation.LastProcessedDate = controlData.LastProcessedDate;
}
else
{
mailboxInformation.LastProcessedDate = DateTime.MinValue;
}
mailboxInformation.mailboxProperties = mailboxProperties;
mailboxInformation.MailboxData.IsPublicFolderMailbox = mailboxInformation.IsPublicFolderMailbox();
return(mailboxInformation);
}
private MailboxInformation(Guid mailboxGuid, Guid databaseGuid, string displayName, bool active, DateTime lastLogonTime, TenantPartitionHint tenantPartitionHint)
{
this.MailboxData = new StoreMailboxDataExtended(mailboxGuid, databaseGuid, displayName, null, tenantPartitionHint, this.IsArchiveMailbox(), this.IsGroupMailbox(), this.IsTeamSiteMailbox(), this.IsSharedMailbox());
this.Active = active;
this.LastLogonTime = lastLogonTime;
}
public MailboxDataForDemandJob(Guid mailboxGuid, Guid databaseGuid, OrganizationId organizationId, string parameters, TenantPartitionHint tenantPartitionHint) : base(mailboxGuid, databaseGuid, "(unknown)", organizationId, tenantPartitionHint)
{
this.Parameters = parameters;
}
public static TenantPartitionHintAdapter FromPartitionHint(TenantPartitionHint partitionHint)
{
return(new TenantPartitionHintAdapter(partitionHint.GetExternalDirectoryOrganizationId(), partitionHint.IsConsumer()));
}
protected override List <MailboxData> GetMailboxesForCurrentWindow(out int totalMailboxOnDatabaseCount, out int notInterestingMailboxCount, out int filteredMailboxCount, out int failedFilteringCount)
{
Guid activityId = Guid.NewGuid();
PropTag[] mailboxProperties = this.GetMailboxProperties();
PropValue[][] mailboxes = MailboxTableQuery.GetMailboxes("Client=TBA", base.DatabaseInfo, mailboxProperties);
totalMailboxOnDatabaseCount = ((mailboxes == null) ? 0 : mailboxes.Length);
notInterestingMailboxCount = 0;
filteredMailboxCount = 0;
failedFilteringCount = 0;
AssistantsLog.LogGetMailboxesQueryEvent(activityId, base.Assistant.NonLocalizedName, totalMailboxOnDatabaseCount, base.Assistant as AssistantBase);
if (mailboxes == null)
{
return(new List <MailboxData>());
}
List <MailboxInformation> list3 = new List <MailboxInformation>(mailboxes.Length);
Guid mailboxGuid = Guid.Empty;
VariantConfigurationSnapshot snapshot = VariantConfiguration.GetSnapshot(DatabaseSettingsContext.Get(base.DatabaseInfo.Guid), null, null);
TimeSpan notInterestingLogInterval = snapshot.MailboxAssistants.GetObject <IMailboxAssistantSettings>(base.AssistantType.Identifier, new object[0]).MailboxNotInterestingLogInterval;
int filteredMailboxCountLocal = 0;
int notInterestingMailboxCountLocal = 0;
string traceMessage;
foreach (PropValue[] propertiesForDelegateClosure2 in mailboxes)
{
try
{
PropValue[] propertiesForDelegateClosure = propertiesForDelegateClosure2;
List <MailboxInformation> list = list3;
base.CatchMeIfYouCan(delegate
{
PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.UserGuid);
PropValue mailboxProperty2 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.DisplayName);
string mailboxDisplayNameTracingOnlyUsage = (mailboxProperty2.IsNull() || mailboxProperty2.Value == null) ? string.Empty : mailboxProperty2.Value.ToString();
if (mailboxProperty.PropTag != PropTag.UserGuid || mailboxProperty2.PropTag != PropTag.DisplayName)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNoGuidFilter, MailboxSlaFilterReasonType.NoGuid, new object[]
{
mailboxProperty.Value
});
filteredMailboxCountLocal++;
return;
}
byte[] bytes = mailboxProperty.GetBytes();
if (bytes != null && bytes.Length == 16)
{
mailboxGuid = new Guid(bytes);
}
if (MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.DateDiscoveredAbsentInDS).PropTag == PropTag.DateDiscoveredAbsentInDS)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNotInDirectoryFilter, MailboxSlaFilterReasonType.NotInDirectory, new object[0]);
filteredMailboxCountLocal++;
return;
}
PropValue mailboxProperty3 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.MailboxMiscFlags);
MailboxMiscFlags @int = (MailboxMiscFlags)mailboxProperty3.GetInt(0);
if ((@int & MailboxMiscFlags.CreatedByMove) == MailboxMiscFlags.CreatedByMove)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxMoveDestinationFilter, MailboxSlaFilterReasonType.MoveDestination, new object[0]);
filteredMailboxCountLocal++;
return;
}
MailboxMiscFlags mailboxMiscFlags = @int & (MailboxMiscFlags.DisabledMailbox | MailboxMiscFlags.SoftDeletedMailbox | MailboxMiscFlags.MRSSoftDeletedMailbox);
if (mailboxMiscFlags != MailboxMiscFlags.None)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxInaccessibleFilter, MailboxSlaFilterReasonType.Inaccessible, new object[]
{
mailboxMiscFlags
});
filteredMailboxCountLocal++;
return;
}
IMailboxFilter mailboxFilter = this.AssistantType as IMailboxFilter;
if (mailboxFilter != null && mailboxProperty3.PropTag == PropTag.MailboxMiscFlags)
{
MailboxMiscFlags int2 = (MailboxMiscFlags)mailboxProperty3.GetInt();
bool flag = (int2 & MailboxMiscFlags.ArchiveMailbox) == MailboxMiscFlags.ArchiveMailbox;
if (flag && !mailboxFilter.MailboxType.Contains(MailboxType.Archive))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxArchiveFilter, MailboxSlaFilterReasonType.Archive, new object[0]);
filteredMailboxCountLocal++;
return;
}
}
ControlData controlData = ControlData.Empty;
if (this.AssistantType.ControlDataPropertyDefinition != null)
{
PropValue mailboxProperty4 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, (PropTag)this.AssistantType.ControlDataPropertyDefinition.PropertyTag);
if (mailboxProperty4.PropTag == (PropTag)this.AssistantType.ControlDataPropertyDefinition.PropertyTag)
{
controlData = ControlData.CreateFromByteArray(mailboxProperty4.GetBytes());
}
}
TenantPartitionHint tenantPartitionHint = null;
PropValue mailboxProperty5 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.PersistableTenantPartitionHint);
if (mailboxProperty5.PropTag == PropTag.PersistableTenantPartitionHint)
{
byte[] bytes2 = mailboxProperty5.GetBytes();
if (bytes2 != null && bytes2.Length != 0)
{
tenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(bytes2);
}
}
MailboxInformation mailboxInformation2 = MailboxInformation.Create(mailboxProperty.GetBytes(), this.DatabaseInfo.Guid, mailboxProperty2.GetString(), controlData, propertiesForDelegateClosure, MailboxInformation.GetLastLogonTime(propertiesForDelegateClosure), tenantPartitionHint);
if (!this.DatabaseInfo.IsUserMailbox(mailboxInformation2.MailboxGuid))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNotUserFilter, MailboxSlaFilterReasonType.NotUser, new object[0]);
filteredMailboxCountLocal++;
return;
}
if (mailboxInformation2.MailboxData.IsPublicFolderMailbox && (mailboxFilter == null || !mailboxFilter.MailboxType.Contains(MailboxType.PublicFolder)))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxPublicFolderFilter, MailboxSlaFilterReasonType.PublicFolder, new object[0]);
filteredMailboxCountLocal++;
return;
}
if (this.IsMailboxInDemandJob(mailboxInformation2.MailboxData))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxInDemandJobFilter, MailboxSlaFilterReasonType.InDemandJob, new object[0]);
filteredMailboxCountLocal++;
return;
}
if (this.AssistantType.MailboxExtendedProperties != null)
{
if (!this.AssistantType.IsMailboxInteresting(mailboxInformation2))
{
traceMessage = string.Format("{0}: {1} is not interesting for the assistant {2}.", this, mailboxGuid, this.Assistant.NonLocalizedName);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
DateTime utcNow = DateTime.UtcNow;
if (!this.notInterestingEventsLastLogDateTimes.ContainsKey(this.Assistant.NonLocalizedName) || utcNow - this.notInterestingEventsLastLogDateTimes[this.Assistant.NonLocalizedName] >= notInterestingLogInterval)
{
AssistantsLog.LogMailboxNotInterestingEvent(activityId, this.Assistant.NonLocalizedName, this.Assistant as AssistantBase, mailboxGuid, mailboxDisplayNameTracingOnlyUsage);
this.notInterestingEventsLastLogDateTimes[this.Assistant.NonLocalizedName] = utcNow;
}
notInterestingMailboxCountLocal++;
return;
}
}
else
{
traceMessage = string.Format("{0}: {1} mailbox properties are null, IsMailboxInteresting was not called.", this, mailboxGuid);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
}
traceMessage = string.Format("{0}: {1} is interesting for the assistant {2}.", this, mailboxGuid, this.Assistant.NonLocalizedName);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
AssistantsLog.LogMailboxInterestingEvent(activityId, this.Assistant.NonLocalizedName, this.Assistant as AssistantBase, null, mailboxGuid, mailboxDisplayNameTracingOnlyUsage);
list.Add(mailboxInformation2);
}, base.AssistantType.NonLocalizedName);
}
catch (AIException exception)
{
failedFilteringCount++;
AssistantsLog.LogErrorEnumeratingMailboxes(base.Assistant, mailboxGuid, exception, true);
}
catch (Exception exception2)
{
AssistantsLog.LogErrorEnumeratingMailboxes(base.Assistant, mailboxGuid, exception2, false);
throw;
}
}
traceMessage = string.Format("{0}: {1} mailboxes after filtering", this, list3.Count);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
if (this.firstIteration || base.AssistantType.WorkCycleCheckpoint < base.AssistantType.WorkCycle)
{
int count = list3.Count;
list3 = list3.FindAll((MailboxInformation mailbox) => DateTime.UtcNow - mailbox.LastProcessedDate > base.AssistantType.WorkCycle - base.AssistantType.WorkCycleCheckpoint);
this.firstIteration = false;
filteredMailboxCountLocal += count - list3.Count;
}
list3.Sort((MailboxInformation m1, MailboxInformation m2) => m1.LastProcessedDate.CompareTo(m2.LastProcessedDate));
List <MailboxData> list2 = new List <MailboxData>();
foreach (MailboxInformation mailboxInformation in list3)
{
list2.Add(mailboxInformation.MailboxData);
}
AssistantsLog.LogEndGetMailboxesEvent(activityId, base.Assistant.NonLocalizedName, list2.Count, base.Assistant as AssistantBase);
filteredMailboxCount = filteredMailboxCountLocal;
notInterestingMailboxCount = notInterestingMailboxCountLocal;
return(list2);
}
public static RemoteReservation Create(string serverFQDN, NetworkCredential credentials, Guid mailboxGuid, TenantPartitionHint partitionHint, Guid mdbGuid, ReservationFlags flags)
{
RemoteReservation result;
using (MailboxReplicationProxyClient mailboxReplicationProxyClient = MailboxReplicationProxyClient.CreateWithoutThrottling(serverFQDN, credentials, mailboxGuid, mdbGuid))
{
Guid reservationID;
if (mailboxReplicationProxyClient.ServerVersion[37])
{
byte[] partitionHintBytes = (partitionHint != null) ? partitionHint.GetPersistablePartitionHint() : null;
reservationID = ((IMailboxReplicationProxyService)mailboxReplicationProxyClient).IReservationManager_ReserveResources(mailboxGuid, partitionHintBytes, mdbGuid, (int)flags);
}
else if (mailboxReplicationProxyClient.ServerVersion[28])
{
reservationID = Guid.NewGuid();
LegacyReservationStatus legacyReservationStatus = (LegacyReservationStatus)((IMailboxReplicationProxyService)mailboxReplicationProxyClient).IMailbox_ReserveResources(reservationID, mdbGuid, (int)RemoteReservation.ConvertReservationFlagsToLegacy(flags, true));
if (legacyReservationStatus != LegacyReservationStatus.Success)
{
throw new CapacityExceededReservationException(string.Format("{0}:{1}:{2}", serverFQDN, mdbGuid, flags), 1);
}
}
else
{
reservationID = RemoteReservation.DownlevelReservationId;
}
result = new RemoteReservation(reservationID, serverFQDN, credentials, mailboxGuid, mdbGuid, flags);
}
return(result);
}
