public FormServer() { InitializeComponent(); _syncContextHelper = new SynchronizationContextHelper(); _accountNames = new BindingList <string>(); _isShutdown = true; }
private void OnInkPointerReleasing(CoreInkIndependentInputSource sender, PointerEventArgs args) { SynchronizationContextHelper.Execute( this.InkPointerReleasing, this, new InkPointerEventArgs(args.CurrentPoint.GetPointerId(), args)); }
public void CanCreateJobWithUsesTaskDependencies() { void test() { using BatchClient batchCli = TestUtilities.OpenBatchClientFromEnvironmentAsync().Result; string jobId = GenerateJobId(); try { CloudJob cloudJob = batchCli.JobOperations.CreateJob(jobId, new PoolInformation()); cloudJob.PoolInformation = new PoolInformation() { PoolId = poolFixture.PoolId }; cloudJob.UsesTaskDependencies = true; cloudJob.Commit(); var boundJob = batchCli.JobOperations.GetJob(jobId); Assert.True(boundJob.UsesTaskDependencies); } finally { TestUtilities.DeleteJobIfExistsAsync(batchCli, jobId).Wait(); } } SynchronizationContextHelper.RunTest(test, TestTimeout); }
public async Task BatchRequestWithShortClientSideTimeoutAndRetries() { const int maxRetries = 5; int actualRequestCount = 0; //The ThrowsAnyAsync must be outside the RunTestAsync or it will deadlock await Assert.ThrowsAnyAsync <OperationCanceledException>(async() => await SynchronizationContextHelper.RunTestAsync(async() => { using (BatchClient client = await TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment(), addDefaultRetryPolicy: false)) { client.CustomBehaviors.Add(RetryPolicyProvider.LinearRetryProvider(TimeSpan.FromMilliseconds(250), maxRetries)); List <BatchClientBehavior> customBehaviors = new List <BatchClientBehavior>(); customBehaviors.Add(new RequestInterceptor((req) => { //Set the timeout to something small so it is guaranteed to expire before the service has responded req.Timeout = TimeSpan.FromMilliseconds(25); var castRequest = (JobGetBatchRequest)req; Func <CancellationToken, Task <AzureOperationResponse <Microsoft.Azure.Batch.Protocol.Models.CloudJob, Microsoft.Azure.Batch.Protocol.Models.JobGetHeaders> > > oldFunc = castRequest.ServiceRequestFunc; castRequest.ServiceRequestFunc = async(token) => { actualRequestCount++; //Count the number of calls to the func return(await oldFunc(token).ConfigureAwait(false)); }; })); await client.JobOperations.GetJobAsync("Foo", additionalBehaviors: customBehaviors).ConfigureAwait(false); } }, TestTimeout)); Assert.Equal(maxRetries, actualRequestCount - 1); //Ensure that the number of retries is as expected }
public async Task Job_CanAddJobWithJobManagerAndAllowLowPriorityTrue() { Func <Task> test = async() => { using (BatchClient batchCli = await TestUtilities.OpenBatchClientFromEnvironmentAsync().ConfigureAwait(false)) { string jobId = "TestJobWithLowPriJobManager-" + TestUtilities.GetMyName(); try { PoolInformation poolInfo = new PoolInformation() { PoolId = "Fake" }; CloudJob unboundJob = batchCli.JobOperations.CreateJob(jobId, poolInfo); unboundJob.JobManagerTask = new JobManagerTask("foo", "cmd /c echo hi") { AllowLowPriorityNode = true }; await unboundJob.CommitAsync().ConfigureAwait(false); await unboundJob.RefreshAsync().ConfigureAwait(false); Assert.True(unboundJob.JobManagerTask.AllowLowPriorityNode); } finally { await TestUtilities.DeleteJobIfExistsAsync(batchCli, jobId); } } }; await SynchronizationContextHelper.RunTestAsync(test, TestTimeout); }
public void OnDeviceConnected(object sender, WebsocketEventArgs evt) { SynchronizationContextHelper.SendMainSyncContext(() => { showNotifyIconMenu(evt.ctx); }); }
public void SyncWithActionCapturesException() { // Arrange InvalidOperationException exception = new InvalidOperationException("Some exception text."); // Act Mock <SynchronizationContext> mockSyncContext = new Mock <SynchronizationContext>(); mockSyncContext .Expect(sc => sc.Send(It.IsAny <SendOrPostCallback>(), null)) .Callback( delegate(SendOrPostCallback d, object state) { try { d(state); } catch { // swallow exceptions, just like AspNetSynchronizationContext } }); // Act & assert ExceptionHelper.ExpectInvalidOperationException( delegate { SynchronizationContextHelper.Sync(mockSyncContext.Object, () => { throw exception; }); }, @"Some exception text."); }
public void ReadClientRequestIdAndRequestIdFromException() { void test() { using BatchClient batchCli = TestUtilities.OpenBatchClient(TestUtilities.GetCredentialsFromEnvironment()); Guid myClientRequestid = Guid.NewGuid(); RequestInterceptor clientRequestIdGenerator = new ClientRequestIdProvider( request => myClientRequestid); RequestInterceptor setReturnClientRequestId = new RequestInterceptor( request => { request.Options.ReturnClientRequestId = true; }); BatchException batchException = TestUtilities.AssertThrowsAsync <BatchException>(async() => await batchCli.JobOperations.GetJobAsync("this-job-doesnt-exist", additionalBehaviors: new[] { clientRequestIdGenerator, setReturnClientRequestId })).Result; Assert.NotNull(batchException.RequestInformation); Assert.NotNull(batchException.RequestInformation.BatchError); Assert.NotNull(batchException.RequestInformation.BatchError.Message); Assert.Equal(BatchErrorCodeStrings.JobNotFound, batchException.RequestInformation.BatchError.Code); Assert.Equal(HttpStatusCode.NotFound, batchException.RequestInformation.HttpStatusCode); Assert.Contains("The specified job does not exist", batchException.RequestInformation.BatchError.Message.Value); Assert.Equal(myClientRequestid, batchException.RequestInformation.ClientRequestId); Assert.NotNull(batchException.RequestInformation.ServiceRequestId); Assert.Equal("The specified job does not exist.", batchException.RequestInformation.HttpStatusMessage); } SynchronizationContextHelper.RunTest(test, TestTimeout); }
public void Bug1771070_1771072_JobAndPoolLifetimeStats() { Action test = () => { using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result) { JobStatistics jobStatistics = batchCli.JobOperations.GetAllJobsLifetimeStatistics(); PoolStatistics poolStatistics = batchCli.PoolOperations.GetAllPoolsLifetimeStatistics(); Assert.NotNull(jobStatistics); Assert.NotNull(poolStatistics); //Since we cannot really validate that the stats returned by the service are correct, the best we can do is make sure we get some //Dump a few properties from each stats bag to make sure they are populated this.testOutputHelper.WriteLine("JobScheduleStatistics.StartTime: {0}", jobStatistics.StartTime); this.testOutputHelper.WriteLine("JobScheduleStatistics.LastUpdateTime: {0}", jobStatistics.LastUpdateTime); this.testOutputHelper.WriteLine("JobScheduleStatistics.NumSucceededTasks: {0}", jobStatistics.SucceededTaskCount); this.testOutputHelper.WriteLine("JobScheduleStatistics.UserCpuTime: {0}", jobStatistics.UserCpuTime); this.testOutputHelper.WriteLine("PoolStatistics.StartTime: {0}", poolStatistics.StartTime); this.testOutputHelper.WriteLine("PoolStatistics.LastUpdateTime: {0}", poolStatistics.LastUpdateTime); this.testOutputHelper.WriteLine("PoolStatistics.ResourceStatistics.AvgMemory: {0}", poolStatistics.ResourceStatistics.AverageMemoryGiB); this.testOutputHelper.WriteLine("PoolStatistics.UsageStatistics.DedicatedCoreTime: {0}", poolStatistics.UsageStatistics.DedicatedCoreTime); } }; SynchronizationContextHelper.RunTest(test, TestTimeout); }
public async Task AddTasksFailIfPoisonTaskTooLarge() { const string testName = "AddTasksFailIfPoisonTaskTooLarge"; List <ResourceFile> resourceFiles = new List <ResourceFile>(); ResourceFile resourceFile; // If this test fails try increasing the size of the Task in case maximum size increase for (int i = 0; i < 10000; i++) { resourceFile = ResourceFile.FromUrl("https://mystorageaccount.blob.core.windows.net/files/resourceFile" + i, "resourceFile" + i); resourceFiles.Add(resourceFile); } await SynchronizationContextHelper.RunTestAsync(async() => { using (BatchClient batchCli = await TestUtilities.OpenBatchClientFromEnvironmentAsync()) { var exception = await TestUtilities.AssertThrowsAsync <ParallelOperationsException>( async() => await this.AddTasksSimpleTestAsync(batchCli, testName, 1, resourceFiles: resourceFiles).ConfigureAwait(false)).ConfigureAwait(false); var innerException = exception.InnerException; Assert.IsType <BatchException>(innerException); Assert.Equal(((BatchException)innerException).RequestInformation.BatchError.Code, BatchErrorCodeStrings.RequestBodyTooLarge); } }, TestTimeout); }
public void OnTotalCountUpdated(object sender, WebsocketEventArgs evt) { SynchronizationContextHelper.SendMainSyncContext(() => { updateNotifyIconMenu(evt.ctx); }); }
public async Task ApplicationPackageReferencesOnCloudTaskAreRoundtripped() { string jobId = Constants.DefaultConveniencePrefix + TestUtilities.GetMyName() + "-APROnCloudTaskAreRoundtripped"; string taskId = "task-id"; const string applicationId = "blender"; const string applicationVerson = "beta"; Func <Task> test = async() => { using (BatchClient client = await TestUtilities.OpenBatchClientFromEnvironmentAsync().ConfigureAwait(false)) { var poolInfo = new PoolInformation { AutoPoolSpecification = new AutoPoolSpecification { PoolSpecification = new PoolSpecification { CloudServiceConfiguration = new CloudServiceConfiguration(PoolFixture.OSFamily), VirtualMachineSize = PoolFixture.VMSize, }, PoolLifetimeOption = PoolLifetimeOption.Job } }; try { CloudJob job = client.JobOperations.CreateJob(jobId, poolInfo); await job.CommitAsync().ConfigureAwait(false); var boundJob = await client.JobOperations.GetJobAsync(jobId).ConfigureAwait(false); CloudTask cloudTask = new CloudTask(taskId, "cmd /c ping 127.0.0.1") { ApplicationPackageReferences = new[] { new ApplicationPackageReference { ApplicationId = applicationId, Version = applicationVerson } } }; await boundJob.AddTaskAsync(cloudTask).ConfigureAwait(false); CloudTask boundCloudTask = await boundJob.GetTaskAsync(taskId).ConfigureAwait(false); Assert.Equal(applicationId, boundCloudTask.ApplicationPackageReferences.Single().ApplicationId); Assert.Equal(applicationVerson, boundCloudTask.ApplicationPackageReferences.Single().Version); } finally { TestUtilities.DeleteJobIfExistsAsync(client, jobId).Wait(); } } }; await SynchronizationContextHelper.RunTestAsync(test, TestTimeout); }
public void Bug2338301_CheckStreamPositionAfterFileRead() { Action test = () => { using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result) { JobOperations jobOperations = batchCli.JobOperations; { string jobId = "Bug2338301Job-" + TestUtilities.GetMyName(); try { const string taskId = "hiWorld"; // // Create the job // CloudJob unboundJob = jobOperations.CreateJob(jobId, new PoolInformation() { PoolId = this.poolFixture.PoolId }); unboundJob.Commit(); CloudJob boundJob = jobOperations.GetJob(jobId); CloudTask myTask = new CloudTask(taskId, "cmd /c echo hello world"); boundJob.AddTask(myTask); this.testOutputHelper.WriteLine("Initial job commit()"); // // Wait for task to go to completion // Utilities utilities = batchCli.Utilities; TaskStateMonitor taskStateMonitor = utilities.CreateTaskStateMonitor(); taskStateMonitor.WaitAll( boundJob.ListTasks(), Microsoft.Azure.Batch.Common.TaskState.Completed, TimeSpan.FromMinutes(3)); CloudTask boundTask = boundJob.GetTask(taskId); //Get the task file const string fileToGet = "stdout.txt"; NodeFile file = boundTask.GetNodeFile(fileToGet); //Download the file data string result = file.ReadAsString(); Assert.True(result.Length > 0); } finally { jobOperations.DeleteJob(jobId); } } } }; SynchronizationContextHelper.RunTest(test, TestTimeout); }
public void TestOMJobPrepReleaseRunOnNaiveComputeNode() { string jobId = "TestOMJobPrepReleaseRunOnNaiveComputeNode-" + TestUtilities.GetMyName(); Action test = () => { using (BatchClient client = TestUtilities.OpenBatchClient(TestUtilities.GetCredentialsFromEnvironment())) { try { // create job with prep/release { CloudJob unboundJob = client.JobOperations.CreateJob(jobId, null); unboundJob.PoolInformation = new PoolInformation(); unboundJob.PoolInformation.PoolId = this.poolFixture.PoolId; // add the jobPrep task to the job { JobPreparationTask prep = new JobPreparationTask("cmd /c echo JobPrep!!"); unboundJob.JobPreparationTask = prep; prep.WaitForSuccess = true; // be explicit even though this is the default. need JP/JP to not run } // add a jobRelease task to the job { JobReleaseTask relTask = new JobReleaseTask(JobReleaseTaskCommandLine); unboundJob.JobReleaseTask = relTask; } // add the job to the service unboundJob.Commit(); } // the victim nodes. pool should have size 1. List <ComputeNode> computeNodes = client.PoolOperations.ListComputeNodes(this.poolFixture.PoolId).ToList(); Assert.Single(computeNodes); // now we have a job with zero tasks... lets call get-status methods // call it List <JobPreparationAndReleaseTaskExecutionInformation> jrStatusList = client.JobOperations.ListJobPreparationAndReleaseTaskStatus(jobId).ToList(); JobPreparationAndReleaseTaskExecutionInformation prepAndReleaseStatus = jrStatusList.FirstOrDefault(); Assert.Null(prepAndReleaseStatus); } finally { // cleanup TestUtilities.DeleteJobIfExistsAsync(client, jobId).Wait(); } } }; SynchronizationContextHelper.RunTest(test, TestTimeout); }
public async Task ComputeNodeUploadLogs() { Func <Task> test = async() => { using (BatchClient batchCli = TestUtilities.OpenBatchClientFromEnvironmentAsync().Result) { const string containerName = "computenodelogscontainer"; // Generate a storage container URL StagingStorageAccount storageAccount = TestUtilities.GetStorageCredentialsFromEnvironment(); BlobServiceClient blobClient = BlobUtilities.GetBlobServiceClient(storageAccount); BlobContainerClient containerClient = BlobUtilities.GetBlobContainerClient(containerName, blobClient, storageAccount); try { containerClient.CreateIfNotExists(); string sasUri = BlobUtilities.GetWriteableSasUri(containerClient, storageAccount); var blobs = containerClient.GetAllBlobs(); // Ensure that there are no items in the container to begin with Assert.Empty(blobs); var startTime = DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(5)); var node = batchCli.PoolOperations.ListComputeNodes(this.poolFixture.PoolId).First(); var result = batchCli.PoolOperations.UploadComputeNodeBatchServiceLogs( this.poolFixture.PoolId, node.Id, sasUri, startTime); Assert.NotEqual(0, result.NumberOfFilesUploaded); Assert.NotEmpty(result.VirtualDirectoryName); // Allow up to 2m for files to get uploaded DateTime timeoutAt = DateTime.UtcNow.AddMinutes(2); while (DateTime.UtcNow < timeoutAt) { blobs = containerClient.GetAllBlobs(); if (blobs.Any()) { break; } } Assert.NotEmpty(blobs); } finally { await containerClient.DeleteIfExistsAsync(); } } }; await SynchronizationContextHelper.RunTestAsync(test, TestTimeout); }
public async Task Bug1360227_AddTasksBatchFailure(bool useJobOperations) { const string testName = "Bug1360227_AddTasksBatchFailure"; int count = 0; const int countToFailAt = 102; const int taskCount = 407; HashSet <string> taskIdsExpectedToFail = new HashSet <string>(); Func <AddTaskResult, CancellationToken, AddTaskResultStatus> resultHandlerFunc = (result, token) => { this.testOutputHelper.WriteLine("Task: {0} got status code: {1}", result.TaskId, result.Status); ++count; if (taskIdsExpectedToFail.Contains(result.TaskId)) { return(AddTaskResultStatus.Retry); } else { if (count >= countToFailAt) { taskIdsExpectedToFail.Add(result.TaskId); this.testOutputHelper.WriteLine("Forcing a failure"); //Throw an exception to cause a failure from the customers result handler -- this is a supported scenario which will //terminate the add task operation throw new HttpRequestException("Test"); } else { return(AddTaskResultStatus.Success); } } }; await SynchronizationContextHelper.RunTestAsync(async() => { using (BatchClient batchCli = await TestUtilities.OpenBatchClientFromEnvironmentAsync()) { BatchClientParallelOptions parallelOptions = new BatchClientParallelOptions() { MaxDegreeOfParallelism = 2 }; var exception = await TestUtilities.AssertThrowsAsync <ParallelOperationsException>( async() => await this.AddTasksSimpleTestAsync( batchCli, testName, taskCount, parallelOptions, resultHandlerFunc, useJobOperations: useJobOperations).ConfigureAwait(false)).ConfigureAwait(false); Assert.IsType <HttpRequestException>(exception.InnerException); } }, TestTimeout); }
public async Task JobSchedulePatch() { Func <Task> test = async() => { using (BatchClient batchCli = await TestUtilities.OpenBatchClientFromEnvironmentAsync().ConfigureAwait(false)) { string jobScheduleId = "TestPatchJobSchedule-" + TestUtilities.GetMyName(); const string newJobManagerCommandLine = "cmd /c dir"; const string metadataKey = "Foo"; const string metadataValue = "Bar"; TimeSpan newRecurrenceInterval = TimeSpan.FromDays(2); try { CloudJobSchedule jobSchedule = batchCli.JobScheduleOperations.CreateJobSchedule( jobScheduleId, new Schedule() { RecurrenceInterval = TimeSpan.FromDays(1) }, new JobSpecification(new PoolInformation() { PoolId = "DummyPool" }) { JobManagerTask = new JobManagerTask(id: "Foo", commandLine: "Foo") }); await jobSchedule.CommitAsync().ConfigureAwait(false); await jobSchedule.RefreshAsync().ConfigureAwait(false); jobSchedule.JobSpecification.JobManagerTask.CommandLine = newJobManagerCommandLine; jobSchedule.Metadata = new List <MetadataItem>() { new MetadataItem(metadataKey, metadataValue) }; jobSchedule.Schedule.RecurrenceInterval = newRecurrenceInterval; await jobSchedule.CommitChangesAsync().ConfigureAwait(false); await jobSchedule.RefreshAsync().ConfigureAwait(false); Assert.Equal(newRecurrenceInterval, jobSchedule.Schedule.RecurrenceInterval); Assert.Equal(newJobManagerCommandLine, jobSchedule.JobSpecification.JobManagerTask.CommandLine); Assert.Equal(metadataKey, jobSchedule.Metadata.Single().Name); Assert.Equal(metadataValue, jobSchedule.Metadata.Single().Value); } finally { await TestUtilities.DeleteJobScheduleIfExistsAsync(batchCli, jobScheduleId).ConfigureAwait(false); } } }; await SynchronizationContextHelper.RunTestAsync(test, TestTimeout); }
public void HelloWorld() { void test() { using BatchClient batchCli = TestUtilities.OpenBatchClient(TestUtilities.GetCredentialsFromEnvironment()); TestUtilities.HelloWorld(batchCli, testOutputHelper, poolFixture.Pool, out string job, out string task); } SynchronizationContextHelper.RunTest(test, TestTimeout); }
public void TestComputeNodeUserIaas() { Action test = () => { using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result) { CloudPool sharedPool = this.poolFixture.Pool; List <string> cnuNamesToDelete = new List <string>(); // pick a compute node to victimize with user accounts var nodes = sharedPool.ListComputeNodes().ToList(); ComputeNode cn = nodes[0]; try { ComputeNodeUser bob = batchCli.PoolOperations.CreateComputeNodeUser(sharedPool.Id, cn.Id); bob.Name = "bob"; bob.ExpiryTime = DateTime.UtcNow + TimeSpan.FromHours(25); bob.Password = "******"; bob.SshPublicKey = "base64=="; cnuNamesToDelete.Add(bob.Name); // remember to clean this up bob.Commit(ComputeNodeUserCommitSemantics.AddUser); bob.SshPublicKey = "base65=="; bob.Commit(ComputeNodeUserCommitSemantics.UpdateUser); // TODO: need to close the loop on this somehow... move to unit/interceptor-based? // currently the server is timing out. } finally { // clear any old accounts try { foreach (string curCNUName in cnuNamesToDelete) { this.testOutputHelper.WriteLine("TestComputeNodeUserIAAS attempting to delete the following <nodeid,user>: <{0},{1}>", cn.Id, curCNUName); cn.DeleteComputeNodeUser(curCNUName); } } catch (Exception ex) { this.testOutputHelper.WriteLine("TestComputeNodeUserIAAS: exception deleting user account. ex: " + ex.ToString()); } } } }; SynchronizationContextHelper.RunTest(test, TestTimeout); }
public async Task End2EndApplicationPackageScenario() { string accountName = TestCommon.Configuration.BatchAccountName; Func <Task> test = async() => { var poolId = "app-ref-test" + Guid.NewGuid(); using (BatchClient client = await TestUtilities.OpenBatchClientFromEnvironmentAsync()) { using (var mgmtClient = IntegrationTestCommon.OpenBatchManagementClient()) { // Give the application a display name await mgmtClient.Application.UpdateAsync(TestCommon.Configuration.BatchAccountResourceGroup, accountName, ApplicationId, new UpdateApplicationParameters { AllowUpdates = true, DefaultVersion = ApplicationIntegrationCommon.Version, DisplayName = DisplayName }).ConfigureAwait(false); List <ApplicationSummary> applicationSummaries = await client.ApplicationOperations.ListApplicationSummaries().ToListAsync().ConfigureAwait(false); ApplicationSummary applicationSummary = applicationSummaries.First(); Assert.Equal(ApplicationIntegrationCommon.Version, applicationSummary.Versions.First()); Assert.Equal(ApplicationId, applicationSummary.Id); Assert.Equal(DisplayName, applicationSummary.DisplayName); ApplicationSummary getApplicationSummary = await client.ApplicationOperations.GetApplicationSummaryAsync(applicationSummary.Id).ConfigureAwait(false); Assert.Equal(getApplicationSummary.Id, applicationSummary.Id); Assert.Equal(getApplicationSummary.Versions.Count(), applicationSummary.Versions.Count()); Assert.Equal(getApplicationSummary.DisplayName, applicationSummary.DisplayName); var appPackage = await mgmtClient.ApplicationPackage.GetAsync( TestCommon.Configuration.BatchAccountResourceGroup, accountName, ApplicationId, ApplicationIntegrationCommon.Version).ConfigureAwait(false); Assert.Equal(PackageState.Active, appPackage.State); Assert.Equal(ApplicationIntegrationCommon.Version, appPackage.Version); Assert.Equal(ApplicationId, appPackage.Id); var application = await mgmtClient.Application.GetAsync(TestCommon.Configuration.BatchAccountResourceGroup, accountName, ApplicationId).ConfigureAwait(false); Assert.Equal(ApplicationIntegrationCommon.Version, application.DefaultVersion); Assert.Equal(ApplicationId, application.Id); await AssertPoolWasCreatedWithApplicationReferences(client, poolId, ApplicationId).ConfigureAwait(false); } } }; await SynchronizationContextHelper.RunTestAsync(test, LongRunningTestTimeout); }
public void SetUpdateJobConditionalHeader() { Action test = () => { using (BatchClient batchCli = TestUtilities.OpenBatchClientFromEnvironmentAsync().Result) { string jobId = "JobConditionalHeaders-" + TestUtilities.GetMyName(); try { PoolInformation poolInfo = new PoolInformation() { PoolId = "Fake" }; CloudJob unboundJob = batchCli.JobOperations.CreateJob(jobId, poolInfo); unboundJob.Commit(); CloudJob boundJob = batchCli.JobOperations.GetJob(jobId); string capturedEtag1 = boundJob.ETag; this.testOutputHelper.WriteLine("Etag is: {0}", capturedEtag1); Assert.NotNull(capturedEtag1); boundJob.Constraints = new JobConstraints(TimeSpan.FromMinutes(60), 0); BatchClientBehavior updateInterceptor = new Protocol.RequestInterceptor( (req) => { var typedParams = req.Options as Protocol.Models.JobUpdateOptions; if (typedParams != null) { typedParams.IfMatch = capturedEtag1; } }); //Update bound job with if-match header, it should succeed boundJob.Commit(additionalBehaviors: new[] { updateInterceptor }); boundJob = batchCli.JobOperations.GetJob(jobId); boundJob.Constraints = new JobConstraints(TimeSpan.FromMinutes(30), 1); //Update bound job with if-match header, it should fail Exception e = TestUtilities.AssertThrows <BatchException>(() => boundJob.Commit(additionalBehaviors: new[] { updateInterceptor })); TestUtilities.AssertIsBatchExceptionAndHasCorrectAzureErrorCode(e, BatchErrorCodeStrings.ConditionNotMet, this.testOutputHelper); } finally { TestUtilities.DeleteJobIfExistsAsync(batchCli, jobId).Wait(); } } }; SynchronizationContextHelper.RunTest(test, LongTestTimeout); }
public void OnFileEnding(object sender, WebsocketEventArgs args) { var file_id = args.ctx.fileCtx.file_id; var file_name = args.ctx.fileCtx.file_name; var file_type = args.ctx.fileCtx.type; SynchronizationContextHelper.SendMainSyncContext(() => { showFile(file_id, file_name, file_type, args.ctx.device_name, args.ctx.device_id); }); }
public void Open(SynchronizationContext synchronizationContext) { if (synchronizationContext != null) { this.synchronizationContext = synchronizationContext; } else { this.synchronizationContext = SynchronizationContextHelper.GetDefaultSynchronizationContext(); } }
public void TestListJobsByJobSchedule() { Action test = () => { using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result) { string jobScheduleId = Microsoft.Azure.Batch.Constants.DefaultConveniencePrefix + TestUtilities.GetMyName() + "-TestListJobsByJobSchedule"; try { Schedule schedule = new Schedule() { DoNotRunAfter = DateTime.UtcNow.Add(TimeSpan.FromDays(1)), RecurrenceInterval = TimeSpan.FromMinutes(1) }; JobSpecification jobSpecification = new JobSpecification(new PoolInformation() { PoolId = "DummyPool" }); CloudJobSchedule unboundJobSchedule = batchCli.JobScheduleOperations.CreateJobSchedule(jobScheduleId, schedule, jobSpecification); unboundJobSchedule.Commit(); //List the jobs under this JobSchedule for (int i = 1; i <= 3; i++) { string expectedJobId = string.Format("{0}:job-{1}", jobScheduleId, i); CloudJobSchedule boundJobSchedule = TestUtilities.WaitForJobOnJobSchedule( batchCli.JobScheduleOperations, jobScheduleId, expectedJobId: expectedJobId, timeout: TimeSpan.FromSeconds(70)); List <CloudJob> jobs = boundJobSchedule.ListJobs().ToList(); Assert.Equal(i, jobs.Count); jobs = batchCli.JobScheduleOperations.ListJobs(jobScheduleId).ToList(); Assert.Equal(i, jobs.Count); //Terminate the current job to force a new job to be created batchCli.JobOperations.TerminateJob(expectedJobId); } } finally { // clean up TestUtilities.DeleteJobScheduleIfExistsAsync(batchCli, jobScheduleId).Wait(); } } }; SynchronizationContextHelper.RunTest(test, LongTestTimeout); }
public void Open(SynchronizationContext synchronizationContext) { Fx.Assert(this.synchronizationContext == null, "can only open when in the created state"); if (synchronizationContext != null) { this.synchronizationContext = synchronizationContext; } else { this.synchronizationContext = SynchronizationContextHelper.GetDefaultSynchronizationContext(); } }
public async Task Bug1360227_AddTasksBatchRequestFailure(bool useJobOperations) { const string testName = "Bug1360227_AddTasksBatchRequestFailure"; Random rand = new Random(); object randLock = new object(); BatchClientBehavior customBehavior = new Protocol.RequestInterceptor(request => { var typedRequest = request as Protocol.BatchRequests.TaskAddCollectionBatchRequest; if (typedRequest != null) { var originalServiceRequestFunction = typedRequest.ServiceRequestFunc; typedRequest.ServiceRequestFunc = token => { lock (randLock) { double d = rand.NextDouble(); if (d > 0.3) { throw new HttpRequestException("Simulating a network problem"); } else { return(originalServiceRequestFunction(token)); } } }; } }); await SynchronizationContextHelper.RunTestAsync(async() => { using (BatchClient batchCli = await TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment(), addDefaultRetryPolicy: false)) { batchCli.JobOperations.CustomBehaviors.Add(customBehavior); BatchClientParallelOptions parallelOptions = new BatchClientParallelOptions() { MaxDegreeOfParallelism = 2 }; var exception = await TestUtilities.AssertThrowsAsync <ParallelOperationsException>(async() => await this.AddTasksSimpleTestAsync(batchCli, testName, 397, parallelOptions, useJobOperations: useJobOperations).ConfigureAwait(false) ).ConfigureAwait(false); Assert.IsType <HttpRequestException>(exception.InnerException); } }, TestTimeout); }
public void Bug1965363_2384616_Wat7OSVersionFeatures() { Action test = () => { using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result) { PoolOperations poolOperations = batchCli.PoolOperations; try { this.testOutputHelper.WriteLine("Listing OS Versions:"); // create pool tests // forget to set CloudServiceConfiguration on Create, get error { CloudPool noArgs = poolOperations.CreatePool("Bug1965363ButNoOSFamily-" + TestUtilities.GetMyName(), PoolFixture.VMSize, default(CloudServiceConfiguration), targetDedicatedComputeNodes: 0); BatchException ex = TestUtilities.AssertThrows <BatchException>(() => noArgs.Commit()); string exStr = ex.ToString(); // we are expecting an exception, assert if the exception is not the correct one. Assert.Contains("cloudServiceConfiguration", exStr); } // create a pool WITH an osFamily { string poolIdHOSF = "Bug1965363HasOSF-" + TestUtilities.GetMyName(); try { CloudPool hasOSF = poolOperations.CreatePool(poolIdHOSF, PoolFixture.VMSize, new CloudServiceConfiguration(PoolFixture.OSFamily), targetDedicatedComputeNodes: 0); hasOSF.Commit(); } finally { poolOperations.DeletePool(poolIdHOSF); } } } catch (Exception ex) { // special case os version beacuse it is a common failure and requires human intervention/editing // test for expired os version Assert.DoesNotContain("The specified OS Version does not exists", ex.ToString()); throw; } } }; SynchronizationContextHelper.RunTest(test, TestTimeout); }
public async Task TestPoolCertificateReferencesWithUpdate() { Func <Task> test = async() => { using (BatchClient batchCli = await TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment())) { //Generate the certificates const string certificatePrefix = "poolwithcertificatereferences"; string cerFilePath = IntegrationTestCommon.GetTemporaryCertificateFilePath(string.Format("{0}.cer", certificatePrefix)); string pfxFilePath = IntegrationTestCommon.GetTemporaryCertificateFilePath(string.Format("{0}.pfx", certificatePrefix)); IEnumerable <Certificate> certificates = GenerateCertificates(batchCli, cerFilePath, pfxFilePath); try { foreach (Certificate certificate in certificates) { this.testOutputHelper.WriteLine("Adding certificate with thumbprint: {0}", certificate.Thumbprint); await certificate.CommitAsync().ConfigureAwait(false); } List <CertificateReference> certificateReferences = certificates.Select(cer => new CertificateReference(cer) { StoreLocation = CertStoreLocation.LocalMachine, StoreName = "My", Visibility = CertificateVisibility.RemoteUser }).ToList(); await TestPoolCreateAndUpdateWithCertificateReferencesAsync(batchCli, certificateReferences).ConfigureAwait(false); await TestAutoPoolCreateAndUpdateWithCertificateReferencesAsync(batchCli, certificateReferences).ConfigureAwait(false); } finally { File.Delete(pfxFilePath); File.Delete(cerFilePath); foreach (Certificate certificate in certificates) { TestUtilities.DeleteCertificateIfExistsAsync(batchCli, certificate.ThumbprintAlgorithm, certificate.Thumbprint).Wait(); } foreach (Certificate certificate in certificates) { TestUtilities.DeleteCertMonitor(batchCli.CertificateOperations, this.testOutputHelper, certificate.ThumbprintAlgorithm, certificate.Thumbprint); } } } }; await SynchronizationContextHelper.RunTestAsync(test, TestTimeout); }
public async Task CanCreateJobAndAutoPoolWithAppPackageReferences() { var jobId = Guid.NewGuid().ToString(); const string applicationId = "blender"; Func <Task> test = async() => { using (BatchClient client = await TestUtilities.OpenBatchClientFromEnvironmentAsync().ConfigureAwait(false)) { var poolInfo = new PoolInformation { AutoPoolSpecification = new AutoPoolSpecification { PoolSpecification = new PoolSpecification { ApplicationPackageReferences = new[] { new ApplicationPackageReference { ApplicationId = applicationId, Version = PoolFixture.VMSize, } }, CloudServiceConfiguration = new CloudServiceConfiguration(PoolFixture.OSFamily), VirtualMachineSize = PoolFixture.VMSize, }, PoolLifetimeOption = PoolLifetimeOption.Job } }; CloudJob response = null; try { CloudJob job = client.JobOperations.CreateJob(jobId, poolInfo); await job.CommitAsync().ConfigureAwait(false); response = await client.JobOperations.GetJobAsync(jobId).ConfigureAwait(false); Assert.Equal(response.PoolInformation.AutoPoolSpecification.PoolSpecification.ApplicationPackageReferences.First().ApplicationId, applicationId); } finally { if (response != null) { TestUtilities.DeleteJobIfExistsAsync(client, jobId).Wait(); } } } }; await SynchronizationContextHelper.RunTestAsync(test, TestTimeout); }
public async Task Bug1360227_AddTasksBatchMultipleBatches(bool useJobOperations) { const string testName = "Bug1360227_AddTasksBatchMultipleBatches"; await SynchronizationContextHelper.RunTestAsync(async() => { using (BatchClient batchCli = await TestUtilities.OpenBatchClientFromEnvironmentAsync()) { await this.AddTasksSimpleTestAsync(batchCli, testName, 550, useJobOperations: useJobOperations).ConfigureAwait(false); } }, TestTimeout); }