public void TokenCleanup()
{
IPersistedGrantStore store = Fixture.GetService <IPersistedGrantStore>();
IHostedService svc = Fixture.GetService <IHostedService>();
Client client = CreateClient();
Provider.AddClientAsync(client).Wait();
svc.StartAsync(default(CancellationToken)).Wait();
PersistedGrant grant1 = CreateGrant(client.ClientId, "aaa", "t1");
PersistedGrant grant2 = CreateGrant(client.ClientId, "aaa");
grant1.Expiration = DateTime.Now.Add(TimeSpan.FromSeconds(15));
grant2.Expiration = DateTime.Now.Add(TimeSpan.FromSeconds(25));
store.StoreAsync(grant1).Wait();
store.StoreAsync(grant2).Wait();
List <PersistedGrant> results = store.GetAllAsync("aaa").Result?.ToList();
Assert.Equal(2, results.Count);
Task.Delay(20000).Wait();
results = store.GetAllAsync("aaa").Result?.ToList();
Assert.Equal(1, results.Count);
Task.Delay(10000).Wait();
results = store.GetAllAsync("aaa").Result?.ToList();
Assert.Equal(0, results.Count);
}
/// <summary>
/// Main method of File Manager
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
// Set up configuration sources
var builder = new ConfigurationBuilder()
.AddCloudFoundry();
IConfiguration configuration = builder.Build();
//setup our DI
var serviceProvider = new ServiceCollection()
.ConfigureCloudFoundryOptions(configuration)
.AddSingleton <IConfiguration>(configuration)
.AddSingleton <IHostedService, ScheduledService>()
.AddSingleton <IScheduledTask, FileMonitorCheckInboundFolderTask>()
.AddSingleton <IScheduledTask, FileMonitorArchiveTask>()
.AddSingleton <IScheduledTask, FileMonitorSfgTask>()
.AddAutoMapper(typeof(Program))
.BuildServiceProvider();
_cancellationTokenSource = new CancellationTokenSource();
_scheduledService = serviceProvider.GetService <IHostedService>();
Console.CancelKeyPress += StopService;
_scheduledService.StartAsync(_cancellationTokenSource.Token);
while (!_cancellationTokenSource.Token.IsCancellationRequested)
{
_cancellationTokenSource.Token.WaitHandle.WaitOne(-1);
}
}
public async Task CanComponentsStart(string componentToError, string expected)
{
IServiceCollection serviceCollection = this.GetServiceDescriptors();
string fromHeaders = componentToError == "from" ? "?WillError=true" : string.Empty;
string toHeaders = componentToError == "to" ? "?WillError=true" : string.Empty;
string actual = string.Empty;
try
{
Kyameru.Route.From($"injectiontest:///mememe{fromHeaders}")
.Process(this.processComponent.Object)
.To($"injectiontest:///somewhere{toHeaders}")
.Build(serviceCollection);
IServiceProvider provider = serviceCollection.BuildServiceProvider();
IHostedService service = provider.GetService <IHostedService>();
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
}
catch (Exception ex)
{
actual = ex.Message;
}
Assert.AreEqual(expected, actual);
}
public async Task CanActivateAndRun()
{
IServiceCollection serviceCollection = this.GetServiceDescriptors();
Routable routable = null;
this.processComponent.Reset();
this.processComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
{
routable = x;
});
Kyameru.Route.From("injectiontest:///mememe")
.Process(this.processComponent.Object)
.To("injectiontest:///somewhere")
.Build(serviceCollection);
IServiceProvider provider = serviceCollection.BuildServiceProvider();
IHostedService service = provider.GetService <IHostedService>();
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
Assert.AreEqual("Injected Test Complete", routable?.Body);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
if (_next != null)
{
await _next.StartAsync(cancellationToken);
}
}
public async Task StartAsync_RegisterRunTime_ShouldRegisterAllLifetimeCallbacks()
{
await hostedService.StartAsync(CancellationToken.None);
lifetime.VerifyGet(x => x.ApplicationStarted, Times.Once);
lifetime.VerifyGet(x => x.ApplicationStopping, Times.Once);
}
private async Task <bool> RunProcess(string callsContain)
{
Component.Test.GlobalCalls.Calls.Clear();
IHostedService service = this.GetRoute();
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
return(Kyameru.Component.Test.GlobalCalls.Calls.Contains(callsContain));
}
public async Task CanExecuteAtomic()
{
Component.Test.GlobalCalls.Calls.Clear();
IHostedService service = this.GetNoErrorChain();
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
Assert.AreEqual(6, this.GetCallCount());
}
public async Task AddHeaderErrors(bool secondFunction)
{
Component.Test.GlobalCalls.Calls.Clear();
IHostedService service = this.GetHeaderError(secondFunction);
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
Assert.AreEqual(6, this.GetCallCount());
}
public async Task CanExecuteMultipleChains()
{
Component.Test.GlobalCalls.Calls.Clear();
IHostedService service = this.AddComponent(true);
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
Assert.AreEqual(20, this.GetCallCount());
}
public IActionResult PublishWeeklyStats()
{
try
{
_timeHostedService.StopAsync(new System.Threading.CancellationToken());
_timeHostedService.StartAsync(new System.Threading.CancellationToken());
return(Ok("Published"));
}
catch (Exception e)
{
return(Ok("Not published: \n" + e.Message));
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
try
{
await _service.StartAsync(cancellationToken);
_logger.LogInformation($"Service {_service.GetType().FullName} started");
}
catch (Exception e)
{
_logger.LogCritical(e, $"Error starting hosted service {_service.GetType().FullName}");
_applicationLifetime.StopApplication();
}
}
/// <summary>启动服务</summary>
/// <param name="service"></param>
public override void Run(IHostedService service)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
_service = service;
var source = new CancellationTokenSource();
service.StartAsync(source.Token);
// 阻塞
Thread.Sleep(-1);
}
public async Task RunAsync(CancellationToken cancellationToken)
{
async Task Serve(CancellationToken token)
{
if (token.IsCancellationRequested)
{
return;
}
await _service.StartAsync(cancellationToken);
while (!token.IsCancellationRequested)
{
await Task.Delay(1000);
}
await _service.StopAsync(default);
public async Task AtomicError()
{
Routable routable = null;
this.errorComponent.Reset();
this.errorComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
{
routable = x;
});
this.processComponent.Reset();
IHostedService service = this.GetHostedService(false, false, true);
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
Assert.IsTrue(this.IsInError(routable, "Atomic Component"));
}
public async Task FromException()
{
Routable routable = null;
this.errorComponent.Reset();
this.errorComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
{
routable = x;
});
this.processComponent.Reset();
IHostedService service = this.GetHostedService(true);
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
Assert.IsNull(routable);
}
public async Task ErrorComponentErrors()
{
Routable routable = null;
this.errorComponent.Reset();
this.errorComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
{
routable = x;
throw new ProcessException("Manual Error", new IndexOutOfRangeException("Random index"));
});
IHostedService service = this.GetHostedService(false, false, true);
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
Assert.IsTrue(this.IsInError(routable, "Error Component"));
}
public async Task CanRunDIComponent()
{
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
Routable routable = null;
this.diProcessor.Reset();
this.diProcessor.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
{
routable = x;
});
IHostedService service = this.SetupDIComponent();
await service.StartAsync(CancellationToken.None);
autoResetEvent.WaitOne(TimeSpan.FromSeconds(5));
await service.StopAsync(CancellationToken.None);
Assert.AreEqual("Yes", routable.Headers["ComponentRan"]);
}
private async void bOperation_Click(object sender, EventArgs e)
{
switch (HostedServiceStatus)
{
case HostedServiceStatus.Starting:
case HostedServiceStatus.Stopping:
break;
case HostedServiceStatus.Running:
UpdateServiceStatus(HostedServiceStatus.Stopping);
try
{
await bindedService.StopAsync();
}
catch (Exception ex)
{
logError("停止服务时出错：" + ex.Message, ex);
UpdateServiceStatus(HostedServiceStatus.Running, true);
break;
}
UpdateServiceStatus(HostedServiceStatus.Stopped);
break;
case HostedServiceStatus.Stopped:
UpdateServiceStatus(HostedServiceStatus.Starting);
try
{
await bindedService.StartAsync();
}
catch (Exception ex)
{
logError("启动服务时出错：" + ex.Message, ex);
UpdateServiceStatus(HostedServiceStatus.Stopped, true);
break;
}
UpdateServiceStatus(HostedServiceStatus.Running);
break;
default:
break;
}
}
private void ServiceQueuedMainCallback(Object state)
{
//var args = (String[])state;
try
{
//OnStart(args);
var source = new CancellationTokenSource();
_service.StartAsync(source.Token);
//WriteLogEntry(SR.StartSuccessful);
_status.checkPoint = 0;
_status.waitHint = 0;
_status.currentState = ServiceControllerStatus.Running;
}
catch (Exception ex)
{
XTrace.WriteException(ex);
_status.currentState = ServiceControllerStatus.Stopped;
}
_startCompletedSignal.Set();
}
public async Task ComponentError()
{
Routable routable = null;
this.errorComponent.Reset();
this.errorComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
{
routable = x;
});
this.processComponent.Reset();
this.processComponent.Setup(x => x.Process(It.IsAny <Routable>())).Callback((Routable x) =>
{
throw new Kyameru.Core.Exceptions.ProcessException("Manual Error");
});
IHostedService service = this.GetHostedService();
await service.StartAsync(CancellationToken.None);
await service.StopAsync(CancellationToken.None);
Assert.IsTrue(this.IsInError(routable, "Processing component"));
}
public void SaveResults(User currentUser, TrainingSetupModel model)
{
var session = new TrainingSession
{
StartDate = model.StartDate,
User = currentUser,
TrainingLogs = new List <TrainingLog>(),
Status = TrainingSessionStatus.InProgress,
EmotionType = EmotionUtil.GetEmotionType(model.SelectedEmotion)
};
var sources = model.Sources.Select(x => new TrainingSource
{
SourceUrl = x,
TrainingSession = session
});
session.TrainingSources = sources.ToList();
trainingRepository.Add(session);
// HERE WE SHOULD START LOGGING PROCESS
hostedService.StartAsync(new CancellationToken(false));
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var scope = _logger.BeginScope(GetScopeState());
_logger.LogInformation("Starting...");
var stopwatch = Stopwatch.StartNew();
try
{
await _inner.StartAsync(cancellationToken);
var elapsed = Math.Round(stopwatch.Elapsed.TotalMilliseconds, 0).ToString(CultureInfo.InvariantCulture);
_logger.LogInformation($"Took {elapsed}ms to start.");
}
catch (Exception ex)
{
_logger.LogCritical(ex, ex.Message);
throw;
}
finally
{
scope.Dispose();
}
}
public void ShouldInitEventScopeAndSubscribeToAccessorEventTest()
{
_messagingService.StartAsync(CancellationToken.None);
_eventConnectionContextMock.Verify(x => x.EventScope(), Times.Once);
_taskEventAccessorMock.Verify(x => x.OnStatusUpdated(It.IsAny <Action <ITaskStatusUpdatedMessage> >()), Times.Once);
}
/// <inheritdoc /> public Task StartAsync(CancellationToken cancellationToken) => _hostedServiceImplementation.StartAsync(cancellationToken);
public void Start()
{
Task.Factory
.StartNew(async() => await _service.StartAsync(CancellationToken.None));
}
public async Task AddHostedService(IHostedService service)
{
_services.Add(service);
await service.StartAsync(_lifetime.ApplicationStopping);
}
public Task StartAsync(CancellationToken cancellationToken)
{
return(_hostedService.StartAsync(cancellationToken));
}
public async Task <IActionResult> StartCounter()
{
await counterService.StartAsync(new CancellationToken(false));
return(Ok("Counter Service Started"));
}
public Task StartAsync(CancellationToken cancellationToken) => _underlyingService.StartAsync(cancellationToken);
