git.pond.sub.org Git - empserver/blob - src/server/update.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2010, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                           Ken Stevens, Steve McClure
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  *  ---
  21  *
  22  *  See files README, COPYING and CREDITS in the root of the source
  23  *  tree for related information and legal notices.  It is expected
  24  *  that future projects/authors will amend these files as needed.
  25  *
  26  *  ---
  27  *
  28  *  update.c: Update scheduler
  29  *
  30  *  Known contributors to this file:
  31  *     Dave Pare, 1994
  32  *     Steve McClure, 1996
  33  *     Ron Koenderink, 2005
  34  *     Markus Armbruster, 2007-2009
  35  */
  36
  37 #include <config.h>
  38
  39 #include <errno.h>
  40 #ifndef _WIN32
  41 #include <sys/wait.h>
  42 #endif
  43 #include <time.h>
  44 #include "empthread.h"
  45 #include "game.h"
  46 #include "misc.h"
  47 #include "optlist.h"
  48 #include "player.h"
  49 #include "prototypes.h"
  50 #include "server.h"
  51
  52 /*
  53  * Update is running.
  54  * Can be used to suppress messages, or direct them to bulletins.
  55  */
  56 int update_running;
  57
  58 static time_t update_schedule_anchor;
  59 static int update_wanted;
  60
  61 static empth_t *update_thread;
  62
  63 static int update_get_schedule(void);
  64 static void update_sched(void *);
  65 static void update_run(void);
  66
  67 void
  68 update_init(void)
  69 {
  70     struct player *dp;
  71     int stacksize;
  72
  73     update_schedule_anchor = (time(NULL) + 59) / 60 * 60;
  74     if (update_get_schedule() < 0)
  75         exit(1);
  76
  77     play_lock = empth_rwlock_create("Update");
  78     if (!play_lock)
  79         exit_nomem();
  80
  81     dp = player_new(-1);
  82     if (!dp)
  83         exit_nomem();
  84     /* FIXME ancient black magic; figure out true stack need */
  85     stacksize = 100000 +
  86 /* finish_sects */ WORLD_X * WORLD_Y * (2 * sizeof(double) +
  87                                         sizeof(char *));
  88     update_thread = empth_create(update_sched, stacksize, 0, "Update", dp);
  89     if (!update_thread)
  90         exit_nomem();
  91 }
  92
  93 /*
  94  * Get the schedule for future updates into update_time[].
  95  * Return 0 on success, -1 on failure.
  96  */
  97 static int
  98 update_get_schedule(void)
  99 {
 100     time_t now = time(NULL);
 101
 102     if (read_schedule(schedulefil, update_time,
 103                       sizeof(update_time) / sizeof(*update_time),
 104                       now + 30, update_schedule_anchor) < 0) {
 105         logerror("No update schedule!");
 106         update_time[0] = 0;
 107         return -1;
 108     }
 109     logerror("Update schedule read");
 110     return 0;
 111 }
 112
 113 /*ARGSUSED*/
 114 static void
 115 update_sched(void *unused)
 116 {
 117     time_t next_update, now;
 118
 119     player->proc = empth_self();
 120     player->cnum = 0;
 121     player->god = 1;
 122
 123     for (;;) {
 124         /*
 125          * Sleep until the next scheduled update or an unscheduled
 126          * wakeup.
 127          */
 128         next_update = update_time[0];
 129         if (next_update) {
 130             if (update_window > 0)
 131                 next_update += random() % update_window;
 132             logerror("Next update at %s", ctime(&next_update));
 133             /* sleep until update is scheduled to go off */
 134             empth_sleep(next_update);
 135         } else {
 136             logerror("No update scheduled");
 137             /* want to sleep forever, but empthread doesn't provide that */
 138             while (empth_sleep(time(NULL) + (60 * 60 * 24)) >= 0) ;
 139         }
 140
 141         now = time(NULL);
 142         if (next_update != 0 && now >= next_update) {
 143             /* scheduled update time reached */
 144             if (now >= next_update + 60)
 145                 logerror("Missed the update!");
 146             else if (update_demand == UPD_DEMAND_SCHED && !demand_check())
 147                 ;
 148             else if (updates_disabled())
 149                 logerror("Updates disabled...skipping update");
 150             else
 151                 update_wanted = 1;
 152             update_schedule_anchor = update_time[0];
 153         }
 154         /* else unscheduled update if update_wanted is set */
 155
 156         if (update_wanted) {
 157             update_wanted = 0;
 158             update_run();
 159         }
 160
 161         update_get_schedule();
 162     }
 163     /*NOTREACHED*/
 164 }
 165
 166 /*
 167  * Trigger an update.
 168  * Return 0 on success, -1 on failure.
 169  */
 170 int
 171 update_trigger(void)
 172 {
 173     logerror("Triggering unscheduled update");
 174     update_wanted = 1;
 175     empth_wakeup(update_thread);
 176     return 0;
 177 }
 178
 179 /*
 180  * Reload the update schedule.
 181  * Return 0 on success, -1 on failure.
 182  */
 183 int
 184 update_reschedule(void)
 185 {
 186     empth_wakeup(update_thread);
 187     return 0;
 188 }
 189
 190 static void
 191 update_run(void)
 192 {
 193     struct player *p;
 194
 195     for (p = player_next(NULL); p; p = player_next(p)) {
 196         if (p->state != PS_PLAYING)
 197             continue;
 198         if (p->command) {
 199             pr_flash(p, "Update aborting command\n");
 200             p->may_sleep = PLAYER_SLEEP_NEVER;
 201             p->aborted = 1;
 202             empth_wakeup(p->proc);
 203         }
 204     }
 205     empth_rwlock_wrlock(play_lock);
 206     if (*pre_update_hook) {
 207         if (run_hook(pre_update_hook, "pre-update")) {
 208             empth_rwlock_unlock(play_lock);
 209             return;
 210         }
 211     }
 212     update_running = 1;
 213     update_main();
 214     update_running = 0;
 215     empth_rwlock_unlock(play_lock);
 216 }
 217
 218 int
 219 run_hook(char *cmd, char *name)
 220 {
 221     int status;
 222
 223     fflush(NULL);
 224
 225     status = system(cmd);
 226     if (status == 0)
 227         ;                       /* successful exit */
 228     else if (status == -1)
 229         logerror("couldn't execute command processor for %s hook (%s)",
 230                  name, strerror(errno));
 231 #ifndef _WIN32
 232     else if (WIFEXITED(status))
 233         logerror("%s hook terminated unsuccessfully (exit status %d)",
 234                  name, WEXITSTATUS(status));
 235     else if (WIFSIGNALED(status))
 236         logerror("%s hook terminated abnormally (signal %d)",
 237                  name, WTERMSIG(status));
 238 #endif
 239     else if (status)
 240         logerror("%s hook terminated strangely (status %d)",
 241                  name, status);
 242     return status;
 243 }