empire/empserver
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

New update scheduler:

Browse source 
(schedulefil): New.
(set_dirs, set_paths): Rename.  Initialize schedulfil.
(read_schedule): New.  Can read several updates, which will be used in
later changesets.
(update_time): Change to array.  Will be used in later changesets.
(update_schedule_anchor): New.
(update_init): Initialize it.
(update_get_schedule): New.
(update_init): Call it to initialize update_time[].
(update_sched): Rewrite.
(update_forced, update_wanted): Replace.
(update_reschedule): New.
(main): Call it on SIGHUP to reload the schedule.
(update_trigger, update_force, force, player_coms): Drop force's
capability to schedule updates in the future, because it's not worth
the trouble to implement again.  Deities can simply edit the schedule
file to schedule updates.  Remove update_force() and
update_trigger()'s parameter.
(upda): Update for new scheduler.  Take care to keep output the same
as far as possible, even though it's ugly, to avoid breaking clients.
(update_policy, adj_update, update_times, hourslop, blitz_time):
econfig keys removed.
(update_demand, UPD_DEMAND_NONE, UPD_DEMAND_SCHED, UPD_DEMAND_ASYNC)
(update_demandpolicy, UDP_NORMAL, UDP_TIMES, UDP_NORMAL, UDP_BLITZ)
(UDP_MAX, UDP_DEFAULT, UDDEM_TMCHECK, UDDEM_COMSET, UDDEM_DISABLE)
(UDDEM_MAX, UDDEM_DEFAULT): econfig key and values replaced.  Users
changed.  wantupd.h is now empty, remove.
(demand_check): External linkage.
(update_policy_check): Now pointless, remove.
(is_daytime_near, min_to_next_daytime, regular_update_time)
(scheduled_update_time, next_scheduled_time, updatetime)
(next_update_time, next_update_check_time): Unused, Remove.

(demand_check, demandupdatecheck): Move call of demand_update_time()
from demand_check(), which controls all demand updates, to
demandupdatecheck(), which controls only unscheduled ones.  Fixes
update command not to lie about the next scheduled demand update.

(demandupdatecheck): Check updates_disabled() so that zdone no longer
claims to trigger an update when it can't.
This commit is contained in:
Markus Armbruster 2007-07-11 22:27:29 +00:00
parent 15f8f48353
commit 71320ed67f
20 changed files with 487 additions and 448 deletions
Download patch file Download diff file Expand all files Collapse all files

185
src/lib/common/wantupd.c
View file

@ -47,26 +47,6 @@
#include "nat.h"
#include "optlist.h"
#include "prototypes.h"
#include "wantupd.h"
void
update_policy_check(void)
{
if (update_policy < 0)
update_policy = UDP_DEFAULT;
if (update_policy > UDP_MAX)
update_policy = UDP_DEFAULT;
if (update_demandpolicy < 0)
update_demandpolicy = UDDEM_DEFAULT;
if (update_demandpolicy > UDDEM_MAX)
update_demandpolicy = UDDEM_DEFAULT;
if (update_wantmin < 1)
update_wantmin = 1;
if (update_wantmin > MAXNOC)
update_wantmin = MAXNOC;
if (blitz_time < 1)
blitz_time = 1;
}
static int
demand_update_time(time_t *now)
@ -78,45 +58,6 @@ demand_update_time(time_t *now)
update_demandtimes);
}
/* When is the next regularly scheduled update from now. */
static void
regular_update_time(time_t *now, time_t *tim, time_t *delta)
{
time_t tw;
int secs_per_update;
tw = *now + adj_update;
secs_per_update = etu_per_update * s_p_etu;
*delta = secs_per_update - (tw % secs_per_update);
*tim = *now + *delta;
}
/* Is this a valid time for a scheduled update. */
static int
scheduled_update_time(time_t *now)
{
struct tm *tm;
tm = localtime(now);
return is_daytime_near(60 * tm->tm_hour + tm->tm_min,
update_times, hourslop);
}
static int
next_scheduled_time(time_t *now, time_t *tim, time_t *delta)
{
struct tm *tm;
int d;
tm = localtime(now);
d = min_to_next_daytime(60 * tm->tm_hour + tm->tm_min, update_times);
if (d < 0)
return 0;
*delta = 60 * d;
*tim = *now + *delta - tm->tm_sec;
return 1;
}
int
demand_update_want(int *want, int *pop, int which)
{
@ -144,12 +85,14 @@ demand_update_want(int *want, int *pop, int which)
return whichwants;
}
static int
/*
* Do we have sufficient votes for a demand update?
*/
int
demand_check(void)
{
struct natstr *natp;
int want, pop, cn, veto;
time_t now;
demand_update_want(&want, &pop, 0);
if (want < update_wantmin) {
@ -158,13 +101,6 @@ demand_check(void)
return 0;
}
time(&now);
if (!demand_update_time(&now)) {
logerror("no demand update, not within hours allowed.");
return 0;
}
veto = 0;
for (cn = 1; 0 != (natp = getnatp(cn)); cn++) {
if (natp->nat_stat == STAT_ACTIVE) {
@ -183,118 +119,17 @@ demand_check(void)
}
/*
* Check if enough countries want an update,
* and if demand updates are allowed now.
* Can we have an unscheduled demand update now?
*/
int
demandupdatecheck(void)
{
if (UDDEM_COMSET != update_demandpolicy) {
logerror("no demand update, not policy.");
return 0;
}
time_t now = time(NULL);
return demand_check();
}
/*
* Is it time for a regular or scheduled update?
* As well, if none of the above, check to see if
* a demand update can occur.
*/
int
updatetime(time_t *now)
{
if (opt_BLITZ && update_policy == UDP_BLITZ) {
logerror("BLITZ Update.");
return 1;
}
if (UDP_NORMAL == update_policy) {
logerror("Regular update, etu type.");
return 1;
}
if (UDP_TIMES == update_policy) {
if (scheduled_update_time(now)) {
logerror("Scheduled update.");
return 1;
}
}
if (UDDEM_DISABLE != update_demandpolicy) {
if (demand_check()) {
logerror("Demand update, at check time.");
return 1;
}
}
return 0;
}
/*
* Return the time, and delta seconds, of the next update.
* If the policy is no regular updates, return the time of
* the next possible check.
*/
void
next_update_time(time_t *now, time_t *tim, time_t *delta)
/* From when */
/* Time of next update */
/* Seconds till next update */
{
time_t stim, sdelta;
switch (update_policy) {
case UDP_NORMAL:
regular_update_time(now, tim, delta);
break;
case UDP_TIMES:
if (!next_scheduled_time(now, tim, delta))
regular_update_time(now, tim, delta);
break;
case UDP_BLITZ:
*delta = (blitz_time * 60) - (*now % (blitz_time * 60));
*tim = *now + *delta;
break;
case UDP_NOREG:
default:
regular_update_time(now, tim, delta);
if (next_scheduled_time(now, &stim, &sdelta)) {
if (*delta > sdelta) {
*delta = sdelta;
*tim = stim;
}
}
break;
}
}
void
next_update_check_time(time_t *now, time_t *tim, time_t *delta)
/* From when */
/* Time of next update */
/* Seconds till next update check */
{
time_t stim, sdelta;
switch (update_policy) {
case UDP_NORMAL:
regular_update_time(now, tim, delta);
break;
case UDP_BLITZ:
*delta = (blitz_time * 60) - (*now % (blitz_time * 60));
*tim = *now + *delta;
break;
case UDP_TIMES:
case UDP_NOREG:
default:
regular_update_time(now, tim, delta);
if (next_scheduled_time(now, &stim, &sdelta)) {
if (*delta > sdelta) {
*delta = sdelta;
*tim = stim;
}
}
}
return update_demand == UPD_DEMAND_ASYNC
&& !updates_disabled()
&& demand_update_time(&now)
&& demand_check();
}
int