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