public static ResourceIdentity CreateResourceIdentity(GenericResourceExtended resource)
{
string[] parts = resource.Type.Split('/');
return(new ResourceIdentity {
ResourceType = parts[1], ResourceProviderNamespace = parts[0], ResourceName = resource.Name, ResourceProviderApiVersion = WebResourceProviderVersion
});
}
private string GetStorageResourceGroup(
ResourceManagementClient resourcesClient,
string storageAccountName,
string resourceType)
{
ResourceListResult res = resourcesClient.Resources.List(new ResourceListParameters
{
ResourceGroupName = null,
ResourceType = resourceType,
TagName = null,
TagValue = null
});
var allResources = new List <GenericResourceExtended>(res.Resources);
GenericResourceExtended account = allResources.Find(r => r.Name == storageAccountName);
if (account != null)
{
string resId = account.Id;
string[] segments = resId.Split('/');
int indexOfResoureGroup = new List <string>(segments).IndexOf("resourceGroups") + 1;
return(segments[indexOfResoureGroup]);
}
else
{
return(null);
}
}
private List <ResourceUsage> GetResourceSummaryByMeter(GenericResourceExtended resource, List <UsageAggregate> usageAggList, bool isTodaysData = false)
{
var resourceUsageList = new List <ResourceUsage>();
var distinctMeters = usageAggList.Select(x => x.Properties.MeterId).Distinct();
foreach (var meter in distinctMeters)
{
var firstEntry = usageAggList.Where(m => m.Properties.MeterId == meter).First();
ResourceUsage usage = new ResourceUsage();
usage.ResourceName = resource.Name;
usage.Type = resource.Type;
usage.Location = resource.Location;
usage.MeterId = meter;
usage.MeterCategory = firstEntry.Properties.MeterCategory;
usage.MeterSubCategory = firstEntry.Properties.MeterSubCategory;
usage.MeterName = firstEntry.Properties.MeterName;
usage.Quantity = usageAggList.Where(x => x.Properties.MeterId == meter).Sum(x => x.Properties.Quantity);
if (isTodaysData)
{
usage.UsageDate = Utils.GetCurrentDateWithMidnightTime();
}
resourceUsageList.Add(usage);
}
return(resourceUsageList);
}
/// <summary>
/// Returns the resource group of the provided storage account
/// </summary>
public string GetStorageResourceGroup(string storageAccountName)
{
ResourceManagementClient resourcesClient = GetCurrentResourcesClient(Profile);
ResourceListResult res = resourcesClient.Resources.List(new ResourceListParameters
{
ResourceGroupName = null,
ResourceType = "Microsoft.ClassicStorage/storageAccounts",
TagName = null,
TagValue = null
});
var allResources = new List <GenericResourceExtended>(res.Resources);
if (allResources.Count != 0)
{
GenericResourceExtended account = allResources.Find(r => r.Name == storageAccountName);
if (account != null)
{
String resId = account.Id;
String[] segments = resId.Split('/');
int indexOfResoureGroup = new List <string>(segments).IndexOf("resourceGroups") + 1;
return(segments[indexOfResoureGroup]);
}
else
{
throw new Exception(string.Format(Resources.StorageAccountNotFound, storageAccountName));
}
}
return(null);
}
public static PSResource ToPSResource(this GenericResourceExtended resource, ResourcesClient client, bool minimal)
{
ResourceIdentifier identifier = new ResourceIdentifier(resource.Id);
return(new PSResource
{
Name = identifier.ResourceName,
Location = resource.Location,
ResourceType = identifier.ResourceType,
ResourceGroupName = identifier.ResourceGroupName,
ParentResource = identifier.ParentResource,
Properties = JsonUtilities.DeserializeJson(resource.Properties),
PropertiesText = resource.Properties,
Tags = TagsConversionHelper.CreateTagHashtable(resource.Tags),
Permissions = minimal ? null : client.GetResourcePermissions(identifier),
ResourceId = identifier.ToString()
});
}
private List <ResourceUsage> GetUsageDailyByResource(GenericResourceExtended resource, UsagePayload usagePayLoad, bool isTodaysData = false)
{
var resourceUsageList = new List <ResourceUsage>();
var usageAggList = FindUsageAggregateByResource(resource.Name, usagePayLoad);
if (usageAggList == null || usageAggList.Count == 0)
{
ResourceUsage usage = new ResourceUsage();
usage.ResourceName = resource.Name;
usage.Type = resource.Type;
usage.Location = resource.Location;
resourceUsageList.Add(usage);
}
else
{
if (isTodaysData)
{
//Todays data is hourly data, so the data needs to be summarized by Meters for a resource
resourceUsageList = GetResourceSummaryByMeter(resource, usageAggList, isTodaysData);
}
else
{
foreach (var usageItem in usageAggList)
{
ResourceUsage usage = new ResourceUsage();
usage.ResourceName = resource.Name;
usage.Type = resource.Type;
usage.Location = resource.Location;
usage.MeterId = usageItem.Properties.MeterId;
usage.MeterCategory = usageItem.Properties.MeterCategory;
usage.MeterSubCategory = usageItem.Properties.MeterSubCategory;
usage.MeterName = usageItem.Properties.MeterName;
usage.Quantity = usageItem.Properties.Quantity;
usage.UsageDate = Utils.ParseDateUtc(usageItem.Properties.UsageStartTime);
resourceUsageList.Add(usage);
}
}
}
return(resourceUsageList);
}
public async void Given_Parameter_GetInsightsResourceAsync_ShouldReturn_Result(string appInsightsName, string resourceGroup, string location)
{
this._appInsights.SetupGet(p => p.Name).Returns(appInsightsName);
this._appInsights.SetupGet(p => p.ResourceGroup).Returns(resourceGroup);
this._settings.SetupGet(p => p.ApplicationInsight).Returns(this._appInsights.Object);
var resource = new GenericResourceExtended(location);
var resourceResult = new ResourceGetResult()
{
StatusCode = HttpStatusCode.OK, Resource = resource
};
this._resourceOperations.Setup(p => p.GetAsync(It.IsAny <string>(), It.IsAny <ResourceIdentity>(), It.IsAny <CancellationToken>())).ReturnsAsync(resourceResult);
this._resourceClient.SetupGet(p => p.Resources).Returns(this._resourceOperations.Object);
var result = await this._service.GetInsightsResourceAsync(this._resourceClient.Object).ConfigureAwait(false);
result.Location.Should().BeEquivalentTo(location);
}
private List <ResourceUsage> GetUsageSummaryByResource(GenericResourceExtended resource, UsagePayload usagePayLoad)
{
var resourceUsageList = new List <ResourceUsage>();
var usageAggList = FindUsageAggregateByResource(resource.Name, usagePayLoad);
if (usageAggList == null || usageAggList.Count == 0)
{
ResourceUsage usage = new ResourceUsage();
usage.ResourceName = resource.Name;
usage.Type = resource.Type;
usage.Location = resource.Location;
resourceUsageList.Add(usage);
return(resourceUsageList);
}
else
{
resourceUsageList = GetResourceSummaryByMeter(resource, usageAggList);
}
return(resourceUsageList);
}
public async void Given_Parameters_CreateOrUpdateWebTestAsync_ShouldReturn_Result(string name, string url, TestStatus testStatus, TestFrequency testFrequency, TestTimeout testTimeout, bool parseDependentRequests, RetriesForWebTestFailure retriesForWebTestFailure, AuthType authType, string accessToken, TestLocations testLocations, string resourceGroup, string location)
{
var successCriteria = new Mock <SucessCriteriaElement>();
successCriteria.SetupGet(p => p.Timeout).Returns(testTimeout);
this._webTest.SetupGet(p => p.TestType).Returns(TestType.UrlPingTest);
this._webTest.SetupGet(p => p.Status).Returns(testStatus);
this._webTest.SetupGet(p => p.Frequency).Returns(testFrequency);
this._webTest.SetupGet(p => p.ParseDependentRequests).Returns(parseDependentRequests);
this._webTest.SetupGet(p => p.SuccessCriteria).Returns(successCriteria.Object);
this._webTest.SetupGet(p => p.RetriesForWebTestFailure).Returns(retriesForWebTestFailure);
this._webTest.SetupGet(p => p.TestLocations).Returns(testLocations);
this._appInsights.SetupGet(p => p.ResourceGroup).Returns(resourceGroup);
this._settings.SetupGet(p => p.ApplicationInsight).Returns(this._appInsights.Object);
var resource = new GenericResourceExtended(location);
var resourceResult = new ResourceCreateOrUpdateResult()
{
StatusCode = HttpStatusCode.OK, Resource = resource
};
this._resourceOperations.Setup(p => p.CreateOrUpdateAsync(It.IsAny <string>(), It.IsAny <ResourceIdentity>(), It.IsAny <GenericResource>(), It.IsAny <CancellationToken>())).ReturnsAsync(resourceResult);
this._resourceClient.Setup(p => p.Resources).Returns(this._resourceOperations.Object);
var id = Guid.NewGuid();
var insightsResource = new ResourceBaseExtended(location)
{
Id = id.ToString(), Name = name
};
var result = await this._service.CreateOrUpdateWebTestAsync(name, url, authType, accessToken, this._webTest.Object, this._resourceClient.Object, insightsResource).ConfigureAwait(false);
result.Location.Should().BeEquivalentTo(location);
}
/// <summary>
/// Returns the resource group of the provided storage account
/// </summary>
public string GetStorageResourceGroup(string storageAccountName)
{
ResourceManagementClient resourcesClient = GetCurrentResourcesClient(Context);
Func <string, string> getResourceGroupName =
resourceType =>
{
ResourceListResult res = resourcesClient.Resources.List(new ResourceListParameters
{
ResourceGroupName = null,
ResourceType = resourceType,
TagName = null,
TagValue = null
});
var allResources = new List <GenericResourceExtended>(res.Resources);
GenericResourceExtended account = allResources.Find(r => r.Name == storageAccountName);
if (account != null)
{
String resId = account.Id;
String[] segments = resId.Split('/');
int indexOfResoureGroup = new List <string>(segments).IndexOf("resourceGroups") + 1;
return(segments[indexOfResoureGroup]);
}
else
{
throw new Exception(string.Format(Microsoft.Azure.Commands.Sql.Properties.Resources.StorageAccountNotFound, storageAccountName));
}
};
try
{
return(getResourceGroupName("Microsoft.ClassicStorage/storageAccounts"));
}
catch
{
return(getResourceGroupName("Microsoft.Storage/storageAccounts"));
}
}
