protected void Application_Start(object sender, EventArgs e)
{
var connectionString = ConfigurationManager.ConnectionStrings["Storage"].ConnectionString;
var storageAccount = CloudStorageAccount.Parse(connectionString);
BackgroundWorker = new BackgroundWorkerService(storageAccount);
Task.Run(() => BackgroundWorker.DoWork("Application_Start"));
}
public async Task CheckStateOnFinishedWork()
{
var cancellationTokenSource = new CancellationTokenSource();
var service = new BackgroundWorkerService();
await service.StartAsync(cancellationTokenSource.Token);
bool finishedExecuting = false;
bool continueExecution = true;
service.RunAsync(CreateTestTaskAsync(300, token =>
{
if (!continueExecution)
{
finishedExecuting = true;
}
return(continueExecution);
}));
// Our service should now be processing the task until we set the tas as finished
Assert.IsTrue(service.IsProcessingTasks, "Service did not process the work");
continueExecution = false; // We set the task as finished
while (!finishedExecuting) // We wait until our work has noticed our flag
{
await Task.Delay(100);
}
// At this point our artificial work should have finished.
// The service should no longer be processing work.
Assert.IsFalse(service.IsProcessingTasks, "Service did not finish processing work");
}
public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
{
_cts = new CancellationTokenSource();
Task.Run(() => {
try
{
BackgroundWorkerService.RunBackgroundWorkerService(_cts.Token).Wait();
}
catch (System.OperationCanceledException ex)
{
throw;
}
finally
{
if (_cts.IsCancellationRequested)
{
var message = new CancelledMessage();
Device.BeginInvokeOnMainThread(
() => MessagingCenter.Send(message, "CancelledMessage")
);
}
}
}, _cts.Token);
return(StartCommandResult.Sticky);
}
public async Task StopServiceWithWorkUngracefulShutdown()
{
var cancellationTokenSource = new CancellationTokenSource();
int stopCheckDelay = 300;
var service = new BackgroundWorkerService();
await service.StartAsync(cancellationTokenSource.Token);
bool allowStop = false;
bool cancellationWasCalled = false;
var workTask = CreateTestTaskAsync(stopCheckDelay, cancellationToken =>
{
if (allowStop)
{
cancellationWasCalled = cancellationToken.IsCancellationRequested;
return(false);
}
return(true);
});
service.RunAsync(workTask);
service.Dispose();
Assert.IsFalse(service.IsStarted, "Service was still runing despite being disposed");
Assert.IsTrue(service.IsProcessingTasks, "Service was not processing unfinished work when disposed");
allowStop = true;
var waitDelay = stopCheckDelay * 2;
await Task.Delay(waitDelay); // Make sure our work has a chance to react
Assert.IsFalse(service.IsProcessingTasks, $"Service was still processing work { waitDelay } milliseconds after stopping");
Assert.IsTrue(cancellationWasCalled, "Cancellation was not called");
}
public BackgroundWorkerServiceTests()
{
_subscriberMock = new Mock <IMQSubscriber>();
_producerMock = new Mock <IProducer>();
_consumerfactoryMock = new Mock <IConsumerFactory>();
sut = new BackgroundWorkerService(_subscriberMock.Object, _producerMock.Object, _consumerfactoryMock.Object);
}
public async Task StartService()
{
var cancellationTokenSource = new CancellationTokenSource();
var service = new BackgroundWorkerService();
await service.StartAsync(cancellationTokenSource.Token);
Assert.IsTrue(service.IsStarted, "Service was not started");
}
static void Main()
{
Console.WriteLine("Starting web job");
var connectionString = ConfigurationManager.ConnectionStrings["Storage"].ConnectionString;
var storageAccount = CloudStorageAccount.Parse(connectionString);
var backgroundWorker = new BackgroundWorkerService(storageAccount);
Task.Run(() => backgroundWorker.DoWork("WebJob")).Wait();
}
public async Task StopService()
{
var cancellationTokenSource = new CancellationTokenSource();
var service = new BackgroundWorkerService();
await service.StartAsync(cancellationTokenSource.Token);
await service.StopAsync(cancellationTokenSource.Token);
Assert.IsFalse(service.IsStarted, "Service did not stop");
}
public async Task CheckStateOnRegistredWork()
{
var cancellationTokenSource = new CancellationTokenSource();
var service = new BackgroundWorkerService();
await service.StartAsync(cancellationTokenSource.Token);
bool continueExecution = true;
service.RunAsync(CreateTestTaskAsync(1000, token =>
{
return(continueExecution);
}));
Assert.IsTrue(service.IsProcessingTasks, "Service did not start processing work");
continueExecution = false;
}
public async Task ExceptionEventWithoutSubscriber()
{
var cancellationTokenSource = new CancellationTokenSource();
var service = new BackgroundWorkerService();
await service.StartAsync(cancellationTokenSource.Token);
service.RunAsync(async token =>
{
throw new Exception("Win!");
});
await Task.Delay(100); // Since our test task does not contain anything asynchronous we will have to wait for it to execute
// We only need to determine that the exception does not disrupt the application outside of the task in progress
}
public void RejectWorkOnUnstartedService()
{
try
{
var service = new BackgroundWorkerService();
Assert.ThrowsException <InvalidOperationException>(() =>
{
service.RunAsync((cancellationToken) => Task.CompletedTask);
}, "No exception was thrown");
}
catch (Exception ex) when(!(ex is InvalidOperationException) && !(ex is AssertFailedException))
{
Assert.Fail($"Wrong exception was thrown: '{ ex.GetType().Name }'");
}
}
public async void TestRunBackgroundWorker()
{
var platformServicesFake = A.Fake <IPlatformServices>();
Device.PlatformServices = platformServicesFake;
DatabaseMigrator.Migrate(_connection, _migrationSkriptFolderPath);
MessagingCenter.Subscribe <StartBackgroundWorkingServiceMessage>(this, MessageHelper.START_BACKGROUND_WORKING_SERVICE_MESSAGE, message =>
{
var msg = new DiagnosticMessage("Start Background Working Service");
output.WriteLine("{0}", msg.Message);
});
MessagingCenter.Subscribe <StopBackgroundWorkingServiceMessage>(this, MessageHelper.STOP_BACKGROUND_WORKING_SERVICE_MESSAGE, message =>
{
var msg = new DiagnosticMessage("Stop Background Working Service");
output.WriteLine("{0}", msg.Message);
});
MessagingCenter.Subscribe <ElementFinishedMessage>(this, MessageHelper.ELEMENT_FINISHED_MESSAGE, message =>
{
var msg = new DiagnosticMessage("Element processed");
output.WriteLine("{0}", msg.Message);
});
var deleteAll = BackgroundQueueService.EmptyQueue(_connection).Result;
Assert.True(deleteAll);
var testSpotGuid = Guid.NewGuid();
var testLat = 48.45;
var testLng = 13.9167;
var result = BackgroundQueueService.PushWheaterRequestToBackgroundQueue(_connection, testSpotGuid, testLat, testLng).Result;
Assert.True(result != Guid.Empty);
await BackgroundWorkerService.RunBackgroundWorkerService(_connection, new CancellationToken(false));
int cnt = BackgroundQueueService.GetQueueElementCount(_connection).Result;
Assert.Equal(0, cnt);
}
public async Task StopServiceWithWorkGracefulShutdown()
{
int stopCheckDelay = 300;
var cancellationTokenSource = new CancellationTokenSource();
var service = new BackgroundWorkerService();
await service.StartAsync(cancellationTokenSource.Token);
bool allowStop = false;
bool cancellationWasCalled = false;
service.RunAsync(CreateTestTaskAsync(stopCheckDelay, (token) =>
{
// If we want to stop the work
if (allowStop)
{
cancellationWasCalled = token.IsCancellationRequested;
return(false);
}
return(true);
}));
// We will stop the service, this should not stop the work from finishing
// We cannot await this task at this point in time as it will not be able to finish until stopToken.IsStopped is set further down (deadlock).
// We can call await after we have stopped the work to view the status
var stoppingTask = service.StopAsync(cancellationTokenSource.Token);
Assert.IsFalse(service.IsStarted, "Service was still runing despite being told to stop");
Assert.IsTrue(service.IsProcessingTasks, "Service stopped processing unfinished work when stopped");
// Now we will simulate our work finishing.
allowStop = true;
var waitDelay = (stopCheckDelay * 2) + 1;
await Task.Delay(waitDelay); // We will wait until we are 100% sure our testwork has registered the stop.
Assert.IsFalse(service.IsProcessingTasks, $"Service was still processing work { waitDelay } milliseconds after stopping");
await stoppingTask;
Assert.IsTrue(stoppingTask.IsCompletedSuccessfully, "Stopping task did not complete successfully");
Assert.IsTrue(cancellationWasCalled, "Cancellation was not called");
}
public async Task ExceptionEventWithSubscriber()
{
var cancellationTokenSource = new CancellationTokenSource();
var service = new BackgroundWorkerService();
await service.StartAsync(cancellationTokenSource.Token);
bool exceptionCallbackWasCalled = false;
service.OnException += (sender, e) =>
{
exceptionCallbackWasCalled = true;
};
service.RunAsync(async token =>
{
throw new Exception("Win!");
});
await Task.Delay(100); // Since our test task does not contain anything asynchronous we will have to wait for it to execute
Assert.IsTrue(exceptionCallbackWasCalled, "Exception event was not raised");
}
public void Setup()
{
if (Directory.Exists(SitesPath))
{
Directory.Delete(SitesPath, true);
}
if (Directory.Exists(ExePath))
{
Directory.Delete(ExePath, true);
}
Directory.CreateDirectory(Path.Combine(SitesPath, SiteName));
Directory.CreateDirectory(Path.Combine(SitesPath, SiteName2));
Directory.CreateDirectory(ExePath);
File.WriteAllText(Path.Combine(SitesPath, SiteName, "web.config"), WebConfigContents);
File.WriteAllText(Path.Combine(SitesPath, SiteName2, "web.config"), WebConfig2Contents);
_service = new BackgroundWorkerService(SitesPath, ExePath, new ConsoleFactory(), LoggerLevel.Debug);
}
/// <inheritdoc />
protected override void Load(ContainerBuilder builder)
{
var iotaRepository = new RestIotaRepository(
new FallbackIotaClient(new List <string> {
"https://nodes.devnet.thetangle.org:443"
}, 5000),
new PoWService(new CpuPearlDiver()));
var channelFactory = new MamChannelFactory(CurlMamFactory.Default, CurlMerkleTreeFactory.Default, iotaRepository);
var subscriptionFactory = new MamChannelSubscriptionFactory(iotaRepository, CurlMamParser.Default, CurlMask.Default);
var encryption = new RijndaelEncryption("somenicekey", "somenicesalt");
var resourceTracker = new ResourceTracker(
channelFactory,
subscriptionFactory,
encryption,
$"{DependencyResolver.LocalStoragePath}\\resources.sqlite");
var seedManager = new SeedManager(
resourceTracker,
new IssSigningHelper(new Curl(), new Curl(), new Curl()),
new AddressGenerator(),
iotaRepository,
encryption,
$"{DependencyResolver.LocalStoragePath}\\seedmanager.sqlite");
var fhirRepository = new IotaFhirRepository(iotaRepository, new FhirJsonTryteSerializer(), resourceTracker, seedManager);
var fhirParser = new FhirJsonParser();
var searchRepository = new SearchRepository($"{DependencyResolver.LocalStoragePath}\\search.sqlite");
var createInteractor = new CreateResourceInteractor(fhirRepository, fhirParser, searchRepository);
var readInteractor = new ReadResourceInteractor(fhirRepository, searchRepository);
var validationInteractor = new ValidateResourceInteractor(fhirRepository, fhirParser);
var searchInteractor = new SearchResourcesInteractor(fhirRepository, searchRepository);
var resourceImporter = new ResourceImporter(searchRepository, fhirRepository, seedManager);
builder.RegisterInstance(searchRepository).As <ISearchRepository>();
builder.RegisterInstance(resourceTracker).As <IResourceTracker>();
builder.RegisterInstance(createInteractor);
builder.RegisterInstance(readInteractor);
builder.RegisterInstance(validationInteractor);
builder.RegisterInstance(searchInteractor);
builder.RegisterInstance(resourceImporter);
builder.RegisterInstance(seedManager).As <ISeedManager>();
builder.RegisterInstance(subscriptionFactory);
builder.RegisterInstance(fhirRepository).As <IFhirRepository>();
builder.RegisterInstance(new AndroidLogout()).As <ILogout>();
var backgroundWorker = new BackgroundWorkerService();
var glucoseService = new FhirGlucoseService(
new CreateResourceInteractor(fhirRepository, fhirParser, searchRepository),
new UpdateResourceInteractor(fhirRepository, fhirParser),
new ReadResourceInteractor(fhirRepository, searchRepository),
searchRepository);
var glucoseRepository = new DexcomGlucoseManagementRepository(new RestClient("https://sandbox-api.dexcom.com"));
//backgoundWorker.RegisterTaskWorker(new ContinuousGlucoseTaskWorker(glucoseService, glucoseRepository));
backgroundWorker.RegisterTaskWorker(new AggregateGlucoseTaskWorker(glucoseService, glucoseRepository));
}