internal static async Task <DataSet> CreateAsync(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
string shareName,
string dataSetName,
DataSet expectedDataSet)
{
AzureOperationResponse <DataSet> createResponse =
await client.DataSets.CreateWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareName,
dataSetName,
expectedDataSet);
AzureOperationResponse <DataSet> DataSet = await client.DataSets.GetWithHttpMessagesAsync(resourceGroupName, accountName, shareName, dataSetName);
BlobDataSet blobDataSet = (BlobDataSet)DataSet.Body;
dataSetId = blobDataSet.DataSetId;
DataSetScenarioTests.ValidateDataSet(
createResponse.Body,
dataSetName);
Assert.Equal(HttpStatusCode.Created, createResponse.Response.StatusCode);
return(createResponse.Body);
}
protected void SetupManagementClients(MockContext context)
{
this.ResourceManagementClient = this.GetResourceManagementClient(context);
this.DataShareManagementClient = TestController.GetDataShareManagementClient(context);
this.helper.SetupManagementClients(
this.ResourceManagementClient,
this.DataShareManagementClient);
}
internal static async Task Delete(DataShareManagementClient client, string resourceGroupName, string accountName)
{
AzureOperationResponse <OperationResponse> deleteResponse = await client.Accounts.DeleteWithHttpMessagesAsync(resourceGroupName, accountName);
Assert.Equal(HttpStatusCode.OK, deleteResponse.Response.StatusCode);
deleteResponse = await client.Accounts.DeleteWithHttpMessagesAsync(resourceGroupName, accountName);
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.Response.StatusCode);
}
internal static void Synchronize(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
string shareSubscriptionName)
{
client.ShareSubscriptions.SynchronizeMethod(
resourceGroupName,
accountName,
shareSubscriptionName,
new Synchronize(synchronizationMode: "FullSync"));
}
internal static async Task CreateAsync(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
Account expectedAccount)
{
AzureOperationResponse <Account> createResponse =
await client.Accounts.CreateWithHttpMessagesAsync(resourceGroupName, accountName, expectedAccount);
AccountScenarioTests.ValidateAccount(createResponse.Body, accountName);
Assert.Equal(HttpStatusCode.Created, createResponse.Response.StatusCode);
}
internal static async Task <EmailRegistration> RegisterEmailAsync(
DataShareManagementClient client,
string location)
{
AzureOperationResponse <EmailRegistration> createResponse =
await client.EmailRegistrations.RegisterEmailWithHttpMessagesAsync(location);
EmailRegistrationScenarioTests.ValidateEmailRegistration(createResponse.Body, "*****@*****.**", "ActivationPending", "15ee7153fe0df5a3a449a897d6cec836", "f686d426-8d16-42db-81b7-ab578e110ccd");
Assert.Equal(HttpStatusCode.OK, createResponse.Response.StatusCode);
return(createResponse.Body);
}
protected async Task RunTest(
Func <DataShareManagementClient, Task> initialAction,
Func <DataShareManagementClient, Task> finallyAction,
[CallerMemberName] string methodName = "")
{
const string modeEnvironmentVariableName = "AZURE_TEST_MODE";
const string playback = "Playback";
using (MockContext mockContext = MockContext.Start(Type, methodName))
{
string mode = Environment.GetEnvironmentVariable(modeEnvironmentVariableName);
if (mode != null && mode.Equals(playback, StringComparison.OrdinalIgnoreCase))
{
HttpMockServer.Mode = HttpRecorderMode.Playback;
}
//this.ResourceGroupName = TestUtilities.GenerateName(ScenarioTestBase<T>.ResourceGroupNamePrefix);
this.ResourceGroupName = ScenarioTestBase <T> .ResourceGroupNamePrefix;
// this.AccountName = TestUtilities.GenerateName(ScenarioTestBase<T>.AccountNamePrefix);
this.AccountName = ScenarioTestBase <T> .AccountNamePrefix;
this.Client =
mockContext.GetServiceClient <DataShareManagementClient>(
TestEnvironmentFactory.GetTestEnvironment());
ResourceManagementClient resourceManagementClient =
mockContext.GetServiceClient <ResourceManagementClient>(TestEnvironmentFactory.GetTestEnvironment());
resourceManagementClient.ResourceGroups.CreateOrUpdate(
this.ResourceGroupName,
new ResourceGroup()
{
Location = ScenarioTestBase <T> .AccountLocation
});
StorageManagementClient storageManagementClient = mockContext.GetServiceClient <StorageManagementClient>(TestEnvironmentFactory.GetTestEnvironment());
CreateStorageAccount(this.ResourceGroupName, storageActName, storageManagementClient);
await initialAction(this.Client);
if (finallyAction != null)
{
await finallyAction(this.Client);
}
resourceManagementClient.ResourceGroups.Delete(this.ResourceGroupName);
}
}
internal static async Task CreateAsync(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
string shareSubscriptionName,
ShareSubscription expectedShareSubscription)
{
AzureOperationResponse <ShareSubscription> createResponse =
await client.ShareSubscriptions.CreateWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareSubscriptionName,
expectedShareSubscription);
ShareSubscriptionScenarioTests.ValidateShare(createResponse.Body, shareSubscriptionName);
Assert.Equal(HttpStatusCode.Created, createResponse.Response.StatusCode);
}
internal static async Task CreateAsync(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
string shareSubscriptionName,
string dataSetMappingName,
DataSetMapping expectedDataSetMapping)
{
var createResponse =
await client.DataSetMappings.CreateWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareSubscriptionName,
dataSetMappingName,
expectedDataSetMapping);
DataSetMappingScenarioTests.ValidateDataSetMapping(
createResponse.Body,
dataSetMappingName);
Assert.Equal(HttpStatusCode.Created, createResponse.Response.StatusCode);
}
internal static async Task <Invitation> CreateAsync(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
string shareName,
string invitationName,
Invitation expectedInvitation)
{
AzureOperationResponse <Invitation> createResponse =
await client.Invitations.CreateWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareName,
invitationName,
expectedInvitation);
InvitationScenarioTests.ValidateInvitation(createResponse.Body, invitationName);
Assert.Equal(HttpStatusCode.Created, createResponse.Response.StatusCode);
return(createResponse.Body);
}
internal static async Task CreateAsync(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
string shareSubscriptionName,
string triggerName,
Trigger expectedTrigger)
{
AzureOperationResponse <Trigger> createResponse =
await client.Triggers.CreateWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareSubscriptionName,
triggerName,
expectedTrigger);
TriggerScenarioTests.ValidateTrigger(
createResponse.Body,
triggerName);
Assert.Equal(HttpStatusCode.OK, createResponse.Response.StatusCode);
}
internal static async Task <SynchronizationSetting> CreateAsync(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
string shareName,
string synchronizationSettingName,
SynchronizationSetting expectedSynchronizationSetting)
{
AzureOperationResponse <SynchronizationSetting> createResponse =
await client.SynchronizationSettings.CreateWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareName,
synchronizationSettingName,
expectedSynchronizationSetting);
SynchronizationSettingScenarioTests.ValidateSynchronizationSetting(
createResponse.Body,
synchronizationSettingName);
Assert.Equal(HttpStatusCode.Created, createResponse.Response.StatusCode);
return(createResponse.Body);
}
internal static async Task Delete(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
string shareSubscriptionName,
string triggerName)
{
AzureOperationResponse <OperationResponse> deleteResponse =
await client.Triggers.DeleteWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareSubscriptionName,
triggerName);
Assert.Equal(HttpStatusCode.OK, deleteResponse.Response.StatusCode);
deleteResponse = await client.SynchronizationSettings.DeleteWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareSubscriptionName,
triggerName);
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.Response.StatusCode);
}
internal static async Task Delete(
DataShareManagementClient client,
string resourceGroupName,
string accountName,
string shareName,
string dataSetName)
{
var deleteResponse =
await client.DataSets.DeleteWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareName,
dataSetName);
Assert.Equal(HttpStatusCode.OK, deleteResponse.Response.StatusCode);
deleteResponse = await client.DataSets.DeleteWithHttpMessagesAsync(
resourceGroupName,
accountName,
shareName,
dataSetName);
Assert.Equal(HttpStatusCode.NoContent, deleteResponse.Response.StatusCode);
}
static async Task Main(string subscriptionId, string resourceGroupName, string dataShareName)
{
//
// Validate
//
if (string.IsNullOrWhiteSpace(subscriptionId))
{
Console.WriteLine($"{nameof(subscriptionId)} must be provided.");
return;
}
if (string.IsNullOrWhiteSpace(resourceGroupName))
{
Console.WriteLine($"{nameof(resourceGroupName)} must be provided.");
return;
}
if (string.IsNullOrWhiteSpace(dataShareName))
{
Console.WriteLine($"{nameof(dataShareName)} must be provided.");
return;
}
//
// Initialize
//
ResourceGroupName = resourceGroupName;
DataShareName = dataShareName;
var tokenProvider = new AzureServiceTokenProvider();
var accessToken = await tokenProvider.GetAccessTokenAsync("https://management.azure.com");
Client = new DataShareManagementClient(new TokenCredentials(accessToken))
{
SubscriptionId = subscriptionId
};
//
// Begin building report
//
var tenantSyncs = new Dictionary <string, UsageReportTenantData>();
var shares = await GetAllPages(skipToken => Client.Shares.ListByAccountAsync(ResourceGroupName, DataShareName, skipToken));
var shareNames = shares.Select(x => x.Name);
foreach (var shareName in shareNames)
{
var syncs = await GetAllPages(skipToken => Client.Shares.ListSynchronizationsAsync(ResourceGroupName, DataShareName, shareName));
if (!syncs.Any())
{
continue;
}
// var tenantLast30DaysCost = await GetTenantLast30DaysCost(shareName, syncs);
// Since each sent share is for a single tenant we can use the first sync for tenant name
var tenantName = syncs.First().ConsumerTenantName;
if (tenantSyncs.ContainsKey(tenantName))
{
throw new InvalidOperationException("This report does not support multiple tenants with the same name.");
}
tenantSyncs.Add(tenantName, new UsageReportTenantData
{
LastSync = syncs.Max(x => x.StartTime).GetValueOrDefault(),
// UnofficialCostLast30Days = tenantLast30DaysCost,
});
}
var notSyncedFor30DaysCount = tenantSyncs
.Select(x => x.Value)
.Count(x => x.LastSync < DateTime.UtcNow.AddDays(-30));
var usageReport = new
{
Totals = new
{
// UnofficialCostLast30Days = tenantSyncs.Select(x => x.Value).Sum(x => x.UnofficialCostLast30Days),
SyncedAtLeastOnceButNotSyncedFor30Days = notSyncedFor30DaysCount,
SyncedAtLeastOnceButNotSyncedFor30DaysPercentage = shares.Count() > 0
? decimal.Round(100 - ((shares.Count() - notSyncedFor30DaysCount) / (decimal)shares.Count() * 100), 2)
: -1,
SentShares = shares.Count(),
SentShareWithSyncActivity = tenantSyncs.Count(),
SentShareWithSyncActivityPercentage = shares.Count() > 0
? decimal.Round(100 - ((shares.Count() - tenantSyncs.Count()) / (decimal)shares.Count() * 100), 2)
: -1,
},
TenantSyncs = tenantSyncs
.Select(x => new
{
Name = x.Key,
LastSync = x.Value.LastSync,
// UnofficialCostLast30Days = x.Value.UnofficialCostLast30Days,
})
.OrderBy(x => x.Name),
TenantsSyncedAtLeastOnceButNotSyncedFor30Days = tenantSyncs
.Where(x => x.Value.LastSync < DateTime.UtcNow.AddDays(-30))
.Select(x => x.Key)
.OrderBy(x => x),
};
//
// Output
//
var output = JsonSerializer.Serialize(usageReport, new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
WriteIndented = true
});
Console.WriteLine(output);
}
