protected override void ProcessRequest()
{
string text = string.Format("MsExchMlb:Band:{0:yyyyMMddhhmm}", ExDateTime.UtcNow);
using (OperationTracker.Create(this.logger, "Rebalancing forest with StartMoves={0}, using LoadBalancer={1}, BatchName={2}", new object[]
{
this.startMoves,
this.loadBalancer,
text
}))
{
List <BandMailboxRebalanceData> list = new List <BandMailboxRebalanceData>();
foreach (LoadPartition loadPartition in this.partitionExtractor.GetPartitions(this.forestTopology))
{
this.logger.LogInformation("Load balancing partition for MailboxProvisioningConstraint \"{0}\"", new object[]
{
loadPartition.ConstraintSetIdentity
});
IEnumerable <BandMailboxRebalanceData> enumerable = this.loadBalancer.BalanceForest(loadPartition.Root);
foreach (BandMailboxRebalanceData bandMailboxRebalanceData in enumerable)
{
bandMailboxRebalanceData.RebalanceBatchName = text;
bandMailboxRebalanceData.ConstraintSetIdentity = loadPartition.ConstraintSetIdentity;
list.Add(bandMailboxRebalanceData);
if (this.startMoves)
{
this.moveStarter.ProcessRebalanceRequest(bandMailboxRebalanceData);
}
}
}
this.Results = list;
}
}
protected virtual IAnchorRunspaceProxy GetRunspace()
{
IAnchorRunspaceProxy result;
using (OperationTracker.Create(this.anchorContext.Logger, "Creating a new runspace.", new object[0]))
{
result = AnchorRunspaceProxy.CreateRunspaceForDatacenterAdmin(this.anchorContext, "Mailbox Load Balance");
}
return(result);
}
protected override void ProcessRequest()
{
using (OperationTracker.Create(this.logger, "Applying processor {0} to mailbox {1}.", new object[]
{
this.Processor.GetType().FullName,
this.Mailbox.Identity
}))
{
using (RunspaceReservation runspaceReservation = this.cmdletPool.AcquireRunspace())
{
this.Processor.ProcessMailbox(this.Mailbox, runspaceReservation.Runspace);
}
}
}
protected override void ProcessRequest()
{
using (OperationTracker.Create(this.logger, "Rebalancing {0} from {1} to {2}.", new object[]
{
this.rebalanceData.RebalanceInformation,
this.rebalanceData.SourceDatabase,
this.rebalanceData.TargetDatabase
}))
{
this.logger.Log(MigrationEventType.Information, "MOVE: Moving {0} from {1} to {2}.", new object[]
{
this.rebalanceData.RebalanceInformation,
this.rebalanceData.SourceDatabase,
this.rebalanceData.TargetDatabase
});
Band[] bands = this.rebalanceData.RebalanceInformation.Metrics.OfType <Band>().ToArray <Band>();
TopologyExtractorFactory entitySelectorFactory = this.serviceContext.TopologyExtractorFactoryContextPool.GetContext(this.clientFactory, bands, this.nonMovableOrgs, this.logger).GetEntitySelectorFactory();
DirectoryDatabase database = this.directoryProvider.GetDatabase(this.rebalanceData.SourceDatabase.Guid);
LoadContainer container = entitySelectorFactory.GetExtractor(database).ExtractTopology();
IOperationRetryManager operationRetryManager = LoadBalanceOperationRetryManager.Create(this.logger);
foreach (LoadMetric loadMetric in this.rebalanceData.RebalanceInformation.Metrics)
{
EntitySelector selector = loadMetric.GetSelector(container, this.rebalanceData.ConstraintSetIdentity, this.rebalanceData.RebalanceInformation[loadMetric]);
if (selector.IsEmpty)
{
this.logger.Log(MigrationEventType.Information, "Could not find any mailbox for metric {0} in database {1}.", new object[]
{
loadMetric,
this.rebalanceData.SourceDatabase
});
}
else
{
this.logger.Log(MigrationEventType.Information, "Found mailboxes matching the metric {0} in database {1}. Requesting the injections.", new object[]
{
loadMetric,
this.rebalanceData.SourceDatabase
});
operationRetryManager.TryRun(delegate
{
DirectoryDatabase database2 = (DirectoryDatabase)this.directoryProvider.GetDirectoryObject(this.rebalanceData.TargetDatabase.DirectoryObjectIdentity);
using (IInjectorService injectorClientForDatabase = this.clientFactory.GetInjectorClientForDatabase(database2))
{
injectorClientForDatabase.InjectMoves(this.rebalanceData.TargetDatabase.Guid, this.rebalanceData.RebalanceBatchName, selector.GetEntities(this.rebalanceData.TargetDatabase));
}
});
}
}
}
}
private void RefreshCachedValue()
{
using (OperationTracker.Create(this.logger, "Refreshing topology for {0}.", new object[]
{
this.directoryObject
}))
{
this.cachedValue = this.topologyExtractor.ExtractTopology();
ExAssert.RetailAssert(this.cachedValue != null, "ExtractTopology for directoryObject: {0} should never return null. TopologyExtractor: {1}", new object[]
{
this.directoryObject,
this.topologyExtractor
});
}
}
private IPhysicalMailbox LoadMailboxData()
{
IPhysicalMailbox result;
using (OperationTracker.Create(this.logger, "Retrieving single mailbox {0} data from database {1}", new object[]
{
this.Guid,
this.database.Identity
}))
{
using (IPhysicalDatabase physicalDatabaseConnection = this.clientFactory.GetPhysicalDatabaseConnection(this.database))
{
result = (physicalDatabaseConnection.GetMailbox(this.Guid) ?? EmptyPhysicalMailbox.Instance);
}
}
return(result);
}
private void BeginProcessingMailbox(DirectoryMailbox mailbox)
{
IRequestQueue requestQueue = (mailbox.Parent != null) ? this.context.QueueManager.GetProcessingQueue(mailbox.Parent) : this.context.QueueManager.MainProcessingQueue;
string[] source = LoadBalanceADSettings.Instance.Value.ExcludedMailboxProcessors.Split(new char[]
{
','
});
IList <MailboxProcessor> list = this.processors(this.context.QueueManager) ?? ((IList <MailboxProcessor>)Array <MailboxProcessor> .Empty);
foreach (MailboxProcessor mailboxProcessor in list)
{
if (source.Contains(mailboxProcessor.Name))
{
this.context.Logger.LogVerbose("Skipping processor {0} because it is disabled.", new object[]
{
mailboxProcessor.Name
});
}
else if (!mailboxProcessor.ShouldProcess(mailbox))
{
this.context.Logger.LogVerbose("Processor {0} doesn't want to process the mailbox, ignored.", new object[]
{
mailboxProcessor.Name
});
}
else if (mailboxProcessor.RequiresRunspace)
{
requestQueue.EnqueueRequest(new ProcessMailboxRequest(mailbox, mailboxProcessor, this.context.Logger, this.context.CmdletPool));
}
else
{
using (OperationTracker.Create(this.context.Logger, "Applying processor {0} to mailbox {1}.", new object[]
{
mailboxProcessor.GetType().FullName,
mailbox.Identity
}))
{
mailboxProcessor.ProcessMailbox(mailbox, null);
}
}
}
}
protected override void ProcessRequest()
{
this.logger.LogInformation("Starting to drain database {0} with batch name {1}.", new object[]
{
this.directoryDatabase.Identity,
this.batchName
});
IOperationRetryManager operationRetryManager = LoadBalanceOperationRetryManager.Create(this.logger);
using (OperationTracker.Create(this.logger, "Moving mailboxes out of {0}.", new object[]
{
this.directoryDatabase.Identity
}))
{
foreach (DirectoryMailbox mailboxToMove2 in this.directoryDatabase.GetMailboxes())
{
DirectoryMailbox mailboxToMove = mailboxToMove2;
operationRetryManager.TryRun(delegate
{
this.moveInjector.InjectMoveForMailbox(mailboxToMove, this.batchName);
});
}
}
this.logger.LogInformation("Draining database {0}: Cleaning soft deleted mailboxes.", new object[]
{
this.directoryDatabase.Identity
});
using (OperationTracker.Create(this.logger, "Starting soft deleted cleanup for {0}.", new object[]
{
this.directoryDatabase.Identity
}))
{
this.serviceContext.CleanupSoftDeletedMailboxesOnDatabase(this.directoryDatabase.Identity, ByteQuantifiedSize.Zero);
}
this.logger.LogInformation("Finished processing the draining of database {0}.", new object[]
{
this.directoryDatabase.Identity
});
if (this.OnDrainFinished != null)
{
this.OnDrainFinished(this.directoryDatabase);
}
}
private void PopulateDirectoryObjectFromIdentity(LoadEntity entity)
{
using (OperationTracker.Create(this.logger, "Re-hydrating directory object of type {0} on load entity.", new object[]
{
entity.DirectoryObjectIdentity.ObjectType
}))
{
if (entity.DirectoryObjectIdentity != null)
{
try
{
entity.DirectoryObject = this.directory.GetDirectoryObject(entity.DirectoryObjectIdentity);
}
catch (LocalizedException exception)
{
this.logger.LogError(exception, "Failed to rehydrate object with identity '{0}'.", new object[]
{
entity.DirectoryObjectIdentity
});
}
}
}
}
public MailboxProvisioningResult GetDatabase(MailboxProvisioningData provisioningData)
{
MailboxProvisioningResult result;
using (OperationTracker.Create(this.logger, "Selecting database for '{0}' using {1}.", new object[]
{
provisioningData,
base.GetType().Name
}))
{
MailboxProvisioningResult mailboxProvisioningResult = new MailboxProvisioningResult
{
Status = MailboxProvisioningResultStatus.ConstraintCouldNotBeSatisfied,
MailboxProvisioningConstraints = provisioningData.MailboxProvisioningConstraints
};
IMailboxProvisioningConstraints provisioningConstraint = provisioningData.MailboxProvisioningConstraints ?? new MailboxProvisioningConstraints();
IEnumerable <LoadContainer> databasesMatchingConstraint = this.GetDatabasesMatchingConstraint(provisioningConstraint);
List <LoadContainer> list = new List <LoadContainer>(300);
foreach (LoadContainer loadContainer in databasesMatchingConstraint)
{
mailboxProvisioningResult.Status = MailboxProvisioningResultStatus.InsufficientCapacity;
LoadMetric loadMetric;
long num;
long num2;
if (!loadContainer.CanAcceptRegularLoad)
{
this.logger.Log(MigrationEventType.Instrumentation, "Database '{0}' cannot accept regular load, skipping.", new object[]
{
loadContainer.DirectoryObjectIdentity
});
}
else if (!loadContainer.AvailableCapacity.SupportsAdditional(provisioningData.ConsumedLoad, out loadMetric, out num, out num2))
{
this.logger.Log(MigrationEventType.Instrumentation, "Database '{0}' does not have sufficient capacity for the provisioning request. The {1} requested units of {2} would exceed the {3} available. Skipped.", new object[]
{
loadContainer.DirectoryObjectIdentity,
num,
loadMetric,
num2
});
}
else
{
list.Add(loadContainer);
}
}
if (list.Any <LoadContainer>())
{
LoadContainer loadContainer2 = list[new Random().Next(0, list.Count)];
mailboxProvisioningResult.Status = MailboxProvisioningResultStatus.Valid;
mailboxProvisioningResult.Database = loadContainer2.DirectoryObjectIdentity;
loadContainer2.CommittedLoad += provisioningData.ConsumedLoad;
this.logger.Log(MigrationEventType.Instrumentation, "Selected database {0} with {1} max, {2} consumed and {3} available.", new object[]
{
loadContainer2.DirectoryObjectIdentity,
loadContainer2.MaximumLoad,
loadContainer2.ConsumedLoad,
loadContainer2.AvailableCapacity
});
}
result = mailboxProvisioningResult;
}
return(result);
}
