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));
}
