/// <summary> /// Get Batch Context with keys /// </summary> public static BatchAccountContext GetBatchAccountContextWithKeys(BatchController controller, string accountName) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); BatchAccountContext context = client.ListKeys(null, accountName); return context; }
/// <summary> /// Creates an account and resource group for use with the Scenario tests /// </summary> public static BatchAccountContext CreateTestAccountAndResourceGroup(BatchController controller, string resourceGroupName, string accountName, string location) { controller.ResourceManagementClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup() { Location = location }); BatchAccountCreateResponse createResponse = controller.BatchManagementClient.Accounts.Create(resourceGroupName, accountName, new BatchAccountCreateParameters() { Location = location }); BatchAccountContext context = BatchAccountContext.ConvertAccountResourceToNewAccountContext(createResponse.Resource); BatchAccountListKeyResponse response = controller.BatchManagementClient.Accounts.ListKeys(resourceGroupName, accountName); context.PrimaryAccountKey = response.PrimaryKey; context.SecondaryAccountKey = response.SecondaryKey; return context; }
public void TestChangeOSVersion() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; string poolId = "changeospool"; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-ChangeOSVersion '{0}' '{1}'", poolId, specificOSVersion) }); }, () => { context = new ScenarioTestContext(); ScenarioTestHelpers.CreateTestPool(controller, context, poolId, targetDedicated: 0, targetLowPriority: 0); }, () => { ScenarioTestHelpers.DeletePool(controller, context, poolId); }, MethodBase.GetCurrentMethod().ReflectedType?.ToString(), MethodBase.GetCurrentMethod().Name); }
/// <summary> /// Creates a test pool for use in Scenario tests. /// </summary> public static void CreateTestPool(BatchController controller, BatchAccountContext context, string poolId, int targetDedicated, CertificateReference certReference = null) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); PSCertificateReference[] certReferences = null; if (certReference != null) { certReferences = new PSCertificateReference[] { new PSCertificateReference(certReference) }; } NewPoolParameters parameters = new NewPoolParameters(context, poolId) { VirtualMachineSize = "small", OSFamily = "4", TargetOSVersion = "*", TargetDedicated = targetDedicated, CertificateReferences = certReferences, }; client.CreatePool(parameters); }
public void IfJobSetsAutoFailure_ItCompletesWhenAnyTaskFails() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; string jobId = "testJobCompletesWhenTaskFails"; string taskId = "taskId-1"; PSCloudJob completedJob = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("IfJobSetsAutoFailure-ItCompletesWhenAnyTaskFails '{0}' '{1}'", jobId, taskId) }); }, null, () => { context = new ScenarioTestContext(); completedJob = ScenarioTestHelpers.WaitForJobCompletion(controller, context, jobId, taskId); AssertJobIsCompleteDueToTaskFailure(completedJob); ScenarioTestHelpers.DeleteJob(controller, context, jobId); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
/// <summary> /// Waits for the specified task to complete /// </summary> public static void WaitForTaskCompletion(BatchController controller, BatchAccountContext context, string workItemName, string jobName, string taskName) { YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListTaskOptions options = new ListTaskOptions() { Context = context, WorkItemName = workItemName, JobName = jobName, TaskName = taskName, AdditionalBehaviors = behaviors }; IEnumerable <PSCloudTask> tasks = client.ListTasks(options); ITaskStateMonitor monitor = context.BatchOMClient.OpenToolbox().CreateTaskStateMonitor(); monitor.WaitAll(tasks.Select(t => t.omObject), TaskState.Completed, TimeSpan.FromMinutes(2), null, behaviors); }
public void TestGetCertificateByThumbprint() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; string thumbprintAlgorithm = null; string thumbprint = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-GetCertificateByThumbprint '{0}' '{1}' '{2}'", accountName, BatchTestHelpers.TestCertificateAlgorithm, thumbprint) }); }, () => { context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, accountName); thumbprint = ScenarioTestHelpers.AddTestCertificate(controller, context, BatchTestHelpers.TestCertificateFileName1); }, () => { ScenarioTestHelpers.DeleteTestCertificate(controller, context, BatchTestHelpers.TestCertificateAlgorithm, thumbprint); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
public void TestGetJobRequiredParameters() { BatchController controller = BatchController.NewInstance; string resourceGroupName = "test-get-job-params"; string accountName = "testgetjobparams"; string location = "eastus"; BatchAccountContext context = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-GetJobRequiredParameters '{0}'", accountName) }); }, () => { context = ScenarioTestHelpers.CreateTestAccountAndResourceGroup(controller, resourceGroupName, accountName, location); }, () => { ScenarioTestHelpers.CleanupTestAccount(controller, resourceGroupName, accountName); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
public void TestRemoveComputeNodes() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; string removeNodePoolId = "removenodepool"; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-RemoveComputeNodes '{0}'", removeNodePoolId) }); }, () => { context = new ScenarioTestContext(); ScenarioTestHelpers.CreateTestPool(controller, context, removeNodePoolId, targetDedicated: 2, targetLowPriority: 0); ScenarioTestHelpers.WaitForSteadyPoolAllocation(controller, context, removeNodePoolId); }, () => { ScenarioTestHelpers.DeletePool(controller, context, removeNodePoolId); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
public void TestDisableAndEnableJobSchedule() { BatchController controller = BatchController.NewInstance; string jobScheduleId = "testDisableEnableJobSchedule"; BatchAccountContext context = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-DisableAndEnableJobSchedule '{0}' '1'", jobScheduleId) }); }, () => { context = new ScenarioTestContext(); ScenarioTestHelpers.CreateTestJobSchedule(controller, context, jobScheduleId, null); }, () => { ScenarioTestHelpers.DeleteJobSchedule(controller, context, jobScheduleId); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
/// <summary> /// Creates a test task for use in Scenario tests. /// </summary> public static void CreateTestTask(BatchController controller, BatchAccountContext context, string jobId, string taskId, string cmdLine = "cmd /c dir /s", int numInstances = 0) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); PSMultiInstanceSettings multiInstanceSettings = null; if (numInstances > 1) { multiInstanceSettings = new PSMultiInstanceSettings(numInstances); multiInstanceSettings.CoordinationCommandLine = "cmd /c echo coordinating"; } NewTaskParameters parameters = new NewTaskParameters(context, jobId, null, taskId) { CommandLine = cmdLine, MultiInstanceSettings = multiInstanceSettings, RunElevated = numInstances <= 1 }; client.CreateTask(parameters); }
public void TestEnableAutoScaleByPipeline() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-EnableAutoScale '{0}' '1'", testPoolId) }); }, () => { context = new ScenarioTestContext(); ScenarioTestHelpers.WaitForSteadyPoolAllocation(controller, context, testPoolId); ScenarioTestHelpers.DisableAutoScale(controller, context, testPoolId); ScenarioTestHelpers.WaitForSteadyPoolAllocation(controller, context, testPoolId); }, () => { ScenarioTestHelpers.DisableAutoScale(controller, context, testPoolId); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
public void TestUpdatePool() { BatchController controller = BatchController.NewInstance; string poolId = "testUpdate"; BatchAccountContext context = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-UpdatePool '{0}' '{1}'", commonAccountName, poolId) }); }, () => { context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, commonAccountName); ScenarioTestHelpers.CreateTestPool(controller, context, poolId, 0); }, () => { ScenarioTestHelpers.DeletePool(controller, context, poolId); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
public void TestCreateTaskCollection() { BatchController controller = BatchController.NewInstance; string jobId = "createTaskCollectionJob"; BatchAccountContext context = null; controller.RunPsTestWorkflow( _logger, () => { return(new string[] { string.Format("Test-CreateTaskCollection '{0}'", jobId) }); }, () => { context = new ScenarioTestContext(); ScenarioTestHelpers.CreateTestJob(controller, context, jobId); }, () => { ScenarioTestHelpers.DeleteJob(controller, context, jobId); }, MethodBase.GetCurrentMethod().ReflectedType?.ToString(), MethodBase.GetCurrentMethod().Name); }
public void TestDisableEnableTerminateJobSchedule() { BatchController controller = BatchController.NewInstance; string jobScheduleId = "testDisableEnableTerminateJobSchedule"; BatchAccountContext context = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-DisableEnableTerminateJobSchedule '{0}'", jobScheduleId) }); }, () => { context = new ScenarioTestContext(); ScenarioTestHelpers.CreateTestJobSchedule(controller, context, jobScheduleId, null); }, () => { ScenarioTestHelpers.DeleteJobSchedule(controller, context, jobScheduleId); }, MethodBase.GetCurrentMethod().ReflectedType?.ToString(), MethodBase.GetCurrentMethod().Name); }
public void TestRebootAndReimageComputeNode() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; string computeNodeId = null; string computeNodeId2 = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-RebootAndReimageComputeNode '{0}' '{1}' '{2}'", poolId, computeNodeId, computeNodeId2) }); }, () => { context = new ScenarioTestContext(); computeNodeId = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId, 0); computeNodeId2 = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId, 1); ScenarioTestHelpers.WaitForIdleComputeNode(controller, context, poolId, computeNodeId); ScenarioTestHelpers.WaitForIdleComputeNode(controller, context, poolId, computeNodeId2); }, null, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
public void TestAutoScaleActions() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; string poolId = "autoscalePool"; controller.RunPsTestWorkflow( _logger, () => { return(new string[] { string.Format("Test-AutoScaleActions '{0}'", poolId) }); }, () => { context = new ScenarioTestContext(); ScenarioTestHelpers.CreateTestPool(controller, context, poolId, targetDedicated: 0, targetLowPriority: 0); }, () => { ScenarioTestHelpers.DeletePool(controller, context, poolId); }, MethodBase.GetCurrentMethod().ReflectedType?.ToString(), MethodBase.GetCurrentMethod().Name); }
public void TestListTaskPipeline() { BatchController controller = BatchController.NewInstance; string jobId = "listTaskPipeJob"; string taskId = "testTask"; BatchAccountContext context = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-ListTaskPipeline '{0}' '{1}'", jobId, taskId) }); }, () => { context = new ScenarioTestContext(); ScenarioTestHelpers.CreateTestJob(controller, context, jobId); ScenarioTestHelpers.CreateTestTask(controller, context, jobId, taskId); }, () => { ScenarioTestHelpers.DeleteJob(controller, context, jobId); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
public void TestUpdateComputeNodeUser() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; string computeNodeId = null; string userName = "******"; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-UpdateComputeNodeUser '{0}' '{1}' '{2}'", poolId, computeNodeId, userName) }); }, () => { context = new ScenarioTestContext(); computeNodeId = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId); ScenarioTestHelpers.CreateComputeNodeUser(controller, context, poolId, computeNodeId, userName); }, () => { ScenarioTestHelpers.DeleteComputeNodeUser(controller, context, poolId, computeNodeId, userName); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
public void TestGetTaskById() { BatchController controller = BatchController.NewInstance; string jobId = "getTaskJob"; string taskId = "testTask"; BatchAccountContext context = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-GetTaskById '{0}' '{1}' '{2}'", accountName, jobId, taskId) }); }, () => { context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, accountName); ScenarioTestHelpers.CreateTestJob(controller, context, jobId); ScenarioTestHelpers.CreateTestTask(controller, context, jobId, taskId); }, () => { ScenarioTestHelpers.DeleteJob(controller, context, jobId); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
/// <summary> /// Uploads an application package to Storage /// </summary> public static ApplicationPackage CreateApplicationPackage(BatchController controller, BatchAccountContext context, string applicationName, string version, string filePath) { ApplicationPackage applicationPackage = null; if (HttpMockServer.Mode == HttpRecorderMode.Record) { applicationPackage = controller.BatchManagementClient.ApplicationPackage.Create( context.ResourceGroupName, context.AccountName, applicationName, version); CloudBlockBlob blob = new CloudBlockBlob(new Uri(applicationPackage.StorageUrl)); #if NETSTANDARD Task.Run(() => blob.UploadFromFileAsync(filePath)).Wait(); #else blob.UploadFromFile(filePath, FileMode.Open); #endif } return(applicationPackage); }
public static void WaitForSteadyPoolAllocation(BatchController controller, BatchAccountContext context, string poolId) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListPoolOptions options = new ListPoolOptions(context) { PoolId = poolId }; DateTime timeout = DateTime.Now.AddMinutes(5); PSCloudPool pool = client.ListPools(options).First(); while (pool.AllocationState != AllocationState.Steady) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for steady allocation state"); } Sleep(5000); pool = client.ListPools(options).First(); } }
public void TestRebootAndReimageComputeNode() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; string computeNodeId = null; string computeNodeId2 = null; controller.RunPsTestWorkflow( _logger, () => { return(new string[] { string.Format("Test-RebootAndReimageComputeNode '{0}' '{1}' '{2}'", poolId, computeNodeId, computeNodeId2) }); }, () => { context = new ScenarioTestContext(); computeNodeId = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId, 0); computeNodeId2 = ScenarioTestHelpers.GetComputeNodeId(controller, context, poolId, 1); ScenarioTestHelpers.WaitForIdleComputeNode(controller, context, poolId, computeNodeId); ScenarioTestHelpers.WaitForIdleComputeNode(controller, context, poolId, computeNodeId2); }, null, MethodBase.GetCurrentMethod().ReflectedType?.ToString(), MethodBase.GetCurrentMethod().Name); }
public void TestGetJobByName() { BatchController controller = BatchController.NewInstance; string workItemName = "testName"; string jobName = null; BatchAccountContext context = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-GetJobByName '{0}' '{1}' '{2}'", accountName, workItemName, jobName) }); }, () => { context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, accountName); ScenarioTestHelpers.CreateTestWorkItem(controller, context, workItemName); jobName = ScenarioTestHelpers.WaitForRecentJob(controller, context, workItemName); }, () => { ScenarioTestHelpers.DeleteWorkItem(controller, context, workItemName); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
public void IfJobSetsAutoFailure_ItCompletesWhenAnyTaskFails() { BatchController controller = BatchController.NewInstance; BatchAccountContext context = null; string poolId = "testPool"; string jobId = "testJobCompletesWhenTaskFails"; string taskId = "taskId-1"; PSCloudJob completedJob = null; controller.RunPsTestWorkflow( _logger, () => { return(new string[] { string.Format("IfJobSetsAutoFailure-ItCompletesWhenAnyTaskFails '{0}' '{1}' '{2}'", poolId, jobId, taskId) }); }, null, () => { context = new ScenarioTestContext(); completedJob = ScenarioTestHelpers.WaitForJobCompletion(controller, context, jobId, taskId); AssertJobIsCompleteDueToTaskFailure(completedJob); ScenarioTestHelpers.DeleteJob(controller, context, jobId); }, MethodBase.GetCurrentMethod().ReflectedType?.ToString(), MethodBase.GetCurrentMethod().Name); }
/// <summary> /// Waits for a compute node to get to the idle state /// </summary> public static void WaitForIdleComputeNode(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListComputeNodeOptions options = new ListComputeNodeOptions(context, poolId, null) { ComputeNodeId = computeNodeId }; DateTime timeout = DateTime.Now.AddMinutes(2); PSComputeNode computeNode = client.ListComputeNodes(options).First(); if (computeNode.State != ComputeNodeState.Idle) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for idle compute node"); } Sleep(5000); computeNode = client.ListComputeNodes(options).First(); } }
/// <summary> /// Waits for a recent job on a job schedule and returns its id. If a previous job is specified, this method waits until a new job is created. /// </summary> public static string WaitForRecentJob(BatchController controller, BatchAccountContext context, string jobScheduleId, string previousJob = null) { DateTime timeout = DateTime.Now.AddMinutes(2); BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListJobScheduleOptions options = new ListJobScheduleOptions(context) { JobScheduleId = jobScheduleId, Filter = null, MaxCount = Constants.DefaultMaxCount }; PSCloudJobSchedule jobSchedule = client.ListJobSchedules(options).First(); while (jobSchedule.ExecutionInformation.RecentJob == null || string.Equals(jobSchedule.ExecutionInformation.RecentJob.Id, previousJob, StringComparison.OrdinalIgnoreCase)) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for recent job"); } Sleep(5000); jobSchedule = client.ListJobSchedules(options).First(); } return(jobSchedule.ExecutionInformation.RecentJob.Id); }
/// <summary> /// Creates a test job schedule for use in Scenario tests. /// </summary> public static void CreateTestJobSchedule(BatchController controller, BatchAccountContext context, string jobScheduleId, TimeSpan?recurrenceInterval) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); PSJobSpecification jobSpecification = new PSJobSpecification(); jobSpecification.PoolInformation = new PSPoolInformation(); jobSpecification.PoolInformation.PoolId = SharedPool; PSSchedule schedule = new PSSchedule(); if (recurrenceInterval != null) { schedule = new PSSchedule(); schedule.RecurrenceInterval = recurrenceInterval; } NewJobScheduleParameters parameters = new NewJobScheduleParameters(context, jobScheduleId) { JobSpecification = jobSpecification, Schedule = schedule }; client.CreateJobSchedule(parameters); }
public static string WaitForOSVersionChange(BatchController controller, BatchAccountContext context, string poolId) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListPoolOptions options = new ListPoolOptions(context) { PoolId = poolId }; DateTime timeout = DateTime.Now.AddMinutes(5); PSCloudPool pool = client.ListPools(options).First(); while (pool.CloudServiceConfiguration.CurrentOSVersion != pool.CloudServiceConfiguration.TargetOSVersion) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for active state pool"); } Sleep(5000); pool = client.ListPools(options).First(); } return(pool.CloudServiceConfiguration.TargetOSVersion); }
/// <summary> /// Deletes a certificate. /// </summary> public static void WaitForCertificateToFailDeletion(BatchController controller, BatchAccountContext context, string thumbprintAlgorithm, string thumbprint) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListCertificateOptions parameters = new ListCertificateOptions(context) { ThumbprintAlgorithm = BatchTestHelpers.TestCertificateAlgorithm, Thumbprint = thumbprint }; PSCertificate cert = client.ListCertificates(parameters).First(); DateTime timeout = DateTime.Now.AddMinutes(2); while (cert.State != CertificateState.DeleteFailed) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for failed certificate deletion"); } Sleep(10000); cert = client.ListCertificates(parameters).First(); } }
/// <summary> /// Creates a test pool for use in Scenario tests. /// </summary> public static void CreateTestPool( BatchController controller, BatchAccountContext context, string poolId, int?targetDedicated, int?targetLowPriority, CertificateReference certReference = null, StartTask startTask = null) { PSCertificateReference[] certReferences = null; if (certReference != null) { certReferences = new PSCertificateReference[] { new PSCertificateReference(certReference) }; } PSStartTask psStartTask = null; if (startTask != null) { psStartTask = new PSStartTask(startTask); } PSCloudServiceConfiguration paasConfiguration = new PSCloudServiceConfiguration("4", "*"); NewPoolParameters parameters = new NewPoolParameters(context, poolId) { VirtualMachineSize = "small", CloudServiceConfiguration = paasConfiguration, TargetDedicatedComputeNodes = targetDedicated, TargetLowPriorityComputeNodes = targetLowPriority, CertificateReferences = certReferences, StartTask = psStartTask, InterComputeNodeCommunicationEnabled = true }; CreatePoolIfNotExists(controller, parameters); }
public void TestUpdateTask() { BatchController controller = BatchController.NewInstance; string jobId = "updateTaskJob"; string taskId = "testTask"; BatchAccountContext context = null; controller.RunPsTestWorkflow( () => { return(new string[] { string.Format("Test-UpdateTask '{0}' '{1}' '{2}'", accountName, jobId, taskId) }); }, () => { context = ScenarioTestHelpers.GetBatchAccountContextWithKeys(controller, accountName); ScenarioTestHelpers.CreateTestJob(controller, context, jobId); // Make the task long running so the constraints can be updated ScenarioTestHelpers.CreateTestTask(controller, context, jobId, taskId, "ping -t localhost -w 60"); }, () => { ScenarioTestHelpers.DeleteJob(controller, context, jobId); }, TestUtilities.GetCallingClass(), TestUtilities.GetCurrentMethodName()); }
/// <summary> /// Gets the CurrentDedicated count from a pool /// </summary> public static int GetPoolCurrentDedicated(BatchController controller, BatchAccountContext context, string poolId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListPoolOptions options = new ListPoolOptions(context, behaviors) { PoolId = poolId }; PSCloudPool pool = client.ListPools(options).First(); return pool.CurrentDedicated.Value; }
public static void WaitForSteadyPoolAllocation(BatchController controller, BatchAccountContext context, string poolId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListPoolOptions options = new ListPoolOptions(context, behaviors) { PoolId = poolId }; DateTime timeout = DateTime.Now.AddMinutes(2); PSCloudPool pool = client.ListPools(options).First(); while (pool.AllocationState != AllocationState.Steady) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for steady allocation state"); } Sleep(5000); pool = client.ListPools(options).First(); } }
/// <summary> /// Waits for a recent job on a workitem and returns its name. If a previous job is specified, this method waits until a new job is created. /// </summary> public static string WaitForRecentJob(BatchController controller, BatchAccountContext context, string workItemName, string previousJob = null) { DateTime timeout = DateTime.Now.AddMinutes(2); YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListWorkItemOptions options = new ListWorkItemOptions(context, behaviors) { WorkItemName = workItemName, Filter = null, MaxCount = Constants.DefaultMaxCount }; PSCloudWorkItem workItem = client.ListWorkItems(options).First(); while (workItem.ExecutionInformation.RecentJob == null || string.Equals(workItem.ExecutionInformation.RecentJob.Name, previousJob, StringComparison.OrdinalIgnoreCase)) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for recent job"); } Sleep(5000); workItem = client.ListWorkItems(options).First(); } return workItem.ExecutionInformation.RecentJob.Name; }
/// <summary> /// Waits for a compute node to get to the idle state /// </summary> public static void WaitForIdleComputeNode(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListComputeNodeOptions options = new ListComputeNodeOptions(context, poolId, null, behaviors) { ComputeNodeId = computeNodeId }; DateTime timeout = DateTime.Now.AddMinutes(2); PSComputeNode computeNode = client.ListComputeNodes(options).First(); if (computeNode.State != ComputeNodeState.Idle) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for idle compute node"); } Sleep(5000); computeNode = client.ListComputeNodes(options).First(); } }
/// <summary> /// Deletes a job used in a Scenario test. /// </summary> public static void DeleteJob(BatchController controller, BatchAccountContext context, string jobId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); client.DeleteJob(context, jobId, behaviors); }
/// <summary> /// Creates a test user for use in Scenario tests. /// </summary> public static void CreateTestUser(BatchController controller, BatchAccountContext context, string poolName, string vmName, string vmUserName) { YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); NewVMUserParameters parameters = new NewVMUserParameters(context, poolName, vmName, null, behaviors) { VMUserName = vmUserName, Password = "******", }; client.CreateVMUser(parameters); }
/// <summary> /// Creates a test job for use in Scenario tests. /// </summary> public static void CreateTestJob(BatchController controller, BatchAccountContext context, string jobId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); PSPoolInformation poolInfo = new PSPoolInformation(); poolInfo.PoolId = SharedPool; NewJobParameters parameters = new NewJobParameters(context, jobId, behaviors) { PoolInformation = poolInfo }; client.CreateJob(parameters); }
/// <summary> /// Waits for the specified task to complete /// </summary> public static void WaitForTaskCompletion(BatchController controller, BatchAccountContext context, string workItemName, string jobName, string taskName) { YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListTaskOptions options = new ListTaskOptions(context, workItemName, jobName, null, behaviors) { TaskName = taskName }; IEnumerable<PSCloudTask> tasks = client.ListTasks(options); ITaskStateMonitor monitor = context.BatchOMClient.OpenToolbox().CreateTaskStateMonitor(); monitor.WaitAll(tasks.Select(t => t.omObject), TaskState.Completed, TimeSpan.FromMinutes(2), null, behaviors); }
/// <summary> /// Adds a test certificate for use in Scenario tests. Returns the thumbprint of the cert. /// </summary> public static string AddTestCertificate(BatchController controller, BatchAccountContext context, string filePath) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); X509Certificate2 cert = new X509Certificate2(filePath); ListCertificateOptions getParameters = new ListCertificateOptions(context) { ThumbprintAlgorithm = BatchTestHelpers.TestCertificateAlgorithm, Thumbprint = cert.Thumbprint, Select = "thumbprint,state" }; try { PSCertificate existingCert = client.ListCertificates(getParameters).FirstOrDefault(); DateTime start = DateTime.Now; DateTime end = start.AddMinutes(5); // Cert might still be deleting from other tests, so we wait for the delete to finish. while (existingCert != null && existingCert.State == CertificateState.Deleting) { if (DateTime.Now > end) { throw new TimeoutException("Timed out waiting for existing cert to be deleted."); } Sleep(5000); existingCert = client.ListCertificates(getParameters).FirstOrDefault(); } } catch (AggregateException ex) { foreach (Exception inner in ex.InnerExceptions) { BatchException batchEx = inner as BatchException; // When the cert doesn't exist, we get a 404 error. For all other errors, throw. if (batchEx == null || !batchEx.Message.Contains("CertificateNotFound")) { throw; } } } NewCertificateParameters parameters = new NewCertificateParameters(context, null, cert.RawData); client.AddCertificate(parameters); return cert.Thumbprint; }
/// <summary> /// Deletes a workitem used in a Scenario test. /// </summary> public static void DeleteWorkItem(BatchController controller, BatchAccountContext context, string workItemName) { YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); client.DeleteWorkItem(context, workItemName, behaviors); }
/// <summary> /// Gets the number of pools under the specified account /// </summary> public static int GetPoolCount(BatchController controller, BatchAccountContext context) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListPoolOptions options = new ListPoolOptions(context, behaviors); return client.ListPools(options).Count(); }
/// <summary> /// Creates a test task for use in Scenario tests. /// </summary> public static void CreateTestTask(BatchController controller, BatchAccountContext context, string jobId, string taskId, string cmdLine = "cmd /c dir /s") { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); NewTaskParameters parameters = new NewTaskParameters(context, jobId, null, taskId, behaviors) { CommandLine = cmdLine, RunElevated = true }; client.CreateTask(parameters); }
/// <summary> /// Creates a test job schedule for use in Scenario tests. /// </summary> public static void CreateTestJobSchedule(BatchController controller, BatchAccountContext context, string jobScheduleId, TimeSpan? recurrenceInterval) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); PSJobSpecification jobSpecification = new PSJobSpecification(); jobSpecification.PoolInformation = new PSPoolInformation(); jobSpecification.PoolInformation.PoolId = SharedPool; PSSchedule schedule = new PSSchedule(); if (recurrenceInterval != null) { schedule = new PSSchedule(); schedule.RecurrenceInterval = recurrenceInterval; } NewJobScheduleParameters parameters = new NewJobScheduleParameters(context, jobScheduleId, behaviors) { JobSpecification = jobSpecification, Schedule = schedule }; client.CreateJobSchedule(parameters); }
/// <summary> /// Deletes a user used in a Scenario test. /// </summary> public static void DeleteUser(BatchController controller, BatchAccountContext context, string poolName, string vmName, string vmUserName) { YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); VMUserOperationParameters parameters = new VMUserOperationParameters(context, poolName, vmName, vmUserName, behaviors); client.DeleteVMUser(parameters); }
/// <summary> /// Waits for a recent job on a job schedule and returns its id. If a previous job is specified, this method waits until a new job is created. /// </summary> public static string WaitForRecentJob(BatchController controller, BatchAccountContext context, string jobScheduleId, string previousJob = null) { DateTime timeout = DateTime.Now.AddMinutes(2); RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListJobScheduleOptions options = new ListJobScheduleOptions(context, behaviors) { JobScheduleId = jobScheduleId, Filter = null, MaxCount = Constants.DefaultMaxCount }; PSCloudJobSchedule jobSchedule = client.ListJobSchedules(options).First(); while (jobSchedule.ExecutionInformation.RecentJob == null || string.Equals(jobSchedule.ExecutionInformation.RecentJob.Id, previousJob, StringComparison.OrdinalIgnoreCase)) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for recent job"); } Sleep(5000); jobSchedule = client.ListJobSchedules(options).First(); } return jobSchedule.ExecutionInformation.RecentJob.Id; }
/// <summary> /// Cleans up an account and resource group used in a Scenario test. /// </summary> public static void CleanupTestAccount(BatchController controller, string resourceGroupName, string accountName) { controller.BatchManagementClient.Accounts.Delete(resourceGroupName, accountName); controller.ResourceManagementClient.ResourceGroups.Delete(resourceGroupName); }
/// <summary> /// Waits for the specified task to complete /// </summary> public static void WaitForTaskCompletion(BatchController controller, BatchAccountContext context, string jobId, string taskId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListTaskOptions options = new ListTaskOptions(context, jobId, null, behaviors) { TaskId = taskId }; IEnumerable<PSCloudTask> tasks = client.ListTasks(options); // Save time by not waiting during playback scenarios if (HttpMockServer.Mode == HttpRecorderMode.Record) { TaskStateMonitor monitor = context.BatchOMClient.Utilities.CreateTaskStateMonitor(); monitor.WaitAll(tasks.Select(t => t.omObject), TaskState.Completed, TimeSpan.FromMinutes(2), null); } }
/// <summary> /// Creates a compute node user for use in Scenario tests. /// </summary> public static void CreateComputeNodeUser(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId, string computeNodeUserName) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); NewComputeNodeUserParameters parameters = new NewComputeNodeUserParameters(context, poolId, computeNodeId, null) { ComputeNodeUserName = computeNodeUserName, Password = "******", }; client.CreateComputeNodeUser(parameters); }
/// <summary> /// Gets the id of a compute node in the specified pool /// </summary> public static string GetComputeNodeId(BatchController controller, BatchAccountContext context, string poolId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListComputeNodeOptions options = new ListComputeNodeOptions(context, poolId, null, behaviors); return client.ListComputeNodes(options).First().Id; }
/// <summary> /// Creates a test workitem for use in Scenario tests. /// </summary> public static void CreateTestWorkItem(BatchController controller, BatchAccountContext context, string workItemName) { CreateTestWorkItem(controller, context, workItemName, null); }
/// <summary> /// Creates a test user for use in Scenario tests. /// </summary> public static void CreateComputeNodeUser(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId, string computeNodeUserName) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); NewComputeNodeUserParameters parameters = new NewComputeNodeUserParameters(context, poolId, computeNodeId, null, behaviors) { ComputeNodeUserName = computeNodeUserName, Password = "******", }; client.CreateComputeNodeUser(parameters); }
public static void DisableAutoScale(BatchController controller, BatchAccountContext context, string poolId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); PoolOperationParameters parameters = new PoolOperationParameters(context, poolId, null, behaviors); client.DisableAutoScale(parameters); }
public static string WaitForOSVersionChange(BatchController controller, BatchAccountContext context, string poolId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ListPoolOptions options = new ListPoolOptions(context, behaviors) { PoolId = poolId }; DateTime timeout = DateTime.Now.AddMinutes(2); PSCloudPool pool = client.ListPools(options).First(); while (pool.CurrentOSVersion != pool.TargetOSVersion) { if (DateTime.Now > timeout) { throw new TimeoutException("Timed out waiting for active state pool"); } Sleep(5000); pool = client.ListPools(options).First(); } return pool.TargetOSVersion; }
/// <summary> /// Creates a test pool for use in Scenario tests. /// </summary> public static void CreateTestPool(BatchController controller, BatchAccountContext context, string poolName) { YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); NewPoolParameters parameters = new NewPoolParameters(context, poolName, behaviors) { OSFamily = "4", TargetOSVersion = "*", TargetDedicated = 1 }; client.CreatePool(parameters); }
/// <summary> /// Creates a test pool for use in Scenario tests. /// </summary> public static void CreateTestPool(BatchController controller, BatchAccountContext context, string poolId, int targetDedicated) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); NewPoolParameters parameters = new NewPoolParameters(context, poolId, behaviors) { VirtualMachineSize = "small", OSFamily = "4", TargetOSVersion = "*", TargetDedicated = targetDedicated, }; client.CreatePool(parameters); }
/// <summary> /// Deletes a compute node user for use in Scenario tests. /// </summary> public static void DeleteComputeNodeUser(BatchController controller, BatchAccountContext context, string poolId, string computeNodeId, string computeNodeUserName) { BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); ComputeNodeUserOperationParameters parameters = new ComputeNodeUserOperationParameters(context, poolId, computeNodeId, computeNodeUserName); client.DeleteComputeNodeUser(parameters); }
public static void EnableAutoScale(BatchController controller, BatchAccountContext context, string poolId) { RequestInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); string formula = "$TargetDedicated=2"; AutoScaleParameters parameters = new AutoScaleParameters(context, poolId, null, formula, behaviors); client.EnableAutoScale(parameters); }
/// <summary> /// Creates a test workitem for use in Scenario tests. /// </summary> public static void CreateTestWorkItem(BatchController controller, BatchAccountContext context, string workItemName, TimeSpan? recurrenceInterval) { YieldInjectionInterceptor interceptor = CreateHttpRecordingInterceptor(); BatchClientBehavior[] behaviors = new BatchClientBehavior[] { interceptor }; BatchClient client = new BatchClient(controller.BatchManagementClient, controller.ResourceManagementClient); PSJobExecutionEnvironment jobExecutionEnvironment = new PSJobExecutionEnvironment(); jobExecutionEnvironment.PoolName = DefaultPoolName; PSWorkItemSchedule schedule = null; if (recurrenceInterval != null) { schedule = new PSWorkItemSchedule(); schedule.RecurrenceInterval = recurrenceInterval; } NewWorkItemParameters parameters = new NewWorkItemParameters(context, workItemName, behaviors) { JobExecutionEnvironment = jobExecutionEnvironment, Schedule = schedule }; client.CreateWorkItem(parameters); }