void StartWallets(CScheduler& scheduler)
{
for (const std::shared_ptr<CWallet>& pwallet : GetWallets()) {
pwallet->postInitProcess();
}
// Schedule periodic wallet flushes and tx rebroadcasts
scheduler.scheduleEvery(MaybeCompactWalletDB, 500);
scheduler.scheduleEvery(MaybeResendWalletTxs, 1000);
}
// Free List Reconstruction Task routine.
//
void dispatch_FreeListReconstruction(void *pUnused, int iUnused)
{
UNUSED_PARAMETER(pUnused);
UNUSED_PARAMETER(iUnused);
if (mudconf.control_flags & CF_DBCHECK)
{
const char *cmdsave = mudstate.debug_cmd;
mudstate.debug_cmd = (char *)"< dbck >";
do_dbck(NOTHING, NOTHING, NOTHING, 0);
Guest.CleanUp();
pcache_trim();
pool_reset();
mudstate.debug_cmd = cmdsave;
}
// Schedule ourselves again.
//
CLinearTimeAbsolute ltaNow;
ltaNow.GetUTC();
CLinearTimeDelta ltd;
ltd.SetSeconds(mudconf.check_interval);
mudstate.check_counter = ltaNow + ltd;
scheduler.DeferTask(mudstate.check_counter, PRIORITY_SYSTEM,
dispatch_FreeListReconstruction, 0, 0);
}
void WalletInit::Start(CScheduler& scheduler) const
{
for (const std::shared_ptr<CWallet>& pwallet : GetWallets()) {
pwallet->postInitProcess();
}
// Run a thread to flush wallet periodically
scheduler.scheduleEvery(MaybeCompactWalletDB, 500);
}
static void microTask(CScheduler& s, boost::mutex& mutex, int& counter, int delta, boost::chrono::system_clock::time_point rescheduleTime)
{
{
boost::unique_lock<boost::mutex> lock(mutex);
counter += delta;
}
boost::chrono::system_clock::time_point noTime = boost::chrono::system_clock::time_point::min();
if (rescheduleTime != noTime) {
CScheduler::Function f = boost::bind(µTask, boost::ref(s), boost::ref(mutex), boost::ref(counter), -delta + 1, noTime);
s.schedule(f, rescheduleTime);
}
}
void init_timer(void)
{
CLinearTimeAbsolute ltaNow;
ltaNow.GetUTC();
// Setup re-occuring Free List Reconstruction task.
//
CLinearTimeDelta ltd;
ltd.SetSeconds((mudconf.check_offset == 0) ? mudconf.check_interval : mudconf.check_offset);
mudstate.check_counter = ltaNow + ltd;
scheduler.DeferTask(mudstate.check_counter, PRIORITY_SYSTEM,
dispatch_FreeListReconstruction, 0, 0);
// Setup re-occuring Database Dump task.
//
ltd.SetSeconds((mudconf.dump_offset == 0) ? mudconf.dump_interval : mudconf.dump_offset);
mudstate.dump_counter = ltaNow + ltd;
scheduler.DeferTask(mudstate.dump_counter, PRIORITY_SYSTEM,
dispatch_DatabaseDump, 0, 0);
// Setup re-occuring Idle Check task.
//
ltd.SetSeconds(mudconf.idle_interval);
mudstate.idle_counter = ltaNow + ltd;
scheduler.DeferTask(mudstate.idle_counter, PRIORITY_SYSTEM,
dispatch_IdleCheck, 0, 0);
// Setup re-occuring Check Events task.
//
mudstate.events_counter = ltaNow + time_15s;
scheduler.DeferTask(mudstate.events_counter, PRIORITY_SYSTEM,
dispatch_CheckEvents, 0, 0);
#ifndef MEMORY_BASED
// Setup re-occuring cache_tick task.
//
ltd.SetSeconds(0);
if (mudconf.cache_tick_period <= ltd)
{
mudconf.cache_tick_period.SetSeconds(1);
}
scheduler.DeferTask(ltaNow+mudconf.cache_tick_period, PRIORITY_SYSTEM,
dispatch_CacheTick, 0, 0);
#endif // !MEMORY_BASED
#if 0
// Setup comsys channel scrubbing.
//
scheduler.DeferTask(ltaNow+time_45s, PRIORITY_SYSTEM, dispatch_CleanChannels, 0, 0);
#endif // 0
// Setup one-shot task to enable restarting 10 seconds after startmux.
//
scheduler.DeferTask(ltaNow+time_15s, PRIORITY_OBJECT, dispatch_CanRestart, 0, 0);
}
void dispatch_CleanChannels(void *pUnused, int iUnused)
{
const char *cmdsave = mudstate.debug_cmd;
mudstate.debug_cmd = (char *)"< cleanchannels >";
do_cleanupchannels();
// Schedule ourselves again.
//
CLinearTimeAbsolute ltaNextTime;
ltaNextTime.GetUTC();
CLinearTimeDelta ltd = time_15m;
ltaNextTime += ltd;
scheduler.DeferTask(ltaNextTime, PRIORITY_SYSTEM, dispatch_CleanChannels, 0, 0);
mudstate.debug_cmd = cmdsave;
}
void do_timewarp(dbref executor, dbref caller, dbref enactor, int eval, int key, char *arg)
{
UNUSED_PARAMETER(eval);
int secs;
secs = mux_atol(arg);
// Sem/Wait queues
//
if ((key == 0) || (key & TWARP_QUEUE))
{
do_queue(executor, caller, enactor, 0, QUEUE_WARP, arg);
}
// Once these are adjusted, we need to Cancel and reschedule the task.
//
CLinearTimeDelta ltd;
ltd.SetSeconds(secs);
if (key & TWARP_DUMP)
{
mudstate.dump_counter -= ltd;
scheduler.CancelTask(dispatch_DatabaseDump, 0, 0);
scheduler.DeferTask(mudstate.dump_counter, PRIORITY_SYSTEM, dispatch_DatabaseDump, 0, 0);
}
if (key & TWARP_CLEAN)
{
mudstate.check_counter -= ltd;
scheduler.CancelTask(dispatch_FreeListReconstruction, 0, 0);
scheduler.DeferTask(mudstate.check_counter, PRIORITY_SYSTEM, dispatch_FreeListReconstruction, 0, 0);
}
if (key & TWARP_IDLE)
{
mudstate.idle_counter -= ltd;
scheduler.CancelTask(dispatch_IdleCheck, 0, 0);
scheduler.DeferTask(mudstate.idle_counter, PRIORITY_SYSTEM, dispatch_IdleCheck, 0, 0);
}
if (key & TWARP_EVENTS)
{
mudstate.events_counter -= ltd;
scheduler.CancelTask(dispatch_CheckEvents, 0, 0);
scheduler.DeferTask(mudstate.events_counter, PRIORITY_SYSTEM, dispatch_CheckEvents, 0, 0);
}
}
// Check Events Task routine.
//
void dispatch_CheckEvents(void *pUnused, int iUnused)
{
UNUSED_PARAMETER(pUnused);
UNUSED_PARAMETER(iUnused);
if (mudconf.control_flags & CF_EVENTCHECK)
{
const char *cmdsave = mudstate.debug_cmd;
mudstate.debug_cmd = (char *)"< eventcheck >";
check_events();
mudstate.debug_cmd = cmdsave;
}
// Schedule ourselves again.
//
CLinearTimeAbsolute ltaNow;
ltaNow.GetUTC();
CLinearTimeDelta ltd = time_15m;
mudstate.events_counter = ltaNow + ltd;
scheduler.DeferTask(mudstate.events_counter, PRIORITY_SYSTEM, dispatch_CheckEvents, 0, 0);
}
// Idle Check Task routine.
//
void dispatch_IdleCheck(void *pUnused, int iUnused)
{
UNUSED_PARAMETER(pUnused);
UNUSED_PARAMETER(iUnused);
if (mudconf.control_flags & CF_IDLECHECK)
{
const char *cmdsave = mudstate.debug_cmd;
mudstate.debug_cmd = (char *)"< idlecheck >";
check_idle();
mudstate.debug_cmd = cmdsave;
}
// Schedule ourselves again.
//
CLinearTimeAbsolute ltaNow;
ltaNow.GetUTC();
CLinearTimeDelta ltd;
ltd.SetSeconds(mudconf.idle_interval);
mudstate.idle_counter = ltaNow + ltd;
scheduler.DeferTask(mudstate.idle_counter, PRIORITY_SYSTEM, dispatch_IdleCheck, 0, 0);
}
// Database Dump Task routine.
//
void dispatch_DatabaseDump(void *pUnused, int iUnused)
{
UNUSED_PARAMETER(pUnused);
UNUSED_PARAMETER(iUnused);
int nNextTimeInSeconds = mudconf.dump_interval;
if (mudconf.control_flags & CF_CHECKPOINT)
{
const char *cmdsave = mudstate.debug_cmd;
mudstate.debug_cmd = (char *)"< dump >";
#ifndef WIN32
if (mudstate.dumping)
{
// There is a dump in progress. These usually happen very quickly.
// We will reschedule ourselves to try again in 20 seconds.
// Ordinarily, you would think "...a dump is a dump...", but some
// dumps might not be the type of dump we're going to do.
//
nNextTimeInSeconds = 20;
}
else
#endif // !WIN32
{
fork_and_dump(0);
}
mudstate.debug_cmd = cmdsave;
}
// Schedule ourselves again.
//
CLinearTimeAbsolute ltaNow;
ltaNow.GetUTC();
CLinearTimeDelta ltd;
ltd.SetSeconds(nNextTimeInSeconds);
mudstate.dump_counter = ltaNow + ltd;
scheduler.DeferTask(mudstate.dump_counter, PRIORITY_SYSTEM, dispatch_DatabaseDump, 0, 0);
}
void dispatch_CacheTick(void *pUnused, int iUnused)
{
UNUSED_PARAMETER(pUnused);
UNUSED_PARAMETER(iUnused);
const char *cmdsave = mudstate.debug_cmd;
mudstate.debug_cmd = (char *)"< cachetick >";
CLinearTimeDelta ltd = 0;
if (mudconf.cache_tick_period <= ltd)
{
mudconf.cache_tick_period.SetSeconds(1);
}
cache_tick();
// Schedule ourselves again.
//
CLinearTimeAbsolute ltaNextTime;
ltaNextTime.GetUTC();
ltaNextTime += mudconf.cache_tick_period;
scheduler.DeferTask(ltaNextTime, PRIORITY_SYSTEM, dispatch_CacheTick, 0, 0);
mudstate.debug_cmd = cmdsave;
}
void CNetFulfilledRequestManager::Controller(CScheduler& scheduler)
{
if (!fLiteMode) {
scheduler.scheduleEvery(std::bind(&CNetFulfilledRequestManager::CheckAndRemove, this), 60000);
}
}
