// Add
public static Batch Add(BatchName name, int p)
{
Batch batch = new Batch(name, p);
_batchManager.Batches.AddToSorted(batch);
return(batch);
}
protected virtual void InjectMoves(LoadContainer database, BatchName batchName, IEnumerable <LoadEntity> mailboxes, bool throwIfNotValid)
{
IRequestQueue injectorQueue = this.queueManager.GetInjectionQueue((DirectoryDatabase)database.DirectoryObject);
IOperationRetryManager operationRetryManager = LoadBalanceOperationRetryManager.Create(this.logger);
using (IEnumerator <LoadEntity> enumerator = mailboxes.GetEnumerator())
{
while (enumerator.MoveNext())
{
LoadEntity mailbox = enumerator.Current;
if (mailbox.DirectoryObject == null)
{
this.logger.Log(MigrationEventType.Warning, "Not injecting move for {0} because its DirectoryObject is null", new object[]
{
mailbox
});
}
else
{
OperationRetryManagerResult operationRetryManagerResult = operationRetryManager.TryRun(delegate
{
DirectoryObject directoryObject = mailbox.DirectoryObject;
ConstraintValidationResult constraintValidationResult = database.Constraint.Accept(mailbox);
if (constraintValidationResult.Accepted)
{
database.CommittedLoad += mailbox.ConsumedLoad;
if (directoryObject.SupportsMoving)
{
DirectoryObject directoryObject2 = database.DirectoryObject;
IRequest request = directoryObject.CreateRequestToMove(directoryObject2.Identity, batchName.ToString(), this.logger);
injectorQueue.EnqueueRequest(request);
return;
}
if (throwIfNotValid)
{
throw new ObjectCannotBeMovedException(mailbox.DirectoryObjectIdentity.ObjectType.ToString(), mailbox.DirectoryObjectIdentity.ToString());
}
}
else
{
this.logger.Log(MigrationEventType.Warning, "Not injecting move for {0} because it violates the target database constraints: {1}", new object[]
{
mailbox,
constraintValidationResult
});
if (throwIfNotValid)
{
constraintValidationResult.Constraint.ValidateAccepted(mailbox);
}
}
});
if (!operationRetryManagerResult.Succeeded && throwIfNotValid)
{
throw operationRetryManagerResult.Exception;
}
}
}
}
}
/// <summary>Snippet for GetBatch</summary>
public void GetBatchResourceNames()
{
// Snippet: GetBatch(BatchName, CallSettings)
// Create client
BatchControllerClient batchControllerClient = BatchControllerClient.Create();
// Initialize request argument(s)
BatchName name = BatchName.FromProjectLocationBatch("[PROJECT]", "[LOCATION]", "[BATCH]");
// Make the request
Batch response = batchControllerClient.GetBatch(name);
// End snippet
}
public void InjectMovesOnCompatibilityMode(LoadContainer targetDatabase, BatchName batchName, IEnumerable <LoadEntity> mailboxes, bool throwIfNotValid)
{
IList <LoadEntity> list = (mailboxes as IList <LoadEntity>) ?? mailboxes.ToList <LoadEntity>();
this.logger.Log(MigrationEventType.Information, "Injecting {0} moves into database '{1}' with batch name '{2}' in backwards compatibility mode.", new object[]
{
list.Count,
targetDatabase.Guid,
batchName
});
this.InjectMoves(targetDatabase, batchName, list, throwIfNotValid);
}
void IInjectorService.InjectSingleMove(Guid targetDatabase, string batchName, LoadEntity mailbox)
{
base.ForwardExceptions(delegate()
{
DirectoryReconnectionVisitor visitor = new DirectoryReconnectionVisitor(this.directory, this.Logger);
mailbox.Accept(visitor);
this.moveInjector.InjectMoves(targetDatabase, BatchName.FromString(batchName), new LoadEntity[]
{
mailbox
}, false);
});
}
void IInjectorService.InjectMoves(Guid targetDatabase, string batchName, IEnumerable <LoadEntity> mailboxes)
{
base.ForwardExceptions(delegate()
{
DirectoryReconnectionVisitor visitor = new DirectoryReconnectionVisitor(this.directory, this.Logger);
IList <LoadEntity> list = (mailboxes as IList <LoadEntity>) ?? mailboxes.ToList <LoadEntity>();
foreach (LoadEntity loadEntity in list)
{
loadEntity.Accept(visitor);
}
this.moveInjector.InjectMoves(targetDatabase, BatchName.FromString(batchName), list, false);
});
}
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);
}
//Find and compare are used for getting an object in the active list.
public static Batch Find(BatchName name)
{
for (SDLinkedNode temp = (SDLinkedNode)_batchManager.Batches.GetHead(); temp != null; temp = (SDLinkedNode)temp.Next)
{
Batch tbatch = (Batch)temp;
if (tbatch.Name == name)
{
return(tbatch);
}
}
return(null);
}
/// <summary>Snippet for GetBatch</summary>
public void GetBatchRequestObject()
{
// Snippet: GetBatch(GetBatchRequest, CallSettings)
// Create client
BatchControllerClient batchControllerClient = BatchControllerClient.Create();
// Initialize request argument(s)
GetBatchRequest request = new GetBatchRequest
{
BatchName = BatchName.FromProjectLocationBatch("[PROJECT]", "[LOCATION]", "[BATCH]"),
};
// Make the request
Batch response = batchControllerClient.GetBatch(request);
// End snippet
}
/// <summary>Snippet for DeleteBatchAsync</summary>
public async Task DeleteBatchResourceNamesAsync()
{
// Snippet: DeleteBatchAsync(BatchName, CallSettings)
// Additional: DeleteBatchAsync(BatchName, CancellationToken)
// Create client
BatchControllerClient batchControllerClient = await BatchControllerClient.CreateAsync();
// Initialize request argument(s)
BatchName name = BatchName.FromProjectLocationBatch("[PROJECT]", "[LOCATION]", "[BATCH]");
// Make the request
await batchControllerClient.DeleteBatchAsync(name);
// End snippet
}
private void InjectMoveRequest(DirectoryMailbox mailbox, IMailboxPolicy violatedPolicy)
{
BatchName batchName = violatedPolicy.GetBatchName();
if (batchName == null)
{
throw new InvalidOperationException("Batch names should never be null.");
}
base.Logger.Log(MigrationEventType.Information, "Starting a new load balancing procedure to fix provisioning constraint, batch name will be '{0}'", new object[]
{
batchName
});
this.moveInjector.InjectMoveForMailbox(mailbox, batchName);
}
public async stt::Task GetBatchRequestObjectAsync()
{
moq::Mock <BatchController.BatchControllerClient> mockGrpcClient = new moq::Mock <BatchController.BatchControllerClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetBatchRequest request = new GetBatchRequest
{
BatchName = BatchName.FromProjectLocationBatch("[PROJECT]", "[LOCATION]", "[BATCH]"),
};
Batch expectedResponse = new Batch
{
BatchName = BatchName.FromProjectLocationBatch("[PROJECT]", "[LOCATION]", "[BATCH]"),
Uuid = "uuid6f877cef",
CreateTime = new wkt::Timestamp(),
PysparkBatch = new PySparkBatch(),
SparkBatch = new SparkBatch(),
SparkRBatch = new SparkRBatch(),
SparkSqlBatch = new SparkSqlBatch(),
RuntimeInfo = new RuntimeInfo(),
State = Batch.Types.State.Failed,
StateMessage = "state_message46cf28c0",
StateTime = new wkt::Timestamp(),
Creator = "creator253324ee",
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
RuntimeConfig = new RuntimeConfig(),
EnvironmentConfig = new EnvironmentConfig(),
Operation = "operation615a23f7",
StateHistory =
{
new Batch.Types.StateHistory(),
},
};
mockGrpcClient.Setup(x => x.GetBatchAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Batch>(stt::Task.FromResult(expectedResponse), null, null, null, null));
BatchControllerClient client = new BatchControllerClientImpl(mockGrpcClient.Object, null);
Batch responseCallSettings = await client.GetBatchAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Batch responseCancellationToken = await client.GetBatchAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public void InjectMoves(Guid targetDatabase, BatchName batchName, IList <LoadEntity> loadEntityList, bool throwIfNotValid = false)
{
this.logger.Log(MigrationEventType.Information, "Injecting {0} moves into database '{1}' with batch name '{2}'.", new object[]
{
loadEntityList.Count,
targetDatabase,
batchName
});
TopologyExtractorFactoryContextPool topologyExtractorFactoryContextPool = this.serviceContext.TopologyExtractorFactoryContextPool;
IList <Guid> nonMovableOrgsList = LoadBalanceUtils.GetNonMovableOrgsList(this.settings);
TopologyExtractorFactoryContext context = topologyExtractorFactoryContextPool.GetContext(this.clientFactory, null, nonMovableOrgsList, this.logger);
TopologyExtractorFactory entitySelectorFactory = context.GetEntitySelectorFactory();
LoadContainer database = entitySelectorFactory.GetExtractor(this.directoryProvider.GetDatabase(targetDatabase)).ExtractTopology();
this.InjectMoves(database, batchName, loadEntityList, throwIfNotValid);
}
/// <summary>Snippet for GetBatchAsync</summary>
public async Task GetBatchRequestObjectAsync()
{
// Snippet: GetBatchAsync(GetBatchRequest, CallSettings)
// Additional: GetBatchAsync(GetBatchRequest, CancellationToken)
// Create client
BatchControllerClient batchControllerClient = await BatchControllerClient.CreateAsync();
// Initialize request argument(s)
GetBatchRequest request = new GetBatchRequest
{
BatchName = BatchName.FromProjectLocationBatch("[PROJECT]", "[LOCATION]", "[BATCH]"),
};
// Make the request
Batch response = await batchControllerClient.GetBatchAsync(request);
// End snippet
}
public void DeleteBatchResourceNames()
{
moq::Mock <BatchController.BatchControllerClient> mockGrpcClient = new moq::Mock <BatchController.BatchControllerClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
DeleteBatchRequest request = new DeleteBatchRequest
{
BatchName = BatchName.FromProjectLocationBatch("[PROJECT]", "[LOCATION]", "[BATCH]"),
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.DeleteBatch(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
BatchControllerClient client = new BatchControllerClientImpl(mockGrpcClient.Object, null);
client.DeleteBatch(request.BatchName);
mockGrpcClient.VerifyAll();
}
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 async stt::Task DeleteBatchResourceNamesAsync()
{
moq::Mock <BatchController.BatchControllerClient> mockGrpcClient = new moq::Mock <BatchController.BatchControllerClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
DeleteBatchRequest request = new DeleteBatchRequest
{
BatchName = BatchName.FromProjectLocationBatch("[PROJECT]", "[LOCATION]", "[BATCH]"),
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.DeleteBatchAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
BatchControllerClient client = new BatchControllerClientImpl(mockGrpcClient.Object, null);
await client.DeleteBatchAsync(request.BatchName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
await client.DeleteBatchAsync(request.BatchName, st::CancellationToken.None);
mockGrpcClient.VerifyAll();
}
private DirectoryMailbox GetMailboxFromMiniRecipient(LoadBalancingMiniRecipient recipient, Guid organizationId, IPhysicalDatabase physicalDatabaseConnection)
{
List <IPhysicalMailbox> physicalMailboxes = new List <IPhysicalMailbox>(2);
Guid exchangeGuid = recipient.ExchangeGuid;
if (recipient.Database != null && exchangeGuid != Guid.Empty)
{
Guid objectGuid = recipient.Database.ObjectGuid;
this.AddPhysicalMailboxToList(exchangeGuid, objectGuid, physicalDatabaseConnection, physicalMailboxes, false);
}
if (recipient.ArchiveGuid != Guid.Empty && recipient.ArchiveDatabase != null)
{
this.AddPhysicalMailboxToList(recipient.ArchiveGuid, recipient.ArchiveDatabase.ObjectGuid, physicalDatabaseConnection, physicalMailboxes, true);
}
DirectoryMailbox directoryMailbox;
if (recipient.RecipientType == RecipientType.MailUser)
{
directoryMailbox = new CloudArchive(this, DirectoryIdentity.CreateMailboxIdentity(recipient.Guid, organizationId, DirectoryObjectType.CloudArchive), physicalMailboxes);
}
else
{
directoryMailbox = new DirectoryMailbox(this, DirectoryIdentity.CreateMailboxIdentity(recipient.Guid, organizationId, DirectoryObjectType.Mailbox), physicalMailboxes, DirectoryMailboxType.Organization);
if (recipient.propertyBag.Contains(MiniRecipientSchema.ConfigurationXML) && recipient.ConfigXML != null)
{
directoryMailbox.MailboxProvisioningConstraints = recipient.ConfigXML.MailboxProvisioningConstraints;
}
}
if (recipient.MailboxMoveFlags.HasFlag(RequestFlags.IntraOrg) && (recipient.MailboxMoveStatus == RequestStatus.Queued || recipient.MailboxMoveStatus == RequestStatus.InProgress))
{
BatchName batchName = BatchName.FromString(recipient.MailboxMoveBatchName);
if (batchName.IsLoadBalancingBatch)
{
directoryMailbox.IsBeingLoadBalanced = true;
}
}
return(directoryMailbox);
}
public Batch(BatchName name, int p)
{
Name = name;
Priority = p;
}
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;
}
public BatchName GetBatchName()
{
return(BatchName.CreateItemUpgradeBatch());
}
public BatchName GetBatchName()
{
return(BatchName.CreateProvisioningConstraintFixBatch());
}
public void InjectMoves(Guid targetDatabase, string batchName, IEnumerable <LoadEntity> mailboxes)
{
this.moveInjector.InjectMovesOnCompatibilityMode(this.service.GetDatabaseData(targetDatabase, false), BatchName.FromString(batchName), mailboxes, false);
}
