public override void ProcessMailbox(DirectoryMailbox mailbox, IAnchorRunspaceProxy runspace)
{
DirectoryDatabase directoryDatabase = (DirectoryDatabase)mailbox.Parent;
IMailboxPolicy violatedPolicy = this.GetViolatedPolicy(mailbox, directoryDatabase);
if (violatedPolicy == null)
{
return;
}
MoveInfo info = this.getMoveInfo.GetInfo(mailbox, runspace);
ProvisioningConstraintFixStateLog.Write(mailbox, directoryDatabase, info);
switch (info.Status)
{
case MoveStatus.MoveExistsNotInProgress:
violatedPolicy.HandleExistingButNotInProgressMove(mailbox, directoryDatabase);
return;
case MoveStatus.MoveExistsInProgress:
break;
case MoveStatus.MoveDoesNotExist:
this.InjectMoveRequest(mailbox, violatedPolicy);
break;
default:
return;
}
}
public SoftDeletedMailboxRemover(DirectoryDatabase database, LoadBalanceAnchorContext context, ByteQuantifiedSize targetDatabaseSize, ObjectLogCollector logCollector)
{
this.database = database;
this.context = context;
this.targetDatabaseSize = targetDatabaseSize;
this.logCollector = logCollector;
}
private TClient GetClient <TClient>(DirectoryDatabase database, bool allowFallback, Func <DirectoryServer, IDirectoryProvider, TClient> factory, Func <DirectoryServer, TClient> fallbackClientFactory) where TClient : class
{
EndpointNotFoundTransientException ex = null;
foreach (DirectoryServer directoryServer in database.ActivationOrder)
{
try
{
return(this.GetClient <TClient>(directoryServer, false, factory, null));
}
catch (EndpointNotFoundTransientException)
{
this.logger.Log(MigrationEventType.Verbose, "Failed to establish a {0} client to '{1}'..", new object[]
{
typeof(TClient).Name,
directoryServer.Name
});
}
}
if (!allowFallback && ex != null)
{
throw new EndpointNotFoundTransientException(ex.ServiceURI, ex.LocalizedString, ex);
}
this.logger.Log(MigrationEventType.Warning, "Failed to establish a {0} client to the preferred servers for database '{1}'. Falling back to local.", new object[]
{
typeof(TClient).Name,
database.Name
});
return(fallbackClientFactory(database.ActivationOrder.First <DirectoryServer>()));
}
public DatabaseSizeInfo GetDatabaseSize(DirectoryDatabase database)
{
DatabaseSizeInfo result;
using (ExRpcAdmin exRpcAdminForDatabase = this.GetExRpcAdminForDatabase(database))
{
ulong bytesValue;
ulong bytesValue2;
exRpcAdminForDatabase.GetDatabaseSize(database.Guid, out bytesValue, out bytesValue2);
ByteQuantifiedSize byteQuantifiedSize = ByteQuantifiedSize.FromBytes(bytesValue);
ByteQuantifiedSize byteQuantifiedSize2 = ByteQuantifiedSize.FromBytes(bytesValue2);
if (byteQuantifiedSize2 > byteQuantifiedSize)
{
this.logger.LogWarning("Database {0} has more free space ({1}) than its total size ({2}), assuming sparse EDB file with no free pages.", new object[]
{
database.Name,
byteQuantifiedSize2,
byteQuantifiedSize
});
byteQuantifiedSize2 = ByteQuantifiedSize.Zero;
}
result = new DatabaseSizeInfo
{
AvailableWhitespace = byteQuantifiedSize2,
CurrentPhysicalSize = byteQuantifiedSize
};
}
return(result);
}
private ExRpcAdmin GetExRpcAdminForDatabase(DirectoryDatabase database)
{
ActiveManager activeManager = LoadBalanceADSettings.Instance.Value.UseCachingActiveManager ? ActiveManager.GetCachingActiveManagerInstance() : ActiveManager.GetNoncachingActiveManagerInstance();
DatabaseLocationInfo serverForDatabase = activeManager.GetServerForDatabase(database.Guid, true);
return(ExRpcAdmin.Create("Client=MSExchangeMailboxLoadBalance", serverForDatabase.ServerFqdn, null, null, null));
}
protected override LoadContainer BuildTopology(TopologyExtractorFactoryContext topologyExtractorContext)
{
TopologyExtractorFactory loadBalancingLocalFactory = topologyExtractorContext.GetLoadBalancingLocalFactory(false);
DirectoryServer localServer = base.ServiceContext.Directory.GetLocalServer();
TopologyExtractor extractor = loadBalancingLocalFactory.GetExtractor(localServer);
LoadContainer loadContainer = extractor.ExtractTopology();
ExAssert.RetailAssert(loadContainer != null, "Extracted toplogy for server '{0}' should never be null.", new object[]
{
localServer
});
DatabaseCollector databaseCollector = new DatabaseCollector();
loadContainer.Accept(databaseCollector);
IOperationRetryManager operationRetryManager = LoadBalanceOperationRetryManager.Create(1, TimeSpan.Zero, base.ServiceContext.Logger);
foreach (LoadContainer loadContainer2 in databaseCollector.Databases)
{
DirectoryDatabase directoryDatabase = loadContainer2.DirectoryObject as DirectoryDatabase;
if (directoryDatabase != null)
{
DatabaseProcessor @object = new DatabaseProcessor(base.ServiceContext.Settings, base.ServiceContext.DrainControl, base.ServiceContext.Logger, directoryDatabase);
operationRetryManager.TryRun(new Action(@object.ProcessDatabase));
}
}
return(loadContainer);
}
private void ExtractConstraintSetHierarchy(LoadContainer databaseContainer)
{
DirectoryDatabase directoryDatabase = (DirectoryDatabase)base.DirectoryObject;
Dictionary <string, LoadContainer> dictionary = new Dictionary <string, LoadContainer>();
foreach (DirectoryMailbox directoryMailbox in directoryDatabase.GetMailboxes())
{
TopologyExtractor extractor = base.ExtractorFactory.GetExtractor(directoryMailbox);
IMailboxProvisioningConstraints mailboxProvisioningConstraints = directoryMailbox.MailboxProvisioningConstraints;
string text = null;
if (mailboxProvisioningConstraints != null)
{
text = mailboxProvisioningConstraints.HardConstraint.Value;
}
text = (text ?? string.Empty);
if (!dictionary.ContainsKey(text))
{
DirectoryIdentity identity = new DirectoryIdentity(DirectoryObjectType.ConstraintSet, Guid.NewGuid(), text, directoryMailbox.Identity.OrganizationId);
DirectoryObject directoryObject = new DirectoryObject(base.DirectoryObject.Directory, identity);
LoadContainer value = new LoadContainer(directoryObject, ContainerType.ConstraintSet);
dictionary.Add(text, value);
databaseContainer.AddChild(dictionary[text]);
}
LoadEntity extractedEntity = extractor.ExtractEntity();
this.AddEntityToContainer(dictionary[text], extractedEntity);
}
}
public IEnumerable <DirectoryDatabase> GetDatabasesOwnedByServer(DirectoryServer server)
{
IOperationRetryManager retryManager = LoadBalanceOperationRetryManager.Create(this.logger);
foreach (MailboxDatabase database in this.ConfigurationSession.GetDatabasesOnServer(server.Identity))
{
DirectoryDatabase result = null;
MailboxDatabase databaseCopy = database;
OperationRetryManagerResult operationResult = retryManager.TryRun(delegate
{
result = this.DirectoryDatabaseFromDatabase(databaseCopy);
});
if (!operationResult.Succeeded)
{
this.logger.LogError(operationResult.Exception, "Could not retrieve database {0} for server {1}.", new object[]
{
databaseCopy.Name,
server.Name
});
}
else if (result != null)
{
yield return(result);
}
}
yield break;
}
public LoadContainer GetDatabaseData(Guid databaseGuid, bool includeMailboxes)
{
TopologyExtractorFactoryContext topologyExtractorFactoryContext = this.serviceContext.GetTopologyExtractorFactoryContext();
TopologyExtractorFactory topologyExtractorFactory = includeMailboxes ? topologyExtractorFactoryContext.GetEntitySelectorFactory() : topologyExtractorFactoryContext.GetLoadBalancingLocalFactory(false);
DirectoryDatabase database = this.serviceContext.Directory.GetDatabase(databaseGuid);
return(topologyExtractorFactory.GetExtractor(database).ExtractTopology());
}
private void RequestRebalancingOnRemoteServer()
{
DirectoryDatabase database = (DirectoryDatabase)this.rebalanceRequest.SourceDatabase.DirectoryObject;
using (ILoadBalanceService loadBalanceClientForDatabase = this.clientFactory.GetLoadBalanceClientForDatabase(database))
{
loadBalanceClientForDatabase.BeginMailboxMove(this.rebalanceRequest, PhysicalSize.Instance);
}
}
private DirectoryDatabase DirectoryDatabaseFromDatabase(MailboxDatabase database)
{
bool isExcludedFromProvisioning = (bool)database[MailboxDatabaseSchema.IsExcludedFromProvisioning];
bool isExcludedFromInitialProvisioning = (bool)database[MailboxDatabaseSchema.IsExcludedFromInitialProvisioning];
DirectoryIdentity identity = DirectoryIdentity.CreateFromADObjectId(database.Id, DirectoryObjectType.Database);
DirectoryDatabase directoryDatabase = new DirectoryDatabase(this, identity, this.clientFactory, isExcludedFromProvisioning, isExcludedFromInitialProvisioning, database.MailboxProvisioningAttributes);
this.ApplyLoadBalanceSettingValuesToDatabase(database, directoryDatabase);
return(directoryDatabase);
}
private LoadContainer GetDatabaseContainer()
{
DirectoryDatabase database = this.context.Directory.GetDatabase(base.Arguments.DatabaseGuid);
if (database == null)
{
throw new DatabaseNotFoundPermanentException(base.Arguments.DatabaseGuid.ToString());
}
return(this.GetTopologyForDirectoryObject(database));
}
public override DatabaseSizeInfo GetDatabaseSizeInformation(DirectoryDatabase database)
{
DatabaseSizeInfo databaseSpaceData;
using (IPhysicalDatabase physicalDatabaseConnection = this.serviceContext.ClientFactory.GetPhysicalDatabaseConnection(database))
{
databaseSpaceData = physicalDatabaseConnection.GetDatabaseSpaceData();
}
return(databaseSpaceData);
}
public IEnumerable <NonConnectedMailbox> GetDisconnectedMailboxesForDatabase(DirectoryDatabase database)
{
using (IPhysicalDatabase physicalDatabase = this.clientFactory.GetPhysicalDatabaseConnection(database))
{
foreach (NonConnectedMailbox disconnectedMailbox in this.GetDisconnectedMailboxesForDatabaseInternal(database, physicalDatabase))
{
yield return(disconnectedMailbox);
}
}
yield break;
}
public IRequestQueue GetInjectionQueue(DirectoryDatabase database)
{
RequestQueue requestQueue;
if (!this.injectionQueues.TryGetValue(database.Guid, out requestQueue))
{
InjectionQueueCounters counters = new InjectionQueueCounters(database.Name);
RequestQueue value = new RequestQueue(database.Guid, counters);
this.injectionQueues.TryAdd(database.Guid, value);
}
return(this.injectionQueues[database.Guid]);
}
protected IEnumerable <LoadContainer> GetDatabasesMatchingConstraint(IMailboxProvisioningConstraints provisioningConstraint)
{
foreach (LoadContainer container in this.GetAvailableDatabases())
{
DirectoryDatabase database = container.DirectoryObject as DirectoryDatabase;
if (database != null && provisioningConstraint.IsMatch(database.MailboxProvisioningAttributes))
{
yield return(container);
}
}
yield break;
}
public IEnumerable <MailboxTableEntry> GetMailboxTable(DirectoryDatabase database, Guid mailboxGuid, PropTag[] propertiesToLoad)
{
IEnumerable <MailboxTableEntry> result;
using (ExRpcAdmin exRpcAdminForDatabase = this.GetExRpcAdminForDatabase(database))
{
PropTag[] propTagsRequested = propertiesToLoad ?? MailboxTablePropertyDefinitions.MailboxTablePropertiesToLoad;
PropValue[][] mailboxTableInfo = exRpcAdminForDatabase.GetMailboxTableInfo(database.Guid, mailboxGuid, MailboxTableFlags.IncludeSoftDeletedMailbox, propTagsRequested);
result = mailboxTableInfo.Select(new Func <PropValue[], MailboxTableEntry>(MailboxTableEntry.FromValues));
}
return(result);
}
public static void Write(DirectoryMailbox mailbox, DirectoryDatabase sourceDatabase, MoveInfo moveInfo)
{
ProvisioningConstraintFixStateLogEntry provisioningConstraintFixStateLogEntry = new ProvisioningConstraintFixStateLogEntry();
provisioningConstraintFixStateLogEntry.MailboxGuid = mailbox.Guid;
provisioningConstraintFixStateLogEntry.MailboxProvisioningHardConstraint = mailbox.MailboxProvisioningConstraints.HardConstraint;
provisioningConstraintFixStateLogEntry.SourceDatabaseGuid = sourceDatabase.Guid;
provisioningConstraintFixStateLogEntry.SourceDatabaseProvisioningAttributes = sourceDatabase.MailboxProvisioningAttributes;
provisioningConstraintFixStateLogEntry.ExistingMoveStatus = moveInfo.Status;
provisioningConstraintFixStateLogEntry.ExistingMoveRequestGuid = moveInfo.MoveRequestGuid;
ProvisioningConstraintFixStateLog.Instance.LogObject(provisioningConstraintFixStateLogEntry);
}
public DatabaseDrainRequest(DirectoryDatabase directoryDatabase, MoveInjector moveInjector, LoadBalanceAnchorContext serviceContext, BatchName batchName)
{
AnchorUtil.ThrowOnNullArgument(directoryDatabase, "directoryDatabase");
AnchorUtil.ThrowOnNullArgument(moveInjector, "moveInjector");
AnchorUtil.ThrowOnNullArgument(serviceContext, "serviceContext");
AnchorUtil.ThrowOnNullArgument(batchName, "batchName");
this.directoryDatabase = directoryDatabase;
this.moveInjector = moveInjector;
this.serviceContext = serviceContext;
this.logger = serviceContext.Logger;
this.batchName = batchName;
}
private LoadContainer CreateDatabaseContainer()
{
DirectoryDatabase directoryDatabase = (DirectoryDatabase)base.DirectoryObject;
LoadContainer loadContainer = directoryDatabase.ToLoadContainer();
loadContainer.Constraint = new AllAcceptConstraint(new IAllocationConstraint[]
{
loadContainer.Constraint,
new SpecialMailboxPlacementConstraint(this.nonMovableOrganizations)
});
return(loadContainer);
}
public virtual BatchName BeginDrainDatabase(DirectoryDatabase database)
{
BatchName batchName = BatchName.CreateDrainBatch(database.Identity);
DatabaseDrainRequest databaseDrainRequest = new DatabaseDrainRequest(database, this.serviceContext.MoveInjector, this.serviceContext, batchName);
if (!this.inProgressDrainRequests.TryAdd(database.Identity, batchName))
{
return(this.inProgressDrainRequests[database.Identity]);
}
databaseDrainRequest.OnDrainFinished += this.DatabaseDrainFinished;
this.serviceContext.QueueManager.GetProcessingQueue(database).EnqueueRequest(databaseDrainRequest);
return(batchName);
}
public IEnumerable <DirectoryServer> GetActivationPreferenceForDatabase(DirectoryDatabase database)
{
Database database2 = this.ConfigurationSession.Read <Database>(database.Identity.ADObjectId);
if (database2 == null)
{
throw new DatabaseNotFoundPermanentException(database.Name);
}
return(from ap in database2.ActivationPreference
orderby ap.Value
select ap into activationPreference
select this.GetServer(activationPreference.Key));
}
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));
}
});
}
}
}
}
protected void DatabaseDrainFinished(DirectoryDatabase database)
{
BatchName batchName;
if (this.inProgressDrainRequests.TryRemove(database.Identity, out batchName))
{
this.serviceContext.Logger.LogVerbose("Draining processing for database '{0}' using batch name '{1}' has completed.", new object[]
{
database.Identity,
batchName
});
return;
}
this.serviceContext.Logger.LogWarning("Received a signal that database {0} finished draining, but the database wasn't tracked.", new object[]
{
database.Identity
});
}
public virtual void InjectMoveForMailbox(DirectoryMailbox mailbox, BatchName batchName)
{
if (LoadBalanceADSettings.Instance.Value.UseDatabaseSelectorForMoveInjection)
{
LoadEntity loadEntity = this.serviceContext.GetTopologyExtractorFactoryContext().GetEntitySelectorFactory().GetExtractor(mailbox).ExtractEntity();
MailboxProvisioningResult database = this.databaseSelector.GetDatabase(new MailboxProvisioningData(mailbox.PhysicalSize, mailbox.MailboxProvisioningConstraints, loadEntity.ConsumedLoad));
database.ValidateSelection();
DirectoryIdentity database2 = database.Database;
DirectoryDatabase database3 = (DirectoryDatabase)this.directoryProvider.GetDirectoryObject(database2);
using (IInjectorService injectorClientForDatabase = this.clientFactory.GetInjectorClientForDatabase(database3))
{
injectorClientForDatabase.InjectSingleMove(database2.Guid, batchName.ToString(), new LoadEntity(mailbox));
return;
}
}
IRequest request = mailbox.CreateRequestToMove(null, batchName.ToString(), this.logger);
this.queueManager.MainProcessingQueue.EnqueueRequest(request);
}
protected override LoadBalanceDiagnosableResult ProcessDiagnostic()
{
LoadBalanceDiagnosableResult result = default(LoadBalanceDiagnosableResult);
if (base.Arguments.ShowQueues)
{
result.QueueManager = this.anchorContext.QueueManager.GetDiagnosticData(base.Arguments.ShowQueuedRequests, base.Arguments.Verbose);
}
if (base.Arguments.CleanQueues)
{
this.anchorContext.QueueManager.Clean();
}
if (base.Arguments.ShowLoadBalancerResults)
{
ILoadBalance loadBalancer = this.anchorContext.CreateLoadBalancer(base.Logger);
result.RebalanceResults = new AutomaticLoadBalancer(this.anchorContext).LoadBalanceForest(loadBalancer, base.Arguments.StartLoadBalance, base.Logger, TimeSpan.FromMinutes(5.0));
}
if (base.Arguments.RemoveSoftDeletedMailbox)
{
result.SoftDeletedMailboxRemovalResult = new SoftDeletedMailboxRemovalResult();
result.SoftDeletedMailboxRemovalResult.MailboxGuid = base.Arguments.MailboxGuid;
result.SoftDeletedMailboxRemovalResult.DatabaseGuid = base.Arguments.DatabaseGuid;
Exception ex;
result.SoftDeletedMailboxRemovalResult.Success = this.anchorContext.TryRemoveSoftDeletedMailbox(base.Arguments.MailboxGuid, base.Arguments.DatabaseGuid, out ex);
}
if (base.Arguments.GetMoveHistory)
{
result.SoftDeletedMoveHistoryResult = new SoftDeletedMoveHistoryResult();
result.SoftDeletedMoveHistoryResult.MailboxGuid = base.Arguments.MailboxGuid;
result.SoftDeletedMoveHistoryResult.TargetDatabaseGuid = base.Arguments.TargetDatabaseGuid;
result.SoftDeletedMoveHistoryResult.SourceDatabaseGuid = base.Arguments.SourceDatabaseGuid;
result.SoftDeletedMoveHistoryResult.MoveHistory = this.anchorContext.RetrieveSoftDeletedMailboxMoveHistory(base.Arguments.MailboxGuid, base.Arguments.TargetDatabaseGuid, base.Arguments.SourceDatabaseGuid);
}
if (base.Arguments.IsDrainingDatabase)
{
DirectoryDatabase database = this.anchorContext.Directory.GetDatabase(base.Arguments.DatabaseToDrainGuid);
BatchName drainBatchName = this.anchorContext.DrainControl.BeginDrainDatabase(database);
result.DatabaseToDrain = database.Identity;
result.DrainBatchName = drainBatchName;
}
return(result);
}
public IEnumerable <DirectoryMailbox> GetMailboxesForDatabase(DirectoryDatabase database)
{
this.logger.LogVerbose("Getting mailboxes for database '{0}'", new object[]
{
database.Name
});
DirectoryIdentity databaseIdentity = database.Identity;
using (IPhysicalDatabase physicalDatabase = this.clientFactory.GetPhysicalDatabaseConnection(database))
{
physicalDatabase.LoadMailboxes();
IOperationRetryManager retryManager = LoadBalanceOperationRetryManager.Create(this.logger);
foreach (LoadBalancingMiniRecipient recipient in this.RecipientSession.FindAllUsersLinkedToDatabase(databaseIdentity.ADObjectId))
{
DirectoryMailbox mailbox = null;
LoadBalancingMiniRecipient miniRecipient = recipient;
retryManager.TryRun(delegate
{
mailbox = this.GetMailboxFromMiniRecipient(miniRecipient, this.RecipientSession.GetExternalDirectoryOrganizationId(miniRecipient), physicalDatabase);
mailbox.Parent = database;
this.NotifyObjectLoaded(mailbox);
});
if (mailbox != null)
{
yield return(mailbox);
}
}
foreach (IPhysicalMailbox consumerMailbox in physicalDatabase.GetConsumerMailboxes())
{
DirectoryIdentity consumerIdentity = DirectoryIdentity.CreateConsumerMailboxIdentity(consumerMailbox.Guid, physicalDatabase.DatabaseGuid, consumerMailbox.OrganizationId);
yield return(new DirectoryMailbox(this, consumerIdentity, new IPhysicalMailbox[]
{
consumerMailbox
}, DirectoryMailboxType.Consumer));
}
foreach (NonConnectedMailbox disconnectedMailbox in this.GetDisconnectedMailboxesForDatabaseInternal(database, physicalDatabase))
{
yield return(disconnectedMailbox);
}
}
yield break;
}
private HeatMapCapacityData GetDatabaseCapacityDatum(DirectoryIdentity objectIdentity, bool refreshData, DirectoryIdentity localServerIdentity)
{
DirectoryDatabase directoryDatabase = (DirectoryDatabase)this.serviceContext.Directory.GetDirectoryObject(objectIdentity);
DirectoryServer directoryServer = directoryDatabase.ActivationOrder.FirstOrDefault <DirectoryServer>();
if (directoryServer == null || localServerIdentity.Equals(directoryServer.Identity))
{
TopologyExtractorFactoryContext topologyExtractorFactoryContext = this.serviceContext.GetTopologyExtractorFactoryContext();
TopologyExtractorFactory loadBalancingLocalFactory = topologyExtractorFactoryContext.GetLoadBalancingLocalFactory(refreshData);
LoadContainer loadContainer = loadBalancingLocalFactory.GetExtractor(directoryDatabase).ExtractTopology();
return(loadContainer.ToCapacityData());
}
HeatMapCapacityData capacitySummary;
using (ILoadBalanceService loadBalanceClientForDatabase = this.serviceContext.ClientFactory.GetLoadBalanceClientForDatabase(directoryDatabase))
{
capacitySummary = loadBalanceClientForDatabase.GetCapacitySummary(objectIdentity, refreshData);
}
return(capacitySummary);
}
public virtual TopologyExtractor GetExtractor(DirectoryObject directoryObject)
{
DirectoryMailbox directoryMailbox = directoryObject as DirectoryMailbox;
if (directoryMailbox != null)
{
return(this.CreateMailboxExtractor(directoryMailbox));
}
DirectoryDatabase directoryDatabase = directoryObject as DirectoryDatabase;
if (directoryDatabase != null)
{
return(this.CreateDatabaseExtractor(directoryDatabase));
}
DirectoryServer directoryServer = directoryObject as DirectoryServer;
if (directoryServer != null)
{
return(this.CreateServerExtractor(directoryServer));
}
DirectoryDatabaseAvailabilityGroup directoryDatabaseAvailabilityGroup = directoryObject as DirectoryDatabaseAvailabilityGroup;
if (directoryDatabaseAvailabilityGroup != null)
{
return(this.CreateDagExtractor(directoryDatabaseAvailabilityGroup));
}
DirectoryForest directoryForest = directoryObject as DirectoryForest;
if (directoryForest != null)
{
return(this.CreateForestExtractor(directoryForest));
}
DirectoryContainerParent directoryContainerParent = directoryObject as DirectoryContainerParent;
if (directoryContainerParent != null)
{
return(this.CreateContainerParentExtractor(directoryContainerParent));
}
return(null);
}
private bool ShouldCullNode(LoadContainer node, List <LoadContainer> copiedChildren, string constraint)
{
switch (node.ContainerType)
{
case ContainerType.Database:
{
if (node.DirectoryObject == null)
{
return(true);
}
IMailboxProvisioningConstraint mailboxProvisioningConstraint = new MailboxProvisioningConstraint(constraint);
DirectoryDatabase directoryDatabase = (DirectoryDatabase)node.DirectoryObject;
return((!string.IsNullOrEmpty(constraint) && directoryDatabase.MailboxProvisioningAttributes == null) || (directoryDatabase.MailboxProvisioningAttributes != null && !mailboxProvisioningConstraint.IsMatch(directoryDatabase.MailboxProvisioningAttributes)));
}
case ContainerType.ConstraintSet:
return(node.DirectoryObjectIdentity.Name != constraint);
default:
return(!copiedChildren.Any <LoadContainer>());
}
}
