public void TestStart1() { using (var scheduler = new DefaultTaskScheduler()) { scheduler.Start(() => "foobar").Result.Should().Be("foobar"); } }
public void executes_scheduled_action_muliple_times() { using (var scheduler = new DefaultTaskScheduler()) { var data = 0; var completionSource = new TaskCompletionSource <bool>(); scheduler.Interval( TimeSpan.FromMilliseconds(20), TaskCreationOptions.LongRunning, () => { data++; completionSource.SetResult(true); }); completionSource.Task.Wait(); data.Should().Be(1); completionSource = new TaskCompletionSource <bool>(); completionSource.Task.Wait(); data.Should().BeGreaterOrEqualTo(2); scheduler.Stop(); } }
public void SetUp() { _taskScheduler = new DefaultTaskScheduler(); _filesystem = new Filesystem(_taskScheduler); _actionCenter = new Mock <IActionCenter>(); _applicationSettings = new Mock <IApplicationSettings>(); }
public void if_task_has_already_started_just_return_the_started_task() { using (var scheduler = new DefaultTaskScheduler(false)) { var data = 0; var completionSource = new TaskCompletionSource <bool>(); scheduler.Interval( TimeSpan.FromMilliseconds(40), TaskCreationOptions.LongRunning, () => { data++; completionSource.SetResult(true); }); scheduler.Interval( TimeSpan.FromMilliseconds(20), TaskCreationOptions.LongRunning, () => { data++; completionSource.SetResult(true); }); completionSource.Task.Wait(); scheduler.Stop(); data.Should().Be(1); } }
public static void ScheduleMetricReporting(this IServiceProvider provider, CancellationTokenSource cancellationTokenSource) { var application = new Application(provider); var scheduler = new DefaultTaskScheduler(); Task.Factory .StartNew(() => { scheduler.Interval(TimeSpan.FromMilliseconds(300), TaskCreationOptions.None, () => { // Run Metrics }, cancellationTokenSource.Token); }); Task.Factory .StartNew(() => { application.Reporter.RunReports(application.Metrics, cancellationTokenSource.Token); }); }
private static int Run <TApp, TOptions>(TOptions options, bool logTimestamps = false, bool logToFile = false) where TApp : class, IApplication <TOptions>, new() { Logging.SetupConsoleLogger(logTimestamps); if (logToFile) { Logging.SetupFileAppender(Constants.ApplicationLogFile); } using (var taskScheduler = new DefaultTaskScheduler()) { var filesystem = new Filesystem(taskScheduler); var app = new TApp(); if (app.RequiresRepository) { using (var repo = PluginRepository.Create(app.ReadOnlyRepository)) { return((int)app.Run(filesystem, repo, options)); } } return((int)app.Run(filesystem, null, options)); } }
public void can_provide_own_token_with_is_then_linked() { Task scheduledTask = null; var token = new CancellationTokenSource(); token.CancelAfter(200); Action action = () => { using (var scheduler = new DefaultTaskScheduler()) { scheduledTask = scheduler.Interval( TimeSpan.FromMilliseconds(40), TaskCreationOptions.LongRunning, async() => { // ReSharper disable MethodSupportsCancellation await Task.Delay(1000); // ReSharper restore MethodSupportsCancellation }, token.Token); // ReSharper disable MethodSupportsCancellation scheduledTask.Wait(); // ReSharper restore MethodSupportsCancellation } }; action.ShouldNotThrow <TaskCanceledException>(); scheduledTask.Status.Should().Be(TaskStatus.RanToCompletion); }
public void TestRemovePeriodic1() { using (var scheduler = new DefaultTaskScheduler()) { scheduler.StopPeriodic(new Mock<IPeriodicTask>().Object).Should().BeFalse(); } }
public void TestFixtureSetUp() { _scheduler = new DefaultTaskScheduler(); _logFileFactory = new PluginLogFileFactory(_scheduler); _actionCenter = new Mock <IActionCenter>(); _settings = new ApplicationSettings(Path.GetTempFileName()); }
/// <summary> /// Renders the documentation to the given path. /// </summary> /// <param name="basePath"></param> public void RenderTo(string basePath) { using (var scheduler = new DefaultTaskScheduler()) { var filesystem = new Filesystem(scheduler); RenderTo(filesystem, basePath); } }
public void TestStartPeriodic1() { using (var scheduler = new DefaultTaskScheduler()) { var task = scheduler.StartPeriodic(() => { }, TimeSpan.FromSeconds(1)); task.Should().NotBeNull(); scheduler.StopPeriodic(task).Should().BeTrue(); } }
private static void SetupResetMetrics() { var resetMetricScheduler = new DefaultTaskScheduler(); resetMetricScheduler.Interval(TimeSpan.FromSeconds(10), TaskCreationOptions.None, () => { // Reset the counter to zero _metrics.Advanced.Counter(SampleMetricRegistry.SentEmailsCounter).Reset(); }); }
public void SetUp() { _taskScheduler = new DefaultTaskScheduler(); _logSourceFactory = new SimplePluginLogSourceFactory(_taskScheduler); _settings = new DataSource(AbstractTextLogSourceAcceptanceTest.File20Mb) { Id = DataSourceId.CreateNew() }; _dataSource = new FileDataSource(_logSourceFactory, _taskScheduler, _settings, TimeSpan.FromMilliseconds(100)); }
public void SetUp() { _serviceContainer = new ServiceContainer(); _taskScheduler = new DefaultTaskScheduler(); _formatMatcher = new SimpleLogFileFormatMatcher(LogFileFormats.GenericText); _logEntryParserPlugin = new SimpleLogEntryParserPlugin(); _serviceContainer.RegisterInstance <ITaskScheduler>(_taskScheduler); _serviceContainer.RegisterInstance <ILogFileFormatMatcher>(_formatMatcher); _serviceContainer.RegisterInstance <ILogEntryParserPlugin>(_logEntryParserPlugin); }
public void logger_factory_is_required() { Action action = () => { var scheduler = new DefaultTaskScheduler(); var factory = SetupReportFactory(); var reporter = new Reporter(_options, factory, _fixture.Metrics, scheduler, null); }; action.ShouldThrow <ArgumentNullException>(); }
public void report_factory_is_required() { Action action = () => { var loggerFactory = new LoggerFactory(); var scheduler = new DefaultTaskScheduler(); var reporter = new Reporter(_options, null, _fixture.Metrics, scheduler, loggerFactory); }; action.ShouldThrow <ArgumentNullException>(); }
public void report_factory_is_required() { Action action = () => { var loggerFactory = new LoggerFactory(); var metrics = new Mock <IMetrics>(); var scheduler = new DefaultTaskScheduler(); var reporter = new Reporter(null, metrics.Object, scheduler, loggerFactory); }; action.ShouldThrow <ArgumentNullException>(); }
public void imetrics_is_required() { Action action = () => { var scheduler = new DefaultTaskScheduler(); var metrics = new Mock <IMetrics>(); var factory = SetupReportFactory(metrics.Object); var reporter = new Reporter(_options, factory, null, scheduler, _loggerFactory); }; action.ShouldThrow <ArgumentNullException>(); }
public void TestStartPeriodic2() { using (var scheduler = new DefaultTaskScheduler()) { int counter = 0; var task = scheduler.StartPeriodic(() => ++counter, TimeSpan.Zero); new object().Property(x => counter).ShouldEventually().BeGreaterOrEqual(100, TimeSpan.FromSeconds(5), "because our periodic task should've been executed at least 100 times by now"); scheduler.StopPeriodic(task); } }
public void can_generate_report_successfully() { var factory = SetupReportFactory(); factory.AddProvider(new TestReportProvider(true, TimeSpan.FromMilliseconds(10))); var scheduler = new DefaultTaskScheduler(); var reporter = new Reporter(new AppMetricsOptions(), factory, _fixture.Metrics, scheduler, _loggerFactory); var token = new CancellationTokenSource(); token.CancelAfter(100); Action action = () => { reporter.RunReports(_fixture.Metrics, token.Token); }; action.ShouldNotThrow(); }
public void when_metric_reporter_fails_continues_to_retry() { var factory = SetupReportFactory(); factory.AddProvider(new TestReportProvider(false, TimeSpan.FromMilliseconds(10))); var scheduler = new DefaultTaskScheduler(); var reporter = new Reporter(_options, factory, _fixture.Metrics, scheduler, _loggerFactory); var token = new CancellationTokenSource(); token.CancelAfter(100); Action action = () => { reporter.RunReports(_fixture.Metrics, token.Token); }; action.ShouldNotThrow(); }
public void throws_if_poll_interval_is_zero() { Action action = () => { using (var scheduler = new DefaultTaskScheduler()) { var completionSource = new TaskCompletionSource <bool>(); scheduler.Interval(TimeSpan.Zero, TaskCreationOptions.LongRunning, () => { completionSource.SetResult(true); }); completionSource.Task.Wait(); scheduler.Stop(); } }; action.ShouldThrow <ArgumentOutOfRangeException>(); }
public void when_metric_report_fails_should_not_throw() { var loggerFactory = new LoggerFactory(); var metrics = new Mock <IMetrics>(); var factory = new ReportFactory(metrics.Object, loggerFactory); factory.AddProvider(new TestReportProvider(false, TimeSpan.FromMilliseconds(10), new Exception())); var scheduler = new DefaultTaskScheduler(); var reporter = new Reporter(factory, metrics.Object, scheduler, loggerFactory); var token = new CancellationTokenSource(); token.CancelAfter(100); Action action = () => { reporter.RunReports(_fixture.Metrics, token.Token); }; action.ShouldNotThrow(); }
public void Setup() { _taskScheduler = new DefaultTaskScheduler(); _formats = new List <SerilogFileFormat>(); _repository = new Mock <ILogFileFormatRepository>(); _repository.Setup(x => x.Formats).Returns(() => _formats); _plugins = new PluginRegistry(); _plugins.Register(new SerilogEntryParserPlugin()); _services = new ServiceContainer(); _services.RegisterInstance <ITaskScheduler>(_taskScheduler); _services.RegisterInstance <ILogFileFormatMatcher>(new SerilogFileFormatMatcher(_repository.Object)); _services.RegisterInstance <IRawFileLogSourceFactory>(new RawFileLogSourceFactory(_taskScheduler)); _services.RegisterInstance <IPluginLoader>(_plugins); _services.RegisterInstance <ILogSourceParserPlugin>(new ParsingLogSourceFactory(_services)); _logSourceFactory = new PluginLogSourceFactory(_services, null); }
private void RunReservoir(IReservoir reservoir) { var scheduler = new DefaultTaskScheduler(); scheduler.Interval( TimeSpan.FromMilliseconds(20), TaskCreationOptions.None, () => { reservoir.GetSnapshot(); reservoir.Reset(); }); SimpleBenchmarkRunner.Run( () => { reservoir.Update(_fixture.Rnd.Next(0, 1000), _fixture.RandomUserValue); }); scheduler.Dispose(); }
public void Setup() { _services = new ServiceContainer(); _taskScheduler = new DefaultTaskScheduler(); _parser = new Mock <ILogSourceParserPlugin>(); _parser.Setup(x => x.CreateParser(It.IsAny <IServiceContainer>(), It.IsAny <ILogSource>())) .Returns((IServiceContainer services, ILogSource source) => { return(new GenericTextLogSource(source, new GenericTextLogEntryParser())); }); _formatMatcher = new SimpleLogFileFormatMatcher(null); _services.RegisterInstance <IRawFileLogSourceFactory>(new RawFileLogSourceFactory(_taskScheduler)); _services.RegisterInstance <ITaskScheduler>(_taskScheduler); _services.RegisterInstance <ILogSourceParserPlugin>(_parser.Object); _services.RegisterInstance <ILogFileFormatMatcher>(_formatMatcher); }
public void can_execute_scheduled_action() { using (var scheduler = new DefaultTaskScheduler()) { var data = 0; var completionSource = new TaskCompletionSource <bool>(); scheduler.Interval(TimeSpan.FromMilliseconds(20), () => { data++; completionSource.SetResult(true); }); completionSource.Task.Wait(); scheduler.Stop(); data.Should().Be(1); } }
public void executes_scheduled_action_with_token() { using (var scheduler = new DefaultTaskScheduler()) { var data = 0; var token = new CancellationTokenSource(); var completionSource = new TaskCompletionSource <bool>(); scheduler.Interval(TimeSpan.FromMilliseconds(20), () => { data++; completionSource.SetResult(true); }, token.Token); completionSource.Task.Wait(token.Token); scheduler.Stop(); data.Should().Be(1); } }
public void gracefully_cancel_task_if_the_action_throws() { Task scheduledTask = null; Action action = () => { using (var scheduler = new DefaultTaskScheduler()) { scheduledTask = scheduler.Interval( TimeSpan.FromMilliseconds(40), TaskCreationOptions.LongRunning, () => throw new InvalidOperationException()); scheduledTask.Wait(); } }; action.ShouldNotThrow(); scheduledTask.Status.Should().Be(TaskStatus.RanToCompletion); }
private static string LoadAndPreprocessScript(IOperationTracker operationTracker, string scriptFilePath) { Log.InfoFormat("Loading '{0}'...", scriptFilePath); var operation = operationTracker.BeginLoadScript(scriptFilePath); string script; try { using (var taskScheduler = new DefaultTaskScheduler()) { var filesystem = new Filesystem(taskScheduler); var processor = new ScriptPreprocessor(filesystem); script = processor.ProcessFile(scriptFilePath, new string[0]); } operation.Success(); } catch (AggregateException e) { var exceptions = Unpack(e); if (exceptions.Count == 1) { var exception = exceptions.First(); operation.Failed(exception); throw exception; } operation.Failed(e); throw; } catch (Exception e) { operation.Failed(e); throw; } return(script); }
private static int TestLoadPlugin(string pluginToLoad, string pluginInterfaceToLoad) { InstallConsoleLogger(); var pluginInterface = typeof(IPlugin).Assembly.GetType(pluginInterfaceToLoad); if (pluginToLoad.EndsWith(".tvp", StringComparison.InvariantCultureIgnoreCase)) { var taskScheduler = new DefaultTaskScheduler(); var filesystem = new Filesystem(taskScheduler); using (var loader = new PluginArchiveLoader(filesystem)) { var group = loader.OpenPlugin(pluginToLoad); group.Load(); if (!group.Status.IsLoaded) { return(-1); } var plugins = group.LoadAllOfType(pluginInterface); if (plugins.Count == 0) { Log.ErrorFormat("The plugin '{0}' doesn't appear to implement '{1}' or there was a problem loading it", pluginToLoad, pluginInterfaceToLoad); return(-2); } if (!group.TryLoadAllTypes()) { return(-3); } return(0); } } else { throw new NotImplementedException(); } }
private static int DeployTo(object script, MethodInfo method, IOperationTracker operationTracker, string nodeAddress, IEnumerable <string> arguments, TimeSpan connectTimeout) { Log.InfoFormat("Executing '{0}' for '{1}'", method, nodeAddress); using (var taskScheduler = new DefaultTaskScheduler()) { var filesystem = new Filesystem(taskScheduler); using (var distributor = new Distributor(operationTracker)) using (var localNode = new LocalNode(operationTracker, filesystem)) using (var remoteNode = distributor.ConnectTo(nodeAddress, connectTimeout)) { var args = new List <object>(); var parameters = method.GetParameters(); if (parameters[0].ParameterType == typeof(INode) && parameters.Length >= 2 && parameters[1].ParameterType == typeof(INode)) { args.Add(localNode); } args.Add(remoteNode); if (parameters[parameters.Length - 1].ParameterType == typeof(string[])) { args.Add(arguments); } var ret = InvokeMethod(script, method, args.ToArray()); if (method.ReturnType == typeof(int)) { return((int)ret); } return(0); } } }
private static void RunRequestsToSample(CancellationToken token) { var scheduler = new DefaultTaskScheduler(); var httpClient = new HttpClient { BaseAddress = ApiBaseAddress }; Task.Run(() => scheduler.Interval( TimeSpan.FromMilliseconds(100), TaskCreationOptions.None, async() => { var uniform = httpClient.GetStringAsync("api/reservoirs/uniform"); var exponentiallyDecaying = httpClient.GetStringAsync("api/reservoirs/exponentially-decaying"); var slidingWindow = httpClient.GetStringAsync("api/reservoirs/sliding-window"); var hdr = httpClient.GetStringAsync("api/reservoirs/high-dynamic-range"); await Task.WhenAll(uniform, exponentiallyDecaying, slidingWindow, hdr); }, token), token); }
public NodeServer(string serviceName, INetworkServiceDiscoverer networkServiceDiscoverer, IEnumerable <string> allowedMachineNames) { LogAllowedHosts(allowedMachineNames); _socket = new SocketEndPoint(EndPointType.Server, serviceName, clientAuthenticator: MachineNameAuthenticator.CreateForServer(allowedMachineNames.ToArray()), networkServiceDiscoverer: networkServiceDiscoverer, heartbeatSettings: new HeartbeatSettings { AllowRemoteHeartbeatDisable = true }); _socket.OnDisconnected += SocketOnOnDisconnected; _taskScheduler = new DefaultTaskScheduler(); _filesystem = new Filesystem(_taskScheduler); _interfaces = new Interfaces(); _socket.CreateServant <IInterfaces>(ObjectIds.Interface, _interfaces); _files = new Files(_filesystem); _socket.CreateServant <IFiles>(ObjectIds.File, _files); _shell = new Shell(); _socket.CreateServant <IShell>(ObjectIds.Shell, _shell); _services = new Services(); _socket.CreateServant <IServices>(ObjectIds.Services, _services); _processes = new Processes(); _socket.CreateServant <IProcesses>(ObjectIds.Processes, _processes); _network = new Network(); _socket.CreateServant <INetwork>(ObjectIds.Network, _network); _registry = new Registry(); _socket.CreateServant <IRegistry>(ObjectIds.Registry, _registry); }
public void TestDispose1() { var scheduler = new DefaultTaskScheduler(); new Action(scheduler.Dispose).ShouldNotThrow(); }
public static int Start(string[] args) { InstallExceptionHandlers(); Log.InfoFormat("Starting tailviewer..."); Log.InfoFormat("Commandline arguments: {0}", string.Join(" ", args)); LogEnvironment(); ApplicationSettings settings = ApplicationSettings.Create(); bool neededPatching; settings.Restore(out neededPatching); if (neededPatching) { // TODO: Save settings right again to complete the upgrade // (maybe we should preserve an old version) } var actionCenter = new ActionCenter(); using (var taskScheduler = new DefaultTaskScheduler()) using (var dataSources = new DataSources(taskScheduler, settings.DataSources)) using (var updater = new AutoUpdater(actionCenter, settings.AutoUpdate)) { if (args.Length > 0) { var filePath = args[0]; if (File.Exists(filePath)) { // Not only do we want to add this file to the list of data sources, // but we also want to select it so the user can view it immediately, regardless // of what was selected previously. var dataSource = dataSources.AddDataSource(filePath); settings.DataSources.SelectedItem = dataSource.Id; } else { Log.ErrorFormat("File '{0}' does not exist, won't open it!", filePath); } } if (settings.AutoUpdate.CheckForUpdates) { // Our initial check for updates is not due to a user action // and therefore we don't need to show a notification when the // application is up-to-date. updater.CheckForUpdates(addNotificationWhenUpToDate: false); } var quickFilters = new QuickFilters(settings.QuickFilters); actionCenter.Add(Changelog.MostRecent); var application = new App(); Dispatcher dispatcher = Dispatcher.CurrentDispatcher; var uiDispatcher = new UiDispatcher(dispatcher); dispatcher.UnhandledException += actionCenter.ReportUnhandledException; TaskScheduler.UnobservedTaskException += actionCenter.ReportUnhandledException; var window = new MainWindow(settings) { DataContext = new MainWindowViewModel(settings, dataSources, quickFilters, actionCenter, updater, uiDispatcher) }; settings.MainWindow.RestoreTo(window); window.Show(); return application.Run(); } }
public void TestFixtureSetUp() { _scheduler = new DefaultTaskScheduler(); }
public void SetUp() { _scheduler = new DefaultTaskScheduler(); }