public virtual void Stop() { if (!IsRunning) { return; } lock (_stateLock) { if (!IsRunning) { return; } Log.Log(LogCatagory.Info, "Stoping {0}. . .", ModuleName); OnStop(); if (LongRunningTask != null) { LongRunningTask.Stop(); } Log.Log(LogCatagory.Info, "{0} stopped.", ModuleName); IsRunning = false; } }
public void Run() { var view = new GenLib.Progress.BackgroundWorker.View(new Mediator(new ViewModel())); var lrt = new LongRunningTask(); // all features view.SetParms("Progress Test", "Testing progress framework using background worker", lrt.Execute, true, 4000); // no cancel //view.SetParms("Progress Test", "Testing progress framework", lrt.Execute, false, 4000); // no cancel, no delay //view.SetParms("Progress Test", "Testing progress framework", lrt.Execute, false, 0); var vpt = new Thread(view.ShowDialog) { Name = "BackgroundWorker" }; vpt.Start(); vpt.Join(); Console.WriteLine(@"BackgroundWorker state is " + view.Mediator.BackgroundWorkerEndingState.Description); Assert.NotEqual(view.Mediator.BackgroundWorkerEndingState, BackgroundWorkerEndingState.NotSet); Assert.True(true); }
public void TryStartDownloadDiscovered(Hash packageId) { var packageDiscovery = packageRegistry.ImmutableDiscoveredPackages.FirstOrDefault(p => p.PackageId.Equals(packageId)); if (packageDiscovery == null) { return; } // try start download if (!packageDownloadManager.GetDiscoveredPackageAndStartDownloadPackage(packageDiscovery, out Task startDownloadTask)) { return; } // create and register task for starting download var task = new LongRunningTask( $"Starting download of package \"{packageDiscovery.Name}\" {packageDiscovery.PackageId:s}", startDownloadTask, $"Download has started" ); // register tasks.AddTaskToQueue(task); }
internal static void Run(CancellationTokenSource cts) { try { var token = cts.Token; var longTask = new LongRunningTask(); t = Task.Factory.StartNew(() => { longTask.Process(token); }, token, TaskCreationOptions.LongRunning, TaskScheduler.Default); t.Wait(); } catch (AggregateException ae) { ae.Flatten().Handle(ex => { if (ex is Exception) { Task.Run(() => { Console.WriteLine(ex.Message); }); throw ex; } else { return(false); } }); } }
public override bool FinishedLaunching(UIApplication uiApplication, NSDictionary launchOptions) { //Xamarin.Calabash.Start(); #if ENABLE_TEST_CLOUD // requires Xamarin Test Cloud Agent Xamarin.Calabash.Start(); #endif var normalTextAttributes = new UITextAttributes(); normalTextAttributes.Font = UIFont.FromName("Roboto-Bold", 16.0f); // -- Unselected normalTextAttributes.TextColor = Color.FromHex("#174163").ToUIColor(); UINavigationBar.Appearance.SetTitleTextAttributes(normalTextAttributes); UINavigationBar.Appearance.BarTintColor = Color.FromHex("#eff9ff").ToUIColor(); UINavigationBar.Appearance.TintColor = Color.FromHex("#174163").ToUIColor(); UINavigationBar.Appearance.SetBackgroundImage(new UIImage(), UIBarPosition.Any, UIBarMetrics.Default); UINavigationBar.Appearance.ShadowImage = new UIImage(); global::Xamarin.Forms.Forms.Init(); MessagingCenter.Subscribe <StartLongRunningTaskMessage>(this, "StartLongRunningTaskMessage", async message => { upload_task = new LongRunningTask(new UploadLongRunningTask()); await upload_task.Start(); }); MessagingCenter.Subscribe <StopLongRunningTaskMessage>(this, "StopLongRunningTaskMessage", message => { upload_task.Stop(); }); //DependencyService.Register<IProgressHUD, IOSProgressHUD>(); App.ScreenSize = new Size(UIScreen.MainScreen.Bounds.Width, UIScreen.MainScreen.Bounds.Height); var fr = new CultureInfo("fr-FR"); Thread.CurrentThread.CurrentCulture = fr; PopolLib.iOS.Renderers.FastListView.FastListViewRenderer.Init(); LoadApplication(new App()); // -- Liste des Fonts dans l'application //var fontList = new StringBuilder(); //var familyNames = UIFont.FamilyNames; //foreach (var familyName in familyNames) //{ // fontList.Append(String.Format("Family: {0}\n", familyName)); // Console.WriteLine("Family: {0}\n", familyName); // var fontNames = UIFont.FontNamesForFamilyName(familyName); // foreach (var fontName in fontNames) // { // Console.WriteLine("\tFont: {0}\n", fontName); // fontList.Append(String.Format("\tFont: {0}\n", fontName)); // } //}; //Console.WriteLine(fontList.ToString()); return(base.FinishedLaunching(uiApplication, launchOptions)); }
public async Task <CalculatorResponse> Add(AddRequest request) { await LongRunningTask.Instance(); return(new CalculatorResponse { Result = request.Left + request.Right }); }
void WireUpLongRunningTask() { MessagingCenter.Subscribe <StartLongRunningTaskMessage, FunctionPassingToNativeBackground>(this, "StartLongRunningTaskMessage", async(message, obj) => { longRunningTaskExample = new LongRunningTask(); await longRunningTaskExample.StartLongRunningTask(obj); }); }
public void Setup() { _queuedExecutorSettings = new QueuedExecutorSettings{Name = "test"}; _queue = new QueuedExecutor(_queuedExecutorSettings, NullPersister.Instance); _queue.TaskAdded += delegate { }; _task = new LongRunningTask(true); _executionEnvelope = new ExecutionEnvelope(_task, DefaultReleaser.Instance); }
public async Task <EchoResponse> ServiceMethod(EchoUrlRequest request) { await LongRunningTask.Instance(); return(new EchoResponse { TokenEcho = request.Token }); }
/// <summary> /// Handles an executing async service request by showing a loading overlay until it completes execution. /// </summary> /// <param name="loadingOverlay">A overlay to display over the screen during the async operation.</param> /// <param name="executingRequest">The task for an executing request.</param> /// <param name="onSuccess">Gets invoked if the request has completed successfully.</param> protected void OnAsyncServiceRequest(ILoadingOverlay loadingOverlay, LongRunningTask executingRequest, Action onSuccess) { this.OnAsyncServiceRequest( loadingOverlay, executingRequest.Progress, executingRequest.Task, onSuccess, result => this.ShowLoadingFromServiceFailedAlert(result)); }
public void Do_not_return_new_task_until_previous_completed() { var queue = new QueuedExecutor(_queuedExecutorSettings, NullPersister.Instance); queue.TaskAdded += delegate { }; var task1 = new LongRunningTask(false); var task2 = new LongRunningTask(false); queue.Enqueue(new ExecutionEnvelope(task1, DefaultReleaser.Instance)); queue.Enqueue(new ExecutionEnvelope(task2, DefaultReleaser.Instance)); queue.Dequeue(); Assert.That(queue.Dequeue(), Is.Null); }
public void SingleTaskAlreadyStarted() { var loggerFactory = new LoggerFactory(); var tasksManager = new LongRunningTasksManager(loggerFactory); var task = new LongRunningTask("Test", Task.CompletedTask); tasksManager.AddTaskToQueue(task); // should be placed directly to finished Thread.Sleep(50); Assert.True(task.IsCompletedSuccessfully); Assert.DoesNotContain(task, tasksManager.Tasks); Assert.Contains(task, tasksManager.CompletedTasks); }
public void TryVerifyPackage(Hash packageId) { if (!packageRegistry.TryGetPackage(packageId, out LocalPackageInfo package) || package.LockProvider.IsMarkedToDelete) { return; } // create lock lock (syncLock) { if (!packagesInVerify.Add(packageId)) { return; } } // run var measureItem = new MeasureItem(MeasureType.Throughput); var extractTask = validator.ValidatePackageAsync(package, measureItem).ContinueWith(t => { if (t.IsFaulted && !t.Result.IsValid) { throw new Exception(string.Join("; ", t.Result.Errors)); } }); // return lock extractTask.ContinueWith(t => { // release lock lock (syncLock) { packagesInVerify.Remove(packageId); } if (t.IsFaulted) { throw t.Exception; } }); // create and register task for starting download var task = new LongRunningTask( $"Validation of \"{package.Metadata.Name}\" {package.Id:s}", extractTask, $"Package is valid.", t => $"Validating {measureItem.ValueFormatted}" ); // register tasks.AddTaskToQueue(task); }
public void Should_match_and_return_results_from_different_matchers() { var nsMatcher = new NamespaceMatcher("byNamespace", typeof (PersistentTask).Namespace); var funcMatcher = new FuncMatcher("byFunc", task => task.GetType() == typeof (LongRunningTask)); var matcher = new AggregateMatcher(nsMatcher, funcMatcher); var namespaceMatch = matcher.TryMatch(PersistentTask.Instance); Assert.That(namespaceMatch.Matched, Is.True); Assert.That(namespaceMatch.Value, Is.EqualTo("byNamespace")); var anotherTask = new LongRunningTask(false); var funcMatch = matcher.TryMatch(anotherTask); Assert.That(funcMatch.Matched, Is.True); Assert.That(funcMatch.Value, Is.EqualTo("byFunc")); }
public void DeletePackage(Hash packageId) { if (!packageRegistry.TryGetPackage(packageId, out LocalPackageInfo package) || package.LockProvider.IsMarkedToDelete) { return; } // start var deleteTask = packageRegistry.DeletePackageAsync(package); // create and register task for starting download var task = new LongRunningTask( $"Deleting package \"{package.Metadata.Name}\" {package.Id:s}", deleteTask, $"Package has been deleted" ); // register tasks.AddTaskToQueue(task); }
public void SingleTaskSuccess() { var loggerFactory = new LoggerFactory(); var tasksManager = new LongRunningTasksManager(loggerFactory); LongRunningTask task; tasksManager.AddTaskToQueue(task = new LongRunningTask("Test", Task.Delay(TimeSpan.FromMilliseconds(100)))); // started but not finished Assert.Contains(task, tasksManager.Tasks); Assert.DoesNotContain(task, tasksManager.CompletedTasks); task.CompletionTask.Wait(); Thread.Sleep(50); // finisihed Assert.True(task.IsCompletedSuccessfully); Assert.DoesNotContain(task, tasksManager.Tasks); Assert.Contains(task, tasksManager.CompletedTasks); }
public void ExtractPackage(Hash packageId, string folder, bool validate) { if (!packageRegistry.TryGetPackage(packageId, out LocalPackageInfo package) || package.LockProvider.IsMarkedToDelete) { return; } // run var extractTask = Task.Run(new Action(() => localPackageManager.ExtractPackage(package, folder, validate: validate))); // create and register task for starting download var task = new LongRunningTask( validate ? $"Validating and extracting \"{package.Metadata.Name}\" {package.Id:s} to: {folder}" : $"Extracting \"{package.Metadata.Name}\" {package.Id:s} to: {folder}", extractTask, $"Success" ); // register tasks.AddTaskToQueue(task); }
public void CreateNewPackage(string folder, string name) { if (!Directory.Exists(folder)) { throw new InvalidOperationException("Folder does not exists."); } // start var measureItem = new MeasureItem(MeasureType.Throughput); Task taskCreate = Task.Run(new Action(() => packageRegistry.CreatePackageFromFolder(folder, name, measureItem))); // create and register task for starting download var task = new LongRunningTask( $"Started creating new package from: \"{folder}\"", taskCreate, $"Package has been created.", (t) => $"Writing {measureItem.ValueFormatted}" ); // register tasks.AddTaskToQueue(task); }
public JsonResult Run(CancellationTokenSource cancellationTokenSource) { try { _cancellationTokenSource = cancellationTokenSource; var longTask = new LongRunningTask(); _longTask = Task.Factory.StartNew(() => { longTask.Process(_cancellationTokenSource.Token); }, _cancellationTokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default); _longTask.Wait(); } catch (AggregateException ae) { ae.Flatten().Handle(ex => { if (ex is Exception) { Task.Run(() => { return(Json("Specific OperationCanceledException", JsonRequestBehavior.AllowGet)); }); throw ex; } else { return(false); } }); } return(Json("The Operation Started successfully .", JsonRequestBehavior.AllowGet)); }
public virtual void Start() { if (IsRunning) { return; } lock (_stateLock) { if (IsRunning) { return; } Log.Log(LogCatagory.Info, "Starting {0}. . .", ModuleName); LongRunningTask = new LongRunningTask(AttendIncomingQueue); LongRunningTask.Start(); OnStart(); Log.Log(LogCatagory.Info, "{0} started.", ModuleName); IsRunning = true; } }
public async void ServiceMethodReturningVoid(RequestOne request) { await LongRunningTask.Instance(); }
public async virtual void AsyncDecoratedMethodWithCancellationTokenAndOtherParameters(Request request, CancellationToken cancel, object other) { await LongRunningTask.Instance(); }
public async virtual void AsyncDecoratedMethodWithCancellationTokenInWrongPlace(CancellationToken cancel, Request request) { await LongRunningTask.Instance(); }
public override void ExecuteCmdlet() { if (AsJob.IsPresent) { task = new LongRunningTask<PublishAzureRemoteAppProgram>(this, "RemoteAppBackgroundTask", Commands_RemoteApp.Publish); task.ProcessJob(() => { task.SetStatus(Commands_RemoteApp.Publishing); PublishAction(); task.SetStatus(Commands_RemoteApp.JobComplete); }); WriteObject(task); } else { PublishAction(); } }
public Task <object> ServiceMethodReturningTaskOfT(RequestOne request) { return(LongRunningTask.Instance <object>()); }
public Task ServiceMethodReturningTask(RequestOne request) { return(LongRunningTask.Instance()); }
public static async void AsyncDecoratedStaticMethod(Request request) { await LongRunningTask.Instance <Response>(); }
public virtual async void MethodDecoratedWithAsync(Request request) { await LongRunningTask.Instance(); }
public void Starts_thread_if_a_task_added() { var task = new LongRunningTask(false); var envelope = new ExecutionEnvelope(task, DefaultReleaser.Instance); _queue.Enqueue(envelope); task.WaitForFinish(); Assert.That(task.Executed, Is.True); }
public override void ExecuteCmdlet() { DateTime today = DateTime.Now; CollectionUsageDetailsResult detailsUsage = null; string locale = String.Empty; if (String.IsNullOrWhiteSpace(UsageMonth)) { UsageMonth = today.Month.ToString(); } if (String.IsNullOrWhiteSpace(UsageYear)) { UsageYear = today.Year.ToString(); } locale = System.Globalization.CultureInfo.CurrentCulture.ToString(); detailsUsage = CallClient(() => Client.Collections.GetUsageDetails(CollectionName, UsageYear, UsageMonth, locale), Client.Collections); if (detailsUsage == null) { return; } if (AsJob.IsPresent) { task = new LongRunningTask<GetAzureRemoteAppCollectionUsageDetails>(this, "RemoteAppBackgroundTask", Commands_RemoteApp.UsageDetails); task.ProcessJob(() => { task.SetStatus(Commands_RemoteApp.DownloadingUsageDetails); GetUsageDetails(detailsUsage); task.SetStatus(Commands_RemoteApp.JobComplete); }); WriteObject(task); } else { GetUsageDetails(detailsUsage); } }
private ExecutionEnvelope CreateTask( string name, bool manualFinish = true) { var result = new LongRunningTask(manualFinish){Name = name}; _tasks.Add(result); return new ExecutionEnvelope(result, DefaultReleaser.Instance); }
public virtual Task <T> MethodReturningTaskOf <T>(Request request) { return(LongRunningTask.Instance <T>()); }
public async virtual Task <Response> AsyncDecoratedMethodWithCancellationTokenAndTaskOfTResponse(Request request, CancellationToken cancel) { return(await LongRunningTask.Instance <Response>()); }
public async Task ServiceMethodReturningTask(RequestTwo request) { await LongRunningTask.Instance(); }
public async Task <object> ServiceMethodReturningTaskOfT(RequestThree request) { return(await LongRunningTask.Instance <object>()); }
public virtual Task MethodReturningTask(Request request) { return(LongRunningTask.Instance()); }
public async virtual Task AsyncDecoratedMethodWithCancellationTokenAndTaskResponse(Request request, CancellationToken cancel) { await LongRunningTask.Instance(); }
public override void ExecuteCmdlet() { // register the subscription for this service if it has not been before // sebsequent call to register is redundent RegisterSubscriptionWithRdfeForRemoteApp(); switch (DetermineParameterSetName()) { case UploadLocalVhd: { string scriptBlock = "Test-Path -Path " + Path; Collection<bool> pathValid = CallPowershellWithReturnType<bool>(scriptBlock); TemplateImage image = null; if (pathValid[0] == false) { throw new RemoteAppServiceException(Commands_RemoteApp.FailedToValidateVhdPathError, ErrorCategory.ObjectNotFound); } task = new LongRunningTask<NewAzureRemoteAppTemplateImage>(this, "RemoteAppTemplateImageUpload", Commands_RemoteApp.UploadTemplateImageJobDescriptionMessage); task.ProcessJob(() => { image = VerifyPreconditions(); image = StartTemplateUpload(image); UploadVhd(image); task.SetStatus(Commands_RemoteApp.JobCompletionStatusMessage); }); WriteObject(task); break; } case AzureVmUpload: { ImportTemplateImage(); break; } } }
public void When_task_completed_allow_to_take_next_task() { var queue = new QueuedExecutor(_queuedExecutorSettings, NullPersister.Instance); queue.TaskAdded += delegate { }; var task1 = new LongRunningTask(false); var task2 = new LongRunningTask(false); var envelope1 = new ExecutionEnvelope(task1, DefaultReleaser.Instance); queue.Enqueue(envelope1); var envelope2 = new ExecutionEnvelope(task2, DefaultReleaser.Instance); queue.Enqueue(envelope2); var extracted = queue.Dequeue(); extracted.ExecuteTask(); Assert.That(queue.Dequeue(), Is.SameAs(envelope2)); }