/*
* Empire - A multi-player, client/server Internet based war game.
- * Copyright (C) 1986-2006, Dave Pare, Jeff Bailey, Thomas Ruschak,
- * Ken Stevens, Steve McClure
+ * Copyright (C) 1986-2013, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ * Ken Stevens, Steve McClure, Markus Armbruster
*
- * This program is free software; you can redistribute it and/or modify
+ * Empire is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* ---
*
* ---
*
* update.c: Update scheduler
- *
+ *
* Known contributors to this file:
* Dave Pare, 1994
* Steve McClure, 1996
* Ron Koenderink, 2005
+ * Markus Armbruster, 2007-2012
*/
#include <config.h>
#include <errno.h>
-#include <stdlib.h>
#ifndef _WIN32
#include <sys/wait.h>
#endif
#include <time.h>
+#include "chance.h"
+#include "empthread.h"
+#include "file.h"
+#include "game.h"
#include "misc.h"
+#include "optlist.h"
#include "player.h"
-#include "empthread.h"
#include "prototypes.h"
-#include "optlist.h"
#include "server.h"
-empth_sem_t *update_sem;
-time_t update_time;
+/*
+ * Update is running.
+ * Can be used to suppress messages, or direct them to bulletins.
+ */
+int update_running;
-static void update_wait(void *unused);
-static int run_hook(char *cmd, char *name);
+static time_t update_schedule_anchor;
+static int update_wanted;
+
+static empth_t *update_thread;
+
+static int update_get_schedule(void);
+static void update_sched(void *);
+static void update_run(void);
-/*ARGSUSED*/
void
-update_sched(void *unused)
+update_init(void)
+{
+ struct player *dp;
+ int stacksize;
+
+ update_schedule_anchor = (time(NULL) + 59) / 60 * 60;
+ if (update_get_schedule() < 0)
+ exit(1);
+
+ dp = player_new(-1);
+ if (!dp)
+ exit_nomem();
+ /* FIXME ancient black magic; figure out true stack need */
+ stacksize = 100000 +
+/* finish_sects */ WORLD_X * WORLD_Y * (2 * sizeof(double) +
+ sizeof(char *));
+ update_thread = empth_create(update_sched, stacksize, 0, "Update", dp);
+ if (!update_thread)
+ exit_nomem();
+}
+
+/*
+ * Get the schedule for future updates into update_time[].
+ * Return 0 on success, -1 on failure.
+ */
+static int
+update_get_schedule(void)
{
- int wind;
- time_t now, delta;
-
- update_sem = empth_sem_create("Update", 0);
- empth_create(PP_SCHED, update_wait, (50 * 1024), 0, "UpdateWait",
- "Waits until players idle", 0);
- time(&now);
- if (s_p_etu <= 0) {
- logerror("bad value for s_p_etu (%d)", s_p_etu);
- s_p_etu = 2 * 60;
- logerror("setting s_p_etu to %d", s_p_etu);
+ time_t now = time(NULL);
+ int n = sizeof(update_time) / sizeof(*update_time);
+ int i;
+
+ ef_truncate(EF_UPDATES, 0);
+ ef_extend(EF_UPDATES, n - 1);
+ if (read_schedule(schedulefil, update_time, n,
+ now + 30, update_schedule_anchor) < 0) {
+ logerror("No update schedule!");
+ ef_truncate(EF_UPDATES, 0);
+ return -1;
}
- while (1) {
- time(&now);
- next_update_time(&now, &update_time, &delta);
- if (update_window > 0) {
- wind = (random() % update_window);
- update_time += wind;
- delta += wind;
- }
- logerror("Next update at %s", ctime(&update_time));
- logerror("Next update in %ld seconds", (long)delta);
- /* sleep until update is scheduled to go off */
- empth_sleep(update_time);
- time(&now);
- now += adj_update;
- if (!gamehours(now)) {
- logerror("No update permitted (hours restriction)");
- continue;
+ logerror("Update schedule read");
+ for (i = 0; update_time[i]; i++) ;
+ ef_truncate(EF_UPDATES, i);
+ return 0;
+}
+
+/*ARGSUSED*/
+static void
+update_sched(void *unused)
+{
+ time_t next_update, now;
+
+ player->proc = empth_self();
+ player->cnum = 0;
+ player->god = 1;
+
+ for (;;) {
+ /*
+ * Sleep until the next scheduled update or an unscheduled
+ * wakeup.
+ */
+ next_update = update_time[0];
+ if (next_update) {
+ if (update_window > 0)
+ next_update += roll0(update_window);
+ logerror("Next update at %s", ctime(&next_update));
+ /* sleep until update is scheduled to go off */
+ empth_sleep(next_update);
+ } else {
+ logerror("No update scheduled");
+ /* want to sleep forever, but empthread doesn't provide that */
+ while (empth_sleep(time(NULL) + (60 * 60 * 24)) >= 0) ;
}
- if (!updatetime(&now)) {
- logerror("No update wanted");
- continue;
+
+ now = time(NULL);
+ if (next_update != 0 && now >= next_update) {
+ /* scheduled update time reached */
+ if (now >= next_update + 60)
+ logerror("Missed the update!");
+ else if (update_demand == UPD_DEMAND_SCHED && !demand_check())
+ ;
+ else if (updates_disabled())
+ logerror("Updates disabled...skipping update");
+ else
+ update_wanted = 1;
+ update_schedule_anchor = update_time[0];
}
- if (updates_disabled()) {
- logerror("Updates disabled...skipping update");
- continue;
+ /* else unscheduled update if update_wanted is set */
+
+ if (update_wanted) {
+ update_wanted = 0;
+ update_run();
}
- empth_sem_signal(update_sem);
+
+ update_get_schedule();
}
/*NOTREACHED*/
}
-void
-update_force(void *seconds)
+/*
+ * Trigger an update.
+ * Return 0 on success, -1 on failure.
+ */
+int
+update_trigger(void)
{
- time_t now;
+ logerror("Triggering unscheduled update");
+ update_wanted = 1;
+ empth_wakeup(update_thread);
+ return 0;
+}
- time(&now);
- empth_sleep(now + *(int *)seconds);
- empth_sem_signal(update_sem);
- empth_exit();
+/*
+ * Reload the update schedule.
+ * Return 0 on success, -1 on failure.
+ */
+int
+update_reschedule(void)
+{
+ empth_wakeup(update_thread);
+ return 0;
}
-/*ARGSUSED*/
static void
-update_wait(void *unused)
+update_run(void)
{
struct player *p;
- int running;
- time_t now;
- int stacksize;
- struct player *dp;
- while (1) {
- empth_sem_wait(update_sem);
- update_pending = 1;
- running = 0;
- for (p = player_next(0); p != 0; p = player_next(p)) {
- if (p->state != PS_PLAYING)
- continue;
- if (p->command) {
- pr_flash(p, "Update aborting command\n");
- p->aborted = 1;
- empth_wakeup(p->proc);
- running++;
- }
- }
- time(&now);
- if (running) {
- /* sleep a few, wait for aborts to take effect */
- empth_sleep(now + 2);
- }
- if (*pre_update_hook) {
- if (run_hook(pre_update_hook, "pre-update")) {
- update_pending = 0;
- continue;
- }
- }
- /*
- * we rely on the fact that update's priority is the highest
- * in the land so it can finish before it yields.
- */
- dp = player_new(-1);
- if (!dp) {
- logerror("can't create dummy player for update");
- update_pending = 0;
+ for (p = player_next(NULL); p; p = player_next(p)) {
+ if (p->state != PS_PLAYING)
continue;
+ if (p->command) {
+ pr_flash(p, "Update aborting command\n");
+ p->may_sleep = PLAYER_SLEEP_NEVER;
+ p->aborted = 1;
+ empth_wakeup(p->proc);
}
- stacksize = 100000 +
-/* finish_sects */ WORLD_X * WORLD_Y * (2 * sizeof(double) +
- sizeof(char *));
-
- empth_create(PP_UPDATE, update_main, stacksize, 0,
- "UpdateRun", "Updates the world", dp);
}
- /*NOTREACHED*/
+ empth_rwlock_wrlock(update_lock);
+ if (*pre_update_hook) {
+ if (run_hook(pre_update_hook, "pre-update")) {
+ empth_rwlock_unlock(update_lock);
+ return;
+ }
+ }
+ update_running = 1;
+ update_main();
+ update_running = 0;
+ empth_rwlock_unlock(update_lock);
}
-static int
+int
run_hook(char *cmd, char *name)
{
int status;
-
+
fflush(NULL);
-
+
status = system(cmd);
if (status == 0)
; /* successful exit */
projects / empserver / blobdiff