[ViewVC] Diff of: cvs/deliantra/server/lib/cf.pm

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.174 by root, Sun Jan 14 19:55:37 2007 UTC vs.
Revision 1.187 by root, Sat Jan 20 21:06:52 2007 UTC

 use Storable;
 use Opcode;
 use Safe;
 use Safe::Hole;
-use Coro 3.3 ();
+use Coro 3.4 ();
 use Coro::Event;
 use Coro::Timer;
 use Coro::Signal;
 use Coro::Semaphore;
 use Coro::AIO;
    my $runtime = cf::localdir . "/runtime";
    my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
       or return;
+   my $value = $cf::RUNTIME + 90 + 10;
-   my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock
+   # 10 is the runtime save interval, for a monotonic clock
+   # 60 allows for the watchdog to kill the server.
    (aio_write $fh, 0, (length $value), $value, 0) <= 0
       and return;
    aio_fsync $fh
       and return;
 sub exists($) {
    my ($login) = @_;
    $cf::PLAYER{$login}
-      or cf::sync_job { !aio_stat $login }
+      or cf::sync_job { !aio_stat path $login }
 }
 sub find($) {
    return $cf::PLAYER{$_[0]} || do {
       my $login = $_[0];
 our $MAX_RESET     = 3600;
 our $DEFAULT_RESET = 3000;
 sub generate_random_map {
    my ($self, $rmp) = @_;
    # mit "rum" bekleckern, nicht
    $self->_create_random_map (
       $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
       $rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
       $rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
       $rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
       (cf::region::find $rmp->{region}), $rmp->{custom}
    )
 }
+=item cf::map->register ($regex, $prio)
+Register a handler for the map path matching the given regex at the
+givne priority (higher is better, built-in handlers have priority 0, the
+default).
+=cut
 sub register {
-   my (undef, $regex) = @_;
+   my (undef, $regex, $prio) = @_;
    my $pkg = caller;
    no strict;
    push @{"$pkg\::ISA"}, __PACKAGE__;
-   $EXT_MAP{$pkg} = qr<$regex>;
+   $EXT_MAP{$pkg} = [$prio, qr<$regex>];
 }
 # also paths starting with '/'
-$EXT_MAP{"cf::map"} = qr{^(?=/)};
+$EXT_MAP{"cf::map"} = [0, qr{^(?=/)}];
 sub thawer_merge {
    my ($self, $merge) = @_;
    # we have to keep some variables in memory intact
    return $path if UNIVERSAL::isa $path, "cf::map"; # already a map object
    $path = normalise $path, $base;
-   for my $pkg (keys %EXT_MAP) {
+   for my $pkg (sort { $EXT_MAP{$b}[0] <=> $EXT_MAP{$a}[0] } keys %EXT_MAP) {
-      if ($path =~ $EXT_MAP{$pkg}) {
+      if ($path =~ $EXT_MAP{$pkg}[1]) {
          my $self = bless cf::map::new, $pkg;
          $self->{path} = $path; $self->path ($path);
          $self->init; # pass $1 etc.
          return $self;
       }
       $map->load_header
          or return;
       if ($map->should_reset) {
+         # doing this can freeze the server in a sync job, obviously
-         $cf::WAIT_FOR_TICK->wait;
+         #$cf::WAIT_FOR_TICK->wait;
          $map->reset;
          undef $guard;
          $map = find $path
             or return;
       }
    cf::sync_job { $map->load };
 }
 our %MAP_PREFETCH;
-our $MAP_PREFETCHER = Coro::async {
+our $MAP_PREFETCHER = undef;
-   while () {
-      for my $path (keys %MAP_PREFETCH) {
-         my $map = find $path
-            or next;
-         $map->load;
-         delete $MAP_PREFETCH{$path};
-      }
-      Coro::schedule;
-   }
-};
 sub find_async {
    my ($path, $origin) = @_;
    $path = normalise $path, $origin && $origin->{path};
    if (my $map = $cf::MAP{$path}) {
       return $map if $map->in_memory == cf::MAP_IN_MEMORY;
    }
-   $MAP_PREFETCH{$path} = 0;
+   undef $MAP_PREFETCH{$path};
-   $MAP_PREFETCHER->ready;
+   $MAP_PREFETCHER ||= cf::async {
+      while (%MAP_PREFETCH) {
+         for my $path (keys %MAP_PREFETCH) {
+            my $map = find $path
+               or next;
+            $map->load;
+            delete $MAP_PREFETCH{$path};
+         }
+      }
+      undef $MAP_PREFETCHER;
+   };
    ()
 }
 sub save {
 sub parse_random_map_params {
    my ($spec) = @_;
    my $rmp = { # defaults
-      xsize => 10,
+      xsize    => (cf::rndm 15, 40),
-      ysize => 10,
+      ysize    => (cf::rndm 15, 40),
+      symmetry => (cf::rndm 1, cf::SYMMETRY_XY),
+      #layout   => string,
    };
    for (split /\n/, $spec) {
       my ($k, $v) = split /\s+/, $_, 2;
    $rmp
 }
 sub prepare_random_map {
    my ($exit) = @_;
+   my $guard = cf::lock_acquire "exit_prepare:$exit";
    # all this does is basically replace the /! path by
    # a new random map path (?random/...) with a seed
    # that depends on the exit object
    $rmp->{random_seed} ||= $exit->random_seed;
    my $data = cf::to_json $rmp;
    my $md5 = Digest::MD5::md5_hex $data;
+   my $meta = "$cf::RANDOM_MAPS/$md5.meta";
-   if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY | O_CREAT, 0666) {
+   if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) {
       aio_write $fh, 0, (length $data), $data, 0;
+      undef $fh;
+      aio_rename "$meta~", $meta;
       $exit->slaying ("?random/$md5");
       $exit->msg (undef);
    }
 }
    sub db_sync() {
       db_save if $dirty;
       undef $dirty;
    }
-   my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, data => WF_AUTOCANCEL, cb => sub {
+   my $idle = Event->idle (min => 10, max => 20, repeat => 0, data => WF_AUTOCANCEL, cb => sub {
       db_sync;
    });
    sub db_dirty() {
       $dirty = 1;
 sub main {
    # we must not ever block the main coroutine
    local $Coro::idle = sub {
       Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
+      (async {
-      async { Event::one_event };
+         Event::one_event;
+      })->prio (Coro::PRIO_MAX);
    };
    cfg_load;
    db_load;
    load_extensions;
+   $TICK_WATCHER->start;
    Event::loop;
 }
 #############################################################################
 # initialisation and cleanup
 }
 sub reload() {
    # can/must only be called in main
    if ($Coro::current != $Coro::main) {
-      warn "can only reload from main coroutine\n";
+      warn "can only reload from main coroutine";
       return;
    }
    warn "reloading...";
-   warn "freezing server";
+   warn "cancelling server ticker";
-   my $guard = freeze_mainloop;
+   $TICK_WATCHER->cancel;
    cf::emergency_save;
-   warn "sync database to disk";
-   cf::db_sync;
-   IO::AIO::flush;
    eval {
       # if anything goes wrong in here, we should simply crash as we already saved
+      warn "syncing database to disk";
+      cf::db_sync;
-      warn "cancel all watchers";
+      warn "cancelling all WF_AUTOCANCEL watchers";
       for (Event::all_watchers) {
          $_->cancel if $_->data & WF_AUTOCANCEL;
       }
+      warn "flushing outstanding aio requests";
+      for (;;) {
+         IO::AIO::flush;
+         Coro::cede;
+         last unless IO::AIO::nreqs;
+         warn "iterate...";
+      }
-      warn "cancel all extension coros";
+      warn "cancelling all extension coros";
       $_->cancel for values %EXT_CORO;
       %EXT_CORO = ();
-      warn "remove commands";
+      warn "removing commands";
       %COMMAND = ();
-      warn "remove ext commands";
+      warn "removing ext commands";
       %EXTCMD = ();
-      warn "unload/nuke all extensions";
+      warn "unloading/nuking all extensions";
       for my $pkg (@EXTS) {
          warn "... unloading $pkg";
          if (my $cb = $pkg->can ("unload")) {
             eval {
          warn "... nuking $pkg";
          Symbol::delete_package $pkg;
       }
-      warn "unload all perl modules loaded from $LIBDIR";
+      warn "unloading all perl modules loaded from $LIBDIR";
       while (my ($k, $v) = each %INC) {
          next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
-         warn "removing <$k>";
+         warn "... unloading $k";
          delete $INC{$k};
          $k =~ s/\.pm$//;
          $k =~ s/\//::/g;
          }
          Symbol::delete_package $k;
       }
-      warn "get rid of safe::, as good as possible";
+      warn "getting rid of safe::, as good as possible";
       Symbol::delete_package "safe::$_"
          for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
-      warn "unload cf.pm \"a bit\"";
+      warn "unloading cf.pm \"a bit\"";
       delete $INC{"cf.pm"};
       # don't, removes xs symbols, too,
       # and global variables created in xs
       #Symbol::delete_package __PACKAGE__;
+      warn "unload completed, starting to reload now";
       warn "reloading cf.pm";
       require cf;
       cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
-      warn "load config and database again";
+      warn "loading config and database again";
       cf::cfg_load;
       cf::db_load;
-      warn "load extensions";
+      warn "loading extensions";
       cf::load_extensions;
-      warn "reattach attachments to objects/players";
+      warn "reattaching attachments to objects/players";
       _global_reattach;
-      warn "reattach attachments to maps";
+      warn "reattaching attachments to maps";
       reattach $_ for values %MAP;
+      warn "restarting server ticker";
+      $TICK_WATCHER->start;
    };
    if ($@) {
       warn $@;
       warn "error while reloading, exiting.";
    }
    warn "reloaded";
 };
+our $RELOAD_WATCHER; # used only during reload
 register_command "reload" => sub {
    my ($who, $arg) = @_;
    if ($who->flag (FLAG_WIZ)) {
-      $who->message ("start of reload.");
+      $who->message ("reloading server.");
+      # doing reload synchronously and two reloads happen back-to-back,
+      # coro crashes during coro_state_free->destroy here.
+      $RELOAD_WATCHER ||= Event->timer (after => 0, data => WF_AUTOCANCEL, cb => sub {
-      reload;
+         reload;
-      $who->message ("end of reload.");
+         undef $RELOAD_WATCHER;
+      });
    }
 };
 unshift @INC, $LIBDIR;
+my $bug_warning = 0;
 $TICK_WATCHER = Event->timer (
    reentrant => 0,
+   parked    => 1,
    prio      => 0,
    at        => $NEXT_TICK || $TICK,
    data      => WF_AUTOCANCEL,
    cb        => sub {
+      if ($Coro::current != $Coro::main) {
+         Carp::cluck "major BUG: server tick called outside of main coro, skipping it"
+            unless ++$bug_warning > 10;
+         return;
+      }
       $NOW = Event::time;
       cf::server_tick; # one server iteration
       $RUNTIME   += $TICK;
       $NEXT_TICK += $TICK;
    cb   => \&IO::AIO::poll_cb,
 );
 $WRITE_RUNTIME_WATCHER = Event->timer (
    data     => WF_AUTOCANCEL,
-   after    => 0,
+   after    => 1,
    interval => 10,
-   cb       => sub {
+   prio     => 6,  # keep it lowest so it acts like a watchdog
-      (Coro::unblock_sub {
+   cb       => Coro::unblock_sub {
-         write_runtime
+      write_runtime
-            or warn "ERROR: unable to write runtime file: $!";
+         or warn "ERROR: unable to write runtime file: $!";
-      })->();
    },
 );
 END { cf::emergency_save }

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.174 by root, Sun Jan 14 19:55:37 2007 UTC vs. Revision 1.187 by root, Sat Jan 20 21:06:52 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.174 by root, Sun Jan 14 19:55:37 2007 UTC vs.
Revision 1.187 by root, Sat Jan 20 21:06:52 2007 UTC