public void PostShouldThrowExceptionAfterStop() { var scheduler = new Scheduler(new FakeLoggerFactory()); scheduler.Start(); scheduler.Stop(); Assert.Throws<InvalidOperationException>(() => scheduler.Post("testing", () => { })); }
static void Main(string[] args) { System.Console.WriteLine("Application started - Esc to quit"); var sessionFactory = NHibernateFactory.AssembleSessionFactory(DATABASE_FILE); ILog consoleLogger = new ConsoleLogger {VerbosityLevel = 2}; ILog databaseLogger = new Logger(new LogEntryDatabaseRepository(sessionFactory)) {VerbosityLevel = 1}; ILog log = new CompositeLogger(consoleLogger, databaseLogger); var iocContainer = new IocContainerForScheduler(); iocContainer.BindToConstant(sessionFactory); var taskDirectory = new DirectoryInfo(Assembly.GetExecutingAssembly().Location).Parent.FullName; var taskScheduler = new Scheduler(iocContainer, taskDirectory, new FileUtilities(), new TimerWithTimestamp(0, 10000), new TimerWithTimestamp(0, 2000), log); taskScheduler.Start(); try { while (System.Console.ReadKey().Key != ConsoleKey.Escape) { } } catch (Exception e) { log.WriteEntry(new LogEntry(e.Source, e.Message, DateTime.Now)); } }
public void ItShouldStartAndStopWithoutExceptions() { var scheduler = new Scheduler(new FakeLoggerFactory()); scheduler.Start(); var stopped = scheduler.Stop().Wait(4000); Assert.True(stopped); }
public void Given_scheduler_with_daily_item() { var context = new TestSchedulerContext(); _scheduler = new Scheduler(context); var runsoon = new TimeSpan(DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second); var foo1 = JobFactory.Daily("Foo1", () => { Console.WriteLine("Foo1"); foo1_calls += 1; }, runsoon, description: "Description for Foo1"); var foo2 = JobFactory.Daily("Foo2", () => Console.WriteLine("Foo2"), runsoon); _scheduler.Schedule(foo1); _scheduler.Schedule(foo2); _scheduler.Start(); Wait.Until(() => foo1_calls > 0, 30); context.MoveToTommorrow(); Wait.Until(() => foo1_calls > 1, 30); context.MoveForwardNDays(2); Wait.Until(() => foo1_calls > 2, 50); }
protected void SubscribeToEvents(HeapRecording instance) { Instance.StatusChanged += (s, _) => RefreshStatus(); Instance.SnapshotsChanged += (s, _) => RefreshSnapshots(); Instance.SymbolsChanged += (s, _) => { Scheduler.Start( RefreshFunctionNames(Instance), TaskExecutionPolicy.RunAsBackgroundTask ); }; }
public void RunByintervalTest() { Scheduler scheduler = null;// new Scheduler(_timer); Expect.Once.On(_timer).Method("Start").With(_interval, null); scheduler.Start(_interval, 1); _mockery.VerifyAllExpectationsHaveBeenMet(); }
public void StartStopTest() { var scheduler = new Scheduler(error => { throw new AggregateException(error); }); var context = new SchedulerContext(); scheduler.Start(new Clock(), false); scheduler.StartScheduling(context); scheduler.PauseForQuiescence(context); scheduler.StopScheduling(context); }
public Form1() { InitializeComponent(); CommonMethods.setCache(HttpRuntime.Cache); mDBController = new DBController(DateTime.Now.Millisecond.ToString()); mScheduler = new Scheduler(DateTime.Now.Millisecond.ToString(), "Windows App"); mScheduler.Start(); mScheduler.writeEventLogEntry("Started Scheduler"); deriveUI(); }
/// <summary> /// 缓冲池 /// </summary> /// <param name="dataBufferSize">缓冲池bufferPool的容量</param> /// <param name="dataBufferCount">单个缓冲buffer容量</param> /// <param name="autoFlushSeconds">刷新时间</param> /// <param name="isBlockMainThread">是否阻塞write线程</param> public DataBufferPool(int dataBufferSize, int dataBufferCount, TimeSpan autoFlushSeconds, bool isBlockMainThread) { m_isBlockMainThread = isBlockMainThread; m_BufferSize = dataBufferSize; m_DataCount = dataBufferCount; m_AutoFlushTime = autoFlushSeconds; m_dataBuffer = new DataBuffer(m_DataCount); //定时刷新 scheduler.Start(autoFlushSeconds, () => AutoFlush()); }
public void TestConstructor() { Scheduler scheduler = new Scheduler("TestConstructor"); Assert.IsFalse(scheduler.Started); scheduler.Start(); Assert.IsTrue(scheduler.Started); scheduler.Stop(); Assert.IsFalse(scheduler.Started); }
public void RecursiveYieldTest() { this.TestFuture = new Future <object>(); var future = Scheduler.Start(TaskReturnValueOfYieldedTask()); Scheduler.Step(); TestFuture.Complete(10); Scheduler.Step(); Assert.AreEqual(10, future.Result); }
public void ChildFutureFailuresDoNotAbortTasksIfHandled() { var failed = new Future <object>(); failed.Fail(new Exception("pancakes")); var f = Scheduler.Start(YieldAndCheck(failed), TaskExecutionPolicy.RunWhileFutureLives); Assert.AreEqual(false, Scheduler.WaitFor(f, 15)); }
public void TakeUntil_TriggerErrorBeforeCheckpoint_FailAndReload() { var store = new InMemoryStateStore("someId"); var engine = CreateQueryEngine(); var reactive = engine.GetReactiveService(); var ex = new Exception(); var source = GetTestableQbservable(reactive, "source", OnNext(100, 1), // 110 OnNext(200, 2), // 210 OnNext(300, 3), // 310 OnNext(400, 4), // 410 OnNext(550, 6), // 550, 800 + 550 // crash at 600 OnNext(900, 9) // 800 + 900 ); Assert.IsNotNull(source); var triggeringSource = GetTestableQbservable(reactive, "triggeringSource", OnError <int>(490, ex) // 500 ); Assert.IsNotNull(triggeringSource); var result = GetTestableQbserver <int>(reactive, "result"); Scheduler.ScheduleAbsolute(10, () => source.TakeUntil(triggeringSource).Subscribe(result, new Uri("s:/sub1"), null)); Scheduler.ScheduleAbsolute(510, () => Checkpoint(engine, store)); Scheduler.ScheduleAbsolute(600, () => RemoveQueryEngine(engine)); Scheduler.ScheduleAbsolute(800, () => Recover(CreateQueryEngine(), store)); Scheduler.Start(); var sub = GetTestableSubscribable <int>("source"); sub.Subscriptions.AssertEqual( ReactiveTest.Subscribe(10, 500), ReactiveTest.Subscribe(800, 800)); var subTrigger = GetTestableSubscribable <int>("triggeringSource"); subTrigger.Subscriptions.AssertEqual( ReactiveTest.Subscribe(10, 10 + 490), ReactiveTest.Subscribe(800, 800)); var res = GetTestableObserver <int>("result"); res.Messages.AssertEqual( OnNext(110, 1), OnNext(210, 2), OnNext(310, 3), OnNext(410, 4), OnError <int>(500, ex)); }
/// <summary> /// 调用开启方法 /// </summary> public static void Start() { try { Scheduler.Start(); } catch (Exception) { throw new Exception("确定配置的参数是否有错误"); } }
private static async Task StartScheduler() { Logger.LogDebug("StartScheduler"); Scheduler = await new StdSchedulerFactory().GetScheduler(); await Scheduler.Start(); await Scheduler.ScheduleJob(GetJob(typeof(ConnectionManagerJob)), GetTrigger(WEEKDAYS_AT_EVERY_MINUTE)); await Scheduler.ScheduleJob(GetJob(typeof(DailyJob)), GetTrigger(WEEKDAYS_AT_2AM)); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); Scheduler.Start(); RegisterCacheEntry(); }
/// <summary> /// Initializes the scheduler. /// </summary> public static void InitializeScheduler() { var scheduler = new Scheduler(new SchedulerTask[] { new KeepAliveTask(5, true), new UpdateTwitterTask(10, true), new UpdateRssFeedsTask(10, true), }, 20); scheduler.Start(); }
public void ChildTaskFailuresAbortTasks() { var f = Scheduler.Start(RunChildTaskThreeTimes(CrashyTask), TaskExecutionPolicy.RunWhileFutureLives); try { Scheduler.WaitFor(f, 5); throw new Exception("WaitFor did not bubble an exception"); } catch (FutureException fe) { Assert.AreEqual("pancakes", fe.InnerException.Message); } }
protected override void OnStartup(StartupEventArgs e) { // Ensure that only one instance of the application can run at any time if (e.Args.Any(a => a == Constants.IgnoreMutexFlag)) { if (!SingleInstance.Start()) { SingleInstance.ShowFirstInstance(); Shutdown(0); return; } } ConfigureLogging(); LogTo.Info("Application start"); LogEnvironmentInfo(); DispatcherHelper.Initialize(); ProxyServer.Start(Kernel.Get <ITwitterContextList>()); Scheduler = Kernel.Get <IScheduler>(); Scheduler.Start(); base.OnStartup(e); CentralHandler = new CentralMessageHandler(Kernel); var conf = Kernel.Get <IConfig>(); var palette = new PaletteHelper(); palette.SetLightDark(conf.Visual.UseDarkTheme); palette.ReplaceAccentColor(conf.Visual.AccentColor); palette.ReplacePrimaryColor(conf.Visual.PrimaryColor); var swatches = new SwatchesProvider().Swatches.ToArray(); var resDict = new ResourceDictionary(); resDict.BeginInit(); { resDict.Add("HashtagBrush", new SolidColorBrush(swatches.First(s => s.Name == conf.Visual.HashtagColor).ExemplarHue.Color)); resDict.Add("LinkBrush", new SolidColorBrush(swatches.First(s => s.Name == conf.Visual.LinkColor).ExemplarHue.Color)); resDict.Add("MentionBrush", new SolidColorBrush(swatches.First(s => s.Name == conf.Visual.MentionColor).ExemplarHue.Color)); resDict.Add("GlobalFontSize", (double)conf.Visual.FontSize); } resDict.EndInit(); Resources.MergedDictionaries.Add(resDict); ChangeLanguage(conf); }
public Task StartAsync(CancellationToken cancellationToken) { _cancellationTokenSource = new CancellationTokenSource(); _scheduler.JobManager.AddJob <EndlessLoopTask, ScheduleOnce>(); _scheduler.JobManager.AddJob <SimpleTask>(new IntervalSchedule(TimeSpan.FromSeconds(20))); _scheduler.JobManager.AddJob <SimpleTask2, ScheduleNever>(); _scheduler.JobManager.AddJob <RestrictedTask, ScheduleNever>(); _scheduler.AddRestriction(new MutexRestriction(typeof(RestrictedTask), typeof(EndlessLoopTask))); _schedulerTask = _scheduler.Start(_cancellationTokenSource.Token); return(Task.CompletedTask); }
/// <summary> /// Initializes the service relationships. /// </summary> protected virtual void Initialise() { PayloadSerializer.Start(); ResourceTracker.Start(); Scheduler.Collector = Collector; Scheduler.Start(); ResourceTracker.Collector = Collector; ResourceTracker.SharedServices = SharedService; ResourceTracker.Start(); }
public void TestExecuteAfterDelayNoDelay() { Scheduler scheduler = new Scheduler("TestExecuteAfterDelay"); scheduler.Start(); scheduler.ExecuteAfterDelay(CounterCallback, null, 0); scheduler.ExecuteAfterDelay(CounterCallback, null, 0); scheduler.ExecuteAfterDelay(CounterCallback, null, 0); Thread.Sleep(500); Assert.IsTrue(counter == 3, "Should have executed Three tasks."); scheduler.Stop(); }
/// <summary> /// Initializes the service relationships. /// </summary> protected virtual void Initialise() { ServiceHandlers?.Start(); ResourceTracker.Start(); Scheduler.Collector = Collector; Scheduler.Start(); ResourceTracker.Collector = Collector; ResourceTracker.SharedServices = SharedService; ResourceTracker.Start(); }
private void MainWindow_DragDrop(object sender, DragEventArgs e) { if (e.Data.GetDataPresent(DataFormats.FileDrop)) { var filenames = (string[])e.Data.GetData(DataFormats.FileDrop); Scheduler.Start( Program.OpenFilenames(filenames, this), TaskExecutionPolicy.RunAsBackgroundTask ); } }
public void YieldValueTest() { var f = Scheduler.Start(TaskYieldValue()); Scheduler.Step(); try { var _ = f.Result; Assert.Fail("Did not raise a TaskYieldedValueException"); } catch (FutureException fe) { Assert.IsInstanceOf <TaskYieldedValueException>(fe.InnerException); } }
public void StartWith_DuringSource() { var store = new InMemoryStateStore("someId"); var engine = CreateQueryEngine(); var reactive = engine.GetReactiveService(); var source = GetTestableQbservable(reactive, "source", OnNext(10, 1), OnNext(20, 2), OnNext(30, 3), OnNext(40, 4), OnCompleted <int>(50) ); var query = source.StartWith(-3, -2, -1); var result = GetTestableQbserver <int>(reactive, "result"); Scheduler.ScheduleAbsolute(100, () => { query.Subscribe(result, new Uri("s:/sub1"), null); }); Scheduler.ScheduleAbsolute(130, () => { Checkpoint(engine, store); RemoveQueryEngine(engine); }); Scheduler.ScheduleAbsolute(200, () => Recover(CreateQueryEngine(), store)); Scheduler.Start(); var sub = GetTestableSubscribable <int>("source"); sub.Subscriptions.AssertEqual( Subscribe(103), Subscribe(200, 250) ); var res = GetTestableObserver <int>("result"); res.Messages.AssertEqual( OnNext(101, -3), OnNext(102, -2), OnNext(103, -1), OnNext(113, 1), OnNext(123, 2), OnNext(230, 3), OnNext(240, 4), OnCompleted <int>(250) ); }
public void WaitForNextStepTest() { var buf = new List <int>(); Scheduler.Start(TaskWaitForNextStep(buf)); Scheduler.Step(); Assert.AreEqual(1, buf.Count); Scheduler.Step(); Assert.AreEqual(2, buf.Count); Scheduler.Step(); Assert.AreEqual(3, buf.Count); }
public void YieldEnumeratorTest() { var buf = new int[1]; long timeStart = Time.Ticks; var f = Scheduler.Start(TaskYieldEnumerator(buf)); Scheduler.Step(); long timeEnd = Time.Ticks; TimeSpan elapsed = new TimeSpan(timeEnd - timeStart); Assert.AreEqual(1000000, buf[0]); }
private async Task RunScheduler(TimeSpan schedulerTime) { CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); var schedulerTask = _scheduler.Start(cancellationTokenSource.Token); // ReSharper disable MethodSupportsCancellation await Task.Delay(schedulerTime).ContinueWith((t) => cancellationTokenSource.Cancel()); var schedulerFinishTimeout = TimeSpan.FromSeconds(1); await Task.WhenAny(schedulerTask, Task.Delay(schedulerFinishTimeout)); // ReSharper restore MethodSupportsCancellation }
public void SkipUntil_CheckpointStateWrittenCorrectlyAfterDispose() { // Check that state is written correctly after we dispose of the other // subscription we are given. var state = Scheduler.CreateStateContainer(); var checkpoints = new[] { OnSave(340, state), }; var xs = Scheduler.CreateHotObservable( OnNext(310, 1), OnNext(350, 4), OnNext(370, 5), OnCompleted <int>(500) ); var ys = Scheduler.CreateHotObservable( OnNext(330, 2), OnCompleted <int>(425) ); var res = Scheduler.Start(() => xs.SkipUntil(ys).Apply(Scheduler, checkpoints)); Assert.AreEqual(xs.Subscriptions[0].Unsubscribe, 500); Assert.AreEqual(ys.Subscriptions[0].Unsubscribe, 330); res.Messages.AssertEqual( OnNext(350, 4), OnNext(370, 5), OnCompleted <int>(500)); var reader = state.CreateReader().Create(null); ReadOperatorHeader(reader); var skipUntilIsDisposed = reader.Read <bool>(); var otherObserverHasSignaled = reader.Read <bool>(); var firstSubscriptionIsDisposed = reader.Read <bool>(); ReadOperatorHeader(reader); var takeIsDisposed = reader.Read <bool>(); var remainingItemsToTake = reader.Read <int>(); Assert.IsFalse(skipUntilIsDisposed); Assert.IsTrue(otherObserverHasSignaled); Assert.IsFalse(firstSubscriptionIsDisposed); Assert.IsTrue(takeIsDisposed); Assert.AreEqual(remainingItemsToTake, 0); }
public void Ctor_TimeSpan_Success() { Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(0.1)); BlockingScheduledAction action = new BlockingScheduledAction(); scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now.AddSeconds(1.0)), action, true, null, null)); scheduler.Start(); Assert.IsTrue(scheduler.IsEnabled); Stopwatch watch = Stopwatch.StartNew(); action.Waiter.WaitOne(); Assert.IsTrue(watch.ElapsedMilliseconds < 2000); scheduler.Dispose(); }
public void WaitForFirstGCTest() { var a = Scheduler.Start(InfiniteTask()); var b = Scheduler.Start(new Sleep(2)); var c = Future.WaitForFirst(a, b); while (!c.Completed) { Scheduler.Step(); GC.Collect(); } Assert.AreEqual(b, c.Result); }
public void RunAsBackgroundTaskExecutionPolicyBubblesExceptionsOutOfSchedulerStep() { Scheduler.Start(CrashyTask(), TaskExecutionPolicy.RunAsBackgroundTask); Scheduler.Step(); try { Scheduler.Step(); Assert.Fail("Exception did not bubble out of Scheduler.Step"); } catch (TaskException ex) { Assert.AreEqual("pancakes", ex.InnerException.Message); } }
public void BindTaskToVariableBubblesExceptions() { object[] r = new object[1]; var _ = Scheduler.Start(BindToChildTask(CrashyTask(), r), TaskExecutionPolicy.RunWhileFutureLives); try { Scheduler.WaitFor(_, 5); Assert.Fail("Exception was not raised"); } catch (FutureException ex) { Assert.AreEqual("pancakes", ex.InnerException.Message); } Assert.AreEqual(null, r[0]); }
public void ExceptionDoesntBubbleOutRepeatedly() { var f = Scheduler.Start(CallsCrashyTask(), TaskExecutionPolicy.RunAsBackgroundTask); Scheduler.Step(); try { Scheduler.Step(); Assert.Fail("Exception was not raised"); } catch (TaskException ex) { Assert.AreEqual("pancakes", ex.InnerException.Message); } Scheduler.Step(); }
public void MultipleIterations_Success() { Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(0.1)); BlockingScheduledAction action1 = new BlockingScheduledAction(10); scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateInterval(DateTimeOffset.Now, TimeSpan.FromMilliseconds(100.0), Weekdays.All), action1, true, null, null)); BlockingScheduledAction action2 = new BlockingScheduledAction(5); scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateInterval(DateTimeOffset.Now, TimeSpan.FromMilliseconds(200.0), Weekdays.All), action2, true, null, null)); scheduler.Start(); Stopwatch watch = Stopwatch.StartNew(); ManualResetEvent.WaitAny(new WaitHandle[] { action1.Waiter, action2.Waiter }); Assert.IsTrue(watch.ElapsedMilliseconds < 1200); scheduler.Dispose(); }
public void Given_scheduler_with_some_work() { var ctx = new TestSchedulerContext(); _scheduler = new Scheduler(ctx); _scheduler.Schedule("Foo1", () => { _foo1WorkDone = true; }, TimeSpan.FromMinutes(10)); _scheduler.Schedule("Foo2", () => { _foo2WorkDone = true; }, TimeSpan.FromMinutes(10)); // Lest ensure that all workitems // are applicable for schedule ctx.MoveToTommorrow(); _scheduler.Start(); Wait.Until(() => _scheduler.GatherOveralStats().RunningJobs + _scheduler.GatherOveralStats().ScheduledJobs == 0); }
protected override void OnStart(string[] args) { _scheduler = new Scheduler(); _scheduler.Start(); }
private void RunTasks() { var sessionFactory = NHibernateFactory.AssembleSessionFactory(DatabaseFile); var logger = new Logger(new LogEntryDatabaseRepository(sessionFactory)) { VerbosityLevel = 1 }; var iocContaier = new IocContainerForScheduler(); iocContaier.BindToConstant(sessionFactory); var taskDirectory = new DirectoryInfo(Assembly.GetExecutingAssembly().Location).Parent.FullName; var taskScheduler = new Scheduler(iocContaier, taskDirectory, new FileUtilities(), new TimerWithTimestamp(0, 10000), new TimerWithTimestamp(0, 2000), logger); taskScheduler.Start(); }
/// <summary> /// Application entry point. /// </summary> /// <param name="args">The execution arguments.</param> /// <returns>The application's exit code.</returns> public static int Main(string[] args) { int all = 0, backup = 0, man = 0, schedules = 0, restore = 0; string target = null; var options = new OptionSet() { { "a|all", "execute all backup and restore targets in the configuration.", v => { ++all; } }, { "b|backup", "execute backup targets.", v => { ++backup; } }, { "r|restore", "execute restore targets.", v => { ++restore; } }, { "s|schedules", "execute schedules.", v => { ++schedules; } }, { "t|target=", "the name of the specific backup/restore/schedule to execute.", v => target = v }, { "m|man", "show this message", v => { ++man; } } }; try { options.Parse(args); } catch (OptionException ex) { ParseError(options, ex); return 1; } if (man > 0) { Help(options); return 0; } if (all > 0) { ExecuteBackup(String.Empty); ExecuteRestore(String.Empty); } else if (backup > 0) { if (!ExecuteBackup(target)) { return 1; } } else if (restore > 0) { if (!ExecuteRestore(target)) { return 1; } } else if (schedules > 0) { ScheduleConfigurationElementCollection schd = new ScheduleConfigurationElementCollection(); if (!String.IsNullOrEmpty(target)) { var schedule = SThreeQLConfiguration.Section.Schedules[target]; if (schedule != null) { schd.Add(schedule); } else { WriteError("There is no schedule defined for \"{0}\".", target); return 1; } } else { foreach (var schedule in SThreeQLConfiguration.Section.Schedules) { schd.Add(schedule); } } Scheduler scheduler = new Scheduler(schd); scheduler.BackupComplete += new EventHandler<DatabaseTargetEventArgs>(BackupComplete); scheduler.BackupCompressComplete += new EventHandler<DatabaseTargetEventArgs>(BackupCompressComplete); scheduler.BackupCompressStart += new EventHandler<DatabaseTargetEventArgs>(BackupCompressStart); scheduler.BackupStart += new EventHandler<DatabaseTargetEventArgs>(BackupStart); scheduler.BackupTransferComplete += new EventHandler<DatabaseTargetEventArgs>(BackupTransferComplete); scheduler.BackupTransferProgress += new EventHandler<DatabaseTargetEventArgs>(BackupTransferProgress); scheduler.BackupTransferStart += new EventHandler<DatabaseTargetEventArgs>(BackupTransferStart); scheduler.RestoreComplete += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreComplete); scheduler.RestoreDecompressComplete += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreDecompressComplete); scheduler.RestoreDecompressStart += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreDecompressStart); scheduler.RestoreStart += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreStart); scheduler.RestoreTransferComplete += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreTransferComplete); scheduler.RestoreTransferProgress += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreTransferProgress); scheduler.RestoreTransferStart += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreTransferStart); scheduler.ScheduleComplete += new EventHandler<ScheduleEventArgs>(ScheduleComplete); scheduler.ScheduleError += new EventHandler<ScheduleEventArgs>(ScheduleError); scheduler.ScheduleStart += new EventHandler<ScheduleEventArgs>(ScheduleStart); scheduler.Start(); } else { Help(options); return 0; } return 0; }
public void Stop_TimeoutNegative_Error() { Scheduler<CancellableScheduledAction> scheduler = new Scheduler<CancellableScheduledAction>(TimeSpan.FromSeconds(0.1)); scheduler.Stop(); scheduler.Start(); CustomAssert.ThrowsException<CodedArgumentOutOfRangeException>(() => { scheduler.Stop(TimeSpan.FromSeconds(-1.0)); }); scheduler.Dispose(); }
public void Stop_TimeoutExpired_Error() { Scheduler<WaitingScheduledAction> scheduler = new Scheduler<WaitingScheduledAction>(TimeSpan.FromSeconds(0.1)); WaitingScheduledAction action1 = new WaitingScheduledAction(); scheduler.Tasks.Add(new ScheduledTask<WaitingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now), action1, true, null, null)); scheduler.Start(); action1.StartWaiter.WaitOne(); CustomAssert.ThrowsException<CodedTimeoutException>(() => { scheduler.Stop(TimeSpan.FromSeconds(0.5)); }); action1.Waiter.Set(); scheduler.Dispose(); }
public void Interval_Success() { Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(1000.0)); BlockingScheduledAction action1 = new BlockingScheduledAction(5); scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateInterval(DateTimeOffset.Now, TimeSpan.FromMilliseconds(200.0), Weekdays.All), action1, true, null, null)); scheduler.Start(); Assert.AreEqual(1000.0, scheduler.Interval.TotalSeconds); scheduler.Interval = TimeSpan.FromSeconds(0.1); Stopwatch watch = Stopwatch.StartNew(); action1.Waiter.WaitOne(); Assert.IsTrue(watch.ElapsedMilliseconds < 1200); scheduler.Dispose(); }
public void TaskStarting_TaskCompleted_Success() { bool TaskStartingExecuted = false; bool TaskCompletedExecuted = false; Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(0.1)); scheduler.TaskCompleted += (sender, e) => { TaskCompletedExecuted = true; }; scheduler.TaskStarting += (sender, e) => { TaskStartingExecuted = true; }; BlockingScheduledAction action1 = new BlockingScheduledAction(); scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now), action1, true, null, null)); scheduler.Start(); action1.Waiter.WaitOne(); scheduler.Stop(); Assert.IsTrue(TaskCompletedExecuted, nameof(TaskCompletedExecuted)); Assert.IsTrue(TaskStartingExecuted, nameof(TaskStartingExecuted)); scheduler.Dispose(); }
private static void RunBot() { try { var scheduler = new Scheduler(); var container = CreateCompositionContainer(); // Add all the sprockets to the sprocket list var announcements = container.GetExportedValues<IAnnounce>(); Console.WriteLine(String.Format("Connecting to {0}...", _serverUrl)); Bot bot = new Bot(_serverUrl, _botName, _botPassword); foreach (var s in container.GetExportedValues<ISprocket>()) bot.AddSprocket(s); bot.PowerUp(); JoinRooms(bot); var users = bot.GetUsers(bot.Rooms.First()); var user = bot.GetUserInfo(bot.Rooms.First(), users.First().Name.ToString()); scheduler.Start(announcements, bot); Console.Write("Press enter to quit..."); Console.ReadLine(); scheduler.Stop(); bot.ShutDown(); _appShouldExit = true; } catch (Exception e) { Console.WriteLine("ERROR: " + e.GetBaseException().Message); } }
public void Disposed_Error() { Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(); scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now), new BlockingScheduledAction(), true, null, null)); scheduler.Start(); scheduler.Start(); scheduler.Dispose(); scheduler.Dispose(); scheduler.Stop(); CustomAssert.ThrowsException<ObjectDisposedException>(() => { int i = scheduler.Tasks.Count; }); }
public void TaskStarting_Canceled_Success() { bool TaskStartingExecuted = false; Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(0.1)); scheduler.TaskStarting += (sender, e) => { e.Cancel = true; TaskStartingExecuted = true; }; BlockingScheduledAction action1 = new BlockingScheduledAction(); ScheduledTask<BlockingScheduledAction> task = new ScheduledTask<BlockingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now), action1, true, null, null); scheduler.Tasks.Add(task); scheduler.Start(); SpinWait.SpinUntil(() => { return TaskStartingExecuted; }); scheduler.Stop(); Assert.IsNull(task.LastEndTime); scheduler.Dispose(); }