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