public async Task <Response <RecommendedElasticPool> > GetAsync(string resourceGroupName, string serverName, string recommendedElasticPoolName, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (serverName == null)
{
throw new ArgumentNullException(nameof(serverName));
}
if (recommendedElasticPoolName == null)
{
throw new ArgumentNullException(nameof(recommendedElasticPoolName));
}
using var message = CreateGetRequest(resourceGroupName, serverName, recommendedElasticPoolName);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
RecommendedElasticPool value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = RecommendedElasticPool.DeserializeRecommendedElasticPool(document.RootElement);
return(Response.FromValue(value, message.Response));
}
/// <summary>
/// Validate recommended elastic pool properties
/// </summary>
/// <param name="recommendedElasticPool">Recommended elastic pool object</param>
/// <param name="name">Name</param>
/// <param name="type">Type</param>
/// <param name="edition">Edition</param>
/// <param name="dtu">Dtu</param>
/// <param name="databaseDtuMin">Dtu min</param>
/// <param name="databaseDtuMax">Dtu max</param>
/// <param name="storageMB">Storage MB</param>
/// <param name="observationPeriodStart">Observation start</param>
/// <param name="observationPeriodEnd">Observation end</param>
/// <param name="maxObservedDtu">Max observed Dtu</param>
/// <param name="maxObservedStorageMB">Max observed storage MB</param>
private void ValidateRecommendedElasticPool(RecommendedElasticPool recommendedElasticPool, string name, string type, string edition, float dtu, float databaseDtuMin, float databaseDtuMax, float storageMB, DateTime observationPeriodStart, DateTime observationPeriodEnd, float maxObservedDtu, float maxObservedStorageMB)
{
Assert.Equal(recommendedElasticPool.Name, name);
Assert.Equal(recommendedElasticPool.Type, type);
Assert.Equal(recommendedElasticPool.Properties.DatabaseEdition, edition);
Assert.Equal(recommendedElasticPool.Properties.Dtu, dtu, 2);
Assert.Equal(recommendedElasticPool.Properties.DatabaseDtuMin, databaseDtuMin, 2);
Assert.Equal(recommendedElasticPool.Properties.DatabaseDtuMax, databaseDtuMax, 2);
Assert.Equal(recommendedElasticPool.Properties.StorageMB, storageMB, 2);
Assert.Equal(recommendedElasticPool.Properties.ObservationPeriodStart, observationPeriodStart);
Assert.Equal(recommendedElasticPool.Properties.ObservationPeriodEnd, observationPeriodEnd);
Assert.Equal(recommendedElasticPool.Properties.MaxObservedDtu, maxObservedDtu, 2);
Assert.Equal(recommendedElasticPool.Properties.MaxObservedStorageMB, maxObservedStorageMB, 2);
}
/// <summary>
/// Converts the response from the service to a powershell database object
/// </summary>
/// <param name="pool">The service response</param>
/// <returns>The converted model</returns>
private UpgradeRecommendedElasticPoolProperties CreateRecommendedElasticPoolPropertiesFromResponse(RecommendedElasticPool pool)
{
var model = new UpgradeRecommendedElasticPoolProperties();
model.DatabaseCollection = pool.Properties.Databases.Select(database => database.Name).ToList();
model.DatabaseDtuMax = (int)pool.Properties.DatabaseDtuMax;
model.DatabaseDtuMin = (int)pool.Properties.DatabaseDtuMin;
model.Dtu = (int)pool.Properties.Dtu;
model.Edition = pool.Properties.DatabaseEdition;
model.IncludeAllDatabases = false;
model.Name = pool.Name;
return(model);
}
