private static async Task AssertPoolWasCreatedWithApplicationReferences(BatchClient client, string poolId, string applicationId)
{
try
{
CloudPool pool = client.PoolOperations.CreatePool(poolId, PoolFixture.VMSize, new CloudServiceConfiguration(PoolFixture.OSFamily));
pool.ApplicationPackageReferences = new[] { new ApplicationPackageReference {
ApplicationId = applicationId, Version = ApplicationIntegrationCommon.Version
} };
await pool.CommitAsync().ConfigureAwait(false);
CloudPool referenceToPool = await client.PoolOperations.GetPoolAsync(poolId).ConfigureAwait(false);
ApplicationPackageReference apr = referenceToPool.ApplicationPackageReferences.First();
// Check to see if the pool had an application reference.
Assert.Equal(apr.ApplicationId, applicationId);
Assert.Equal(apr.Version, ApplicationIntegrationCommon.Version);
}
finally
{
TestUtilities.DeletePoolIfExistsAsync(client, poolId).Wait();
}
}
/// <summary>
/// Syncs the collections on a PSJobManagerTask with its wrapped OM object
/// </summary>
internal static void JobManagerTaskSyncCollections(PSJobManagerTask jobManager)
{
if (jobManager != null)
{
jobManager.omObject.EnvironmentSettings = CreateSyncedList(jobManager.EnvironmentSettings,
(e) =>
{
EnvironmentSetting envSetting = new EnvironmentSetting(e.Name, e.Value);
return(envSetting);
});
jobManager.omObject.ResourceFiles = CreateSyncedList(jobManager.ResourceFiles,
(r) =>
{
ResourceFile resourceFile = new ResourceFile(r.BlobSource, r.FilePath);
return(resourceFile);
});
jobManager.omObject.ApplicationPackageReferences = CreateSyncedList(jobManager.ApplicationPackageReferences,
a =>
{
ApplicationPackageReference applicationPackageReference = new ApplicationPackageReference
{
ApplicationId = a.ApplicationId,
Version = a.Version
};
return(applicationPackageReference);
});
}
}
/// <summary>
/// Converts a PSApplicationPackageReference to a ApplicationPackageReference
/// </summary>
private static ApplicationPackageReference ConvertApplicationPackageReference(PSApplicationPackageReference psApr)
{
ApplicationPackageReference applicationPackageReference = new ApplicationPackageReference()
{
ApplicationId = psApr.ApplicationId,
Version = psApr.Version
};
return(applicationPackageReference);
}
public static CloudTask CreateLoadTestTask(this LoadTestSupervisorOptions options, int index)
{
var maxExecutionTime = options.InstanceOptions.Timeout + 10.Minutes();
var taskId = $"loadtest__{options.Name}__{index}";
var instanceOptions = options.InstanceOptions;
var builder = new StringBuilder();
builder.Append(
$"cmd /c %AZ_BATCH_APP_PACKAGE_CONREIGN-LOADTEST#{options.ApplicationVersion}%\\Conreign.LoadTest.exe");
var arguments = new List <CommandLineArgument>
{
new CommandLineArgument(nameof(instanceOptions.InstanceId), taskId),
new CommandLineArgument(nameof(instanceOptions.ConnectionUri), instanceOptions.ConnectionUri),
new CommandLineArgument(nameof(instanceOptions.ElasticSearchUri), instanceOptions.ElasticSearchUri),
new CommandLineArgument(
$"{nameof(instanceOptions.BotOptions)}:{nameof(instanceOptions.BotOptions.RoomsCount)}",
instanceOptions.BotOptions.RoomsCount),
new CommandLineArgument(
$"{nameof(instanceOptions.BotOptions)}:{nameof(instanceOptions.BotOptions.BotsPerRoomCount)}",
instanceOptions.BotOptions.BotsPerRoomCount),
new CommandLineArgument(
$"{nameof(instanceOptions.BotOptions)}:{nameof(instanceOptions.BotOptions.RoomPrefix)}",
$"{taskId}:"),
new CommandLineArgument(nameof(instanceOptions.MinimumConsoleLogLevel), LogEventLevel.Warning),
new CommandLineArgument(nameof(instanceOptions.LogFileName),
Path.Combine("%AZ_BATCH_TASK_DIR%", instanceOptions.LogFileName)),
new CommandLineArgument(nameof(instanceOptions.Timeout), instanceOptions.Timeout)
};
var args = arguments.Where(x => x.Value != null).ToList();
builder.Append($" {string.Join(" ", args)}");
var cmd = builder.ToString();
var task = new CloudTask(taskId, cmd);
var app = new ApplicationPackageReference
{
ApplicationId = ApplicationId,
Version = options.ApplicationVersion
};
task.Constraints = new TaskConstraints(maxExecutionTime);
task.ApplicationPackageReferences = new List <ApplicationPackageReference> {
app
};
task.DisplayName = $"Execute load test ({taskId})";
return(task);
}
private static PoolSpecification CreatePoolSpecification(LoadTestSupervisorOptions options, string jobId = null)
{
var applicationPackage = new ApplicationPackageReference
{
ApplicationId = ApplicationId,
Version = options.ApplicationVersion
};
return(new PoolSpecification
{
TargetDedicated = (int)Math.Ceiling((double)options.Instances / MaxTasksPerNode),
MaxTasksPerComputeNode = MaxTasksPerNode,
DisplayName = jobId == null ? "Load test pool" : $"Load test pool ({jobId})",
ApplicationPackageReferences = new List <ApplicationPackageReference> {
applicationPackage
},
CloudServiceConfiguration = new CloudServiceConfiguration(WindowsServer),
VirtualMachineSize = options.MachineSize
});
}
/// <summary>
/// Syncs the collections on a PSJobManagerTask with its wrapped OM object
/// </summary>
internal static void JobManagerTaskSyncCollections(PSJobManagerTask jobManager)
{
if (jobManager != null)
{
jobManager.omObject.EnvironmentSettings = CreateSyncedDict(
jobManager.EnvironmentSettings,
ConvertEnvironmentSetting);
jobManager.omObject.ResourceFiles = CreateSyncedList(jobManager.ResourceFiles, ConvertResourceFile);
jobManager.omObject.ApplicationPackageReferences = CreateSyncedList(jobManager.ApplicationPackageReferences,
a =>
{
ApplicationPackageReference applicationPackageReference = new ApplicationPackageReference
{
ApplicationId = a.ApplicationId,
Version = a.Version
};
return(applicationPackageReference);
});
}
}
private static void ProcessAssembly(AllAssemblies allAssemblies, FileSystemPath productBinariesDir,
MetadataLoader metadataLoader, AssemblyNameInfo assemblyNameInfo,
HashSet <ApplicationPackageFile> packageFiles, HashSet <ApplicationPackageReference> packageReferences)
{
var assembly = metadataLoader.TryLoad(assemblyNameInfo, JetFunc <AssemblyNameInfo> .False, false);
if (assembly == null)
{
return;
}
var subplatformOfAssembly = allAssemblies.FindSubplatformOfAssembly(assemblyNameInfo, OnError.Ignore);
if (subplatformOfAssembly != null)
{
var subplatformReference = new ApplicationPackageReference(subplatformOfAssembly.Name,
subplatformOfAssembly.GetCompanyNameHuman());
packageReferences.Add(subplatformReference);
return;
}
if (assembly.AssemblyName?.Name.Contains("Microsoft.CodeAnalysis") == true)
{
return;
}
if (!packageFiles.Add(new ApplicationPackageFile(assembly.Location.MakeRelativeTo(productBinariesDir),
assemblyNameInfo)))
{
return;
}
foreach (var referencedAssembly in assembly.ReferencedAssembliesNames)
{
ProcessAssembly(allAssemblies, productBinariesDir, metadataLoader, referencedAssembly, packageFiles,
packageReferences);
}
}
static async Task Execute()
{
// setup unique names for pool and job
var poolId = "DemoPool1";
var jobId = "DemoJob1";
var application_package_name = "process-data-standalone";
var application_package_version = "1";
var settings = Config.LoadAccountSettings();
// create a storage blob client to upload files
var blobClient = CreateBlobClient(settings.StorageAccountName, settings.StorageAccountKey);
Console.WriteLine("\n>>> Creating Storage Containers <<<\n");
// Use the blob client to create the containers in Azure Blob Storage.
Console.WriteLine("Creating container to store csv files");
CreateStorageContainersIfNotExist(blobClient, InputContainerName); // store input csv files
Console.WriteLine("Creating container to store output files files");
CreateStorageContainersIfNotExist(blobClient, OutputContainerName); // store output text files
// connect to Azure Batch account
BatchSharedKeyCredentials cred = new BatchSharedKeyCredentials(settings.BatchServiceUrl, settings.BatchAccountName, settings.BatchAccountKey);
using (var batchClient = BatchClient.Open(cred))
{
Console.WriteLine("\n>>> Checking Application Packages in the Azure Batch account <<<\n");
await ListApplicationPackages(batchClient);
// prepare application pacakage reference
var appReference = new ApplicationPackageReference
{
ApplicationId = application_package_name,
Version = application_package_version
};
var app_packages = new List <ApplicationPackageReference> {
appReference
};
Console.WriteLine("\n>>> Creating Pool <<<\n");
await CreatePoolIfNotExist(batchClient, poolId, applicationPackages : app_packages);
PromptContinue();
Console.WriteLine("\n>>> Creating Job <<<\n");
await CreateJob(batchClient, jobId, poolId);
PromptContinue();
Console.WriteLine("\n>>> Creating Tasks <<<\n");
// get reference to output container SAS uri
Console.WriteLine("Getting reference to container for storing task output");
var outputContainerSasUrl = GetContainerSasUrl(blobClient, OutputContainerName);
Console.WriteLine($"[INFO] {OutputContainerName} SAS: {outputContainerSasUrl}");
Console.WriteLine("\nAdding tasks...");
var executable = "$AZ_BATCH_APP_PACKAGE_process_data_standalone_1/process-data";
await AddAllTasksToJob(batchClient, jobId, executable, blobClient, outputContainerSasUrl);
Console.WriteLine("\n>>> Monitor tasks <<<\n");
var tasksSucceeded = await MonitorTasks(batchClient, jobId, TimeSpan.FromMinutes(60));
// Clean up Batch resources (if the user so chooses)
Console.WriteLine();
Console.Write("Delete job? [yes] no: ");
string response = Console.ReadLine().ToLower();
if (response != "n" && response != "no")
{
batchClient.JobOperations.DeleteJob(jobId);
}
Console.Write("Delete pool? [yes] no: ");
response = Console.ReadLine().ToLower();
if (response != "n" && response != "no")
{
batchClient.PoolOperations.DeletePool(poolId);
}
}
}
