--- deliantra/server/lib/cf.pm	2007/10/15 17:50:27	1.386
+++ deliantra/server/lib/cf.pm	2008/04/13 01:34:09	1.419
@@ -1,3 +1,24 @@
+# 
+# This file is part of Deliantra, the Roguelike Realtime MMORPG.
+# 
+# Copyright (©) 2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+# 
+# Deliantra 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 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# 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, see <http://www.gnu.org/licenses/>.
+# 
+# The authors can be reached via e-mail to <support@deliantra.net>
+# 
+
 package cf;
 
 use utf8;
@@ -6,29 +27,30 @@
 use Symbol;
 use List::Util;
 use Socket;
-use Event;
+use EV 3.2;
 use Opcode;
 use Safe;
 use Safe::Hole;
 use Storable ();
 
-use Coro 4.1 ();
+use Coro 4.50 ();
 use Coro::State;
 use Coro::Handle;
-use Coro::Event;
+use Coro::EV;
 use Coro::Timer;
 use Coro::Signal;
 use Coro::Semaphore;
 use Coro::AIO;
+use Coro::BDB;
 use Coro::Storable;
 use Coro::Util ();
 
-use JSON::XS ();
+use JSON::XS 2.01 ();
 use BDB ();
 use Data::Dumper;
 use Digest::MD5;
 use Fcntl;
-use YAML::Syck ();
+use YAML ();
 use IO::AIO 2.51 ();
 use Time::HiRes;
 use Compress::LZF;
@@ -40,11 +62,6 @@
 Coro::State::cctx_stacksize 256000; # 1-2MB stack, for deep recursions in maze generator
 Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
 
-$Event::Eval = 1; # no idea why this is required, but it is
-
-# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
-$YAML::Syck::ImplicitUnicode = 1;
-
 $Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
 
 sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
@@ -72,13 +89,12 @@
 our $PLAYERDIR = "$LOCALDIR/" . playerdir;
 our $RANDOMDIR = "$LOCALDIR/random";
 our $BDBDIR    = "$LOCALDIR/db";
+our %RESOURCE;
 
 our $TICK = MAX_TIME * 1e-6; # this is a CONSTANT(!)
-our $TICK_WATCHER;
 our $AIO_POLL_WATCHER;
 our $NEXT_RUNTIME_WRITE; # when should the runtime file be written
 our $NEXT_TICK;
-our $NOW;
 our $USE_FSYNC = 1; # use fsync to write maps - default off
 
 our $BDB_POLL_WATCHER;
@@ -91,6 +107,7 @@
 
 our $UPTIME; $UPTIME ||= time;
 our $RUNTIME;
+our $NOW;
 
 our (%PLAYER, %PLAYER_LOADING); # all users
 our (%MAP,    %MAP_LOADING   ); # all maps
@@ -101,7 +118,8 @@
 
 our $LOAD;       # a number between 0 (idle) and 1 (too many objects)
 our $LOADAVG;    # same thing, but with alpha-smoothing
-our $tick_start; # for load detecting purposes
+our $JITTER;     # average jitter
+our $TICK_START; # for load detecting purposes
 
 binmode STDOUT;
 binmode STDERR;
@@ -164,7 +182,7 @@
 
 =item %cf::CFG
 
-Configuration for the server, loaded from C</etc/crossfire/config>, or
+Configuration for the server, loaded from C</etc/deliantra-server/config>, or
 from wherever your confdir points to.
 
 =item cf::wait_for_tick, cf::wait_for_tick_begin
@@ -196,6 +214,21 @@
    };
 }
 
+$Coro::State::DIEHOOK = sub {
+   return unless $^S eq 0; # "eq", not "=="
+
+   if ($Coro::current == $Coro::main) {#d#
+      warn "DIEHOOK called in main context, Coro bug?\n";#d#
+      return;#d#
+   }#d#
+
+   # kill coroutine otherwise
+   warn Carp::longmess $_[0];
+   Coro::terminate
+};
+
+$SIG{__DIE__} = sub { }; #d#?
+
 @safe::cf::global::ISA         = @cf::global::ISA         = 'cf::attachable';
 @safe::cf::object::ISA         = @cf::object::ISA         = 'cf::attachable';
 @safe::cf::player::ISA         = @cf::player::ISA         = 'cf::attachable';
@@ -217,7 +250,7 @@
    @{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;
 }
 
-$Event::DIED = sub {
+$EV::DIED = sub {
    warn "error in event callback: @_";
 };
 
@@ -250,11 +283,11 @@
    } || "[unable to dump $_[0]: '$@']";
 }
 
-=item $ref = cf::from_json $json
+=item $ref = cf::decode_json $json
 
 Converts a JSON string into the corresponding perl data structure.
 
-=item $json = cf::to_json $ref
+=item $json = cf::encode_json $ref
 
 Converts a perl data structure into its JSON representation.
 
@@ -262,8 +295,8 @@
 
 our $json_coder = JSON::XS->new->utf8->max_size (1e6); # accept ~1mb max
 
-sub to_json   ($) { $json_coder->encode ($_[0]) }
-sub from_json ($) { $json_coder->decode ($_[0]) }
+sub encode_json($) { $json_coder->encode ($_[0]) }
+sub decode_json($) { $json_coder->decode ($_[0]) }
 
 =item cf::lock_wait $string
 
@@ -329,13 +362,24 @@
 }
 
 sub freeze_mainloop {
-   return unless $TICK_WATCHER->is_active;
+   tick_inhibit_inc;
 
-   my $guard = Coro::guard {
-      $TICK_WATCHER->start;
-   };
-   $TICK_WATCHER->stop;
-   $guard
+   Coro::guard \&tick_inhibit_dec;
+}
+
+=item cf::periodic $interval, $cb
+
+Like EV::periodic, but randomly selects a starting point so that the actions
+get spread over timer.
+
+=cut
+
+sub periodic($$) {
+   my ($interval, $cb) = @_;
+
+   my $start = rand List::Util::min 180, $interval;
+
+   EV::periodic $start, $interval, 0, $cb
 }
 
 =item cf::get_slot $time[, $priority[, $name]]
@@ -408,8 +452,8 @@
 
 =item cf::sync_job { BLOCK }
 
-The design of Crossfire TRT requires that the main coroutine ($Coro::main)
-is always able to handle events or runnable, as Crossfire TRT is only
+The design of Deliantra requires that the main coroutine ($Coro::main)
+is always able to handle events or runnable, as Deliantra is only
 partly reentrant. Thus "blocking" it by e.g. waiting for I/O is not
 acceptable.
 
@@ -424,15 +468,13 @@
    my ($job) = @_;
 
    if ($Coro::current == $Coro::main) {
-      my $time = Event::time;
+      my $time = EV::time;
 
       # this is the main coro, too bad, we have to block
       # till the operation succeeds, freezing the server :/
       
       LOG llevError, Carp::longmess "sync job";#d#
 
-      # TODO: use suspend/resume instead
-      # (but this is cancel-safe)
       my $freeze_guard = freeze_mainloop;
 
       my $busy = 1;
@@ -446,15 +488,16 @@
       })->prio (Coro::PRIO_MAX);
 
       while ($busy) {
-         Coro::cede or Event::one_event;
+         if (Coro::nready) {
+            Coro::cede_notself;
+         } else {
+            EV::loop EV::LOOP_ONESHOT;
+         }
       }
 
-      $time = Event::time - $time;
+      my $time = EV::time - $time;
 
-      LOG llevError | logBacktrace, Carp::longmess "long sync job"
-         if $time > $TICK * 0.5 && $TICK_WATCHER->is_active;
-
-      $tick_start += $time; # do not account sync jobs to server load
+      $TICK_START += $time; # do not account sync jobs to server load
 
       wantarray ? @res : $res[0]
    } else {
@@ -489,7 +532,7 @@
 Executes the given code block with the given arguments in a seperate
 process, returning the results. Everything must be serialisable with
 Coro::Storable. May, of course, block. Note that the executed sub may
-never block itself or use any form of Event handling.
+never block itself or use any form of event handling.
 
 =cut
 
@@ -508,6 +551,33 @@
    wantarray ? @res : $res[-1]
 }
 
+=item $coin = coin_from_name $name
+
+=cut
+
+our %coin_alias = (
+   "silver"        => "silvercoin",
+   "silvercoin"    => "silvercoin",
+   "silvercoins"   => "silvercoin",
+   "gold"          => "goldcoin",
+   "goldcoin"      => "goldcoin",
+   "goldcoins"     => "goldcoin",
+   "platinum"      => "platinacoin",
+   "platinumcoin"  => "platinacoin",
+   "platinumcoins" => "platinacoin",
+   "platina"       => "platinacoin",
+   "platinacoin"   => "platinacoin",
+   "platinacoins"  => "platinacoin",
+   "royalty"       => "royalty",
+   "royalties"     => "royalty",
+);
+
+sub coin_from_name($) {
+   $coin_alias{$_[0]}
+      ? cf::arch::find $coin_alias{$_[0]}
+      : undef
+}
+
 =item $value = cf::db_get $family => $key
 
 Returns a single value from the environment database.
@@ -660,7 +730,7 @@
 
 In the following description, CLASS can be any of C<global>, C<object>
 C<player>, C<client> or C<map> (i.e. the attachable objects in
-Crossfire TRT).
+Deliantra).
 
 =over 4
 
@@ -952,7 +1022,7 @@
    0
 }
 
-=item $bool = cf::global::invoke (EVENT_CLASS_XXX, ...)
+=item $bool = cf::global->invoke (EVENT_CLASS_XXX, ...)
 
 =item $bool = $attachable->invoke (EVENT_CLASS_XXX, ...)
 
@@ -1040,7 +1110,7 @@
    on_instantiate => sub {
       my ($obj, $data) = @_;
 
-      $data = from_json $data;
+      $data = decode_json $data;
 
       for (@$data) {
          my ($name, $args) = @$_;
@@ -1079,7 +1149,7 @@
             if (@$objs) {
                if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
                   chmod SAVE_MODE, $fh;
-                  my $data = Coro::Storable::blocking_nfreeze { version => 1, objs => $objs };
+                  my $data = Coro::Storable::nfreeze { version => 1, objs => $objs };
                   aio_write $fh, 0, (length $data), $data, 0;
                   aio_fsync $fh if $cf::USE_FSYNC;
                   close $fh;
@@ -1120,8 +1190,7 @@
       (aio_load "$filename.pst", $av) >= 0
          or return;
 
-      my $st = eval { Coro::Storable::thaw $av }
-            || eval { my $guard = Coro::Storable::guard; Storable::thaw $av }; #d# compatibility, remove
+      my $st = eval { Coro::Storable::thaw $av };
       $av = $st->{objs};
    }
 
@@ -1288,8 +1357,7 @@
 
                if (exists $v->{meta}{mandatory}) {
                   warn $msg;
-                  warn "mandatory extension failed to load, exiting.\n";
-                  exit 1;
+                  cf::cleanup "mandatory extension failed to load, exiting.";
                }
                
                warn $msg;
@@ -1547,46 +1615,88 @@
 
 =cut
 
+use re 'eval';
+
+my $group;
+my $interior; $interior = qr{
+   # match a pod interior sequence sans C<< >>
+   (?:
+      \ (.*?)\  (?{ $group = $^N })
+      | < (??{$interior}) >
+   )
+}x;
+
 sub expand_cfpod {
-   ((my $self), (local $_)) = @_;
+   my ($self, $pod) = @_;
+
+   my $xml;
 
-   # escape & and <
-   s/&/&amp;/g;
-   s/(?<![BIUGHT])</&lt;/g;
-
-   # this is buggy, it needs to properly take care of nested <'s
-
-   1 while
-      # replace B<>, I<>, U<> etc.
-      s/B<([^\>]*)>/<b>$1<\/b>/
-      || s/I<([^\>]*)>/<i>$1<\/i>/
-      || s/U<([^\>]*)>/<u>$1<\/u>/
-      || s/T<([^\>]*)>/<big><b>$1<\/b><\/big>/
-      # replace G<male|female> tags
-      || s{G<([^>|]*)\|([^>]*)>}{
-         $self->gender ? $2 : $1
-      }ge
-      # replace H<hint text>
-      || s{H<([^\>]*)>}
-          {
-             ("<fg name=\"lightblue\">[$1 (Use hintmode to suppress hints)]</fg>",
-              "<fg name=\"lightblue\">[Hint suppressed, see hintmode]</fg>",
-              "")
-                [$self->{hintmode}]
-          }ge;
-
-   # create single paragraphs (very hackish)
-   s/(?<=\S)\n(?=\w)/ /g;
-
-   # compress some whitespace
-   s/\s+\n/\n/g; # ws line-ends
-   s/\n\n+/\n/g; # double lines
-   s/^\n+//;     # beginning lines
-   s/\n+$//;     # ending lines
+   while () {
+      if ($pod =~ /\G( (?: [^BCGHITU]+ | .(?!<) )+ )/xgcs) {
+         $group = $1;
+
+         $group =~ s/&/&amp;/g;
+         $group =~ s/</&lt;/g;
 
-   $_
+         $xml .= $group;
+      } elsif ($pod =~ m%\G
+                  ([BCGHITU])
+                  <
+                     (?:
+                        ([^<>]*) (?{ $group = $^N })
+                        | < $interior >
+                     )
+                  >
+               %gcsx
+      ) {
+         my ($code, $data) = ($1, $group);
+
+         if ($code eq "B") {
+            $xml .= "<b>" . expand_cfpod ($self, $data) . "</b>";
+         } elsif ($code eq "I") {
+            $xml .= "<i>" . expand_cfpod ($self, $data) . "</i>";
+         } elsif ($code eq "U") {
+            $xml .= "<u>" . expand_cfpod ($self, $data) . "</u>";
+         } elsif ($code eq "C") {
+            $xml .= "<tt>" . expand_cfpod ($self, $data) . "</tt>";
+         } elsif ($code eq "T") {
+            $xml .= "<big><b>" . expand_cfpod ($self, $data) . "</b></big>";
+         } elsif ($code eq "G") {
+            my ($male, $female) = split /\|/, $data;
+            $data =  $self->gender ? $female : $male;
+            $xml .= expand_cfpod ($self, $data);
+         } elsif ($code eq "H") {
+             $xml .= ("<fg name=\"lightblue\">[" . expand_cfpod ($self, $data) . " (Use hintmode to suppress hints)]</fg>",
+                      "<fg name=\"lightblue\">[Hint suppressed, see hintmode]</fg>",
+                      "")
+                        [$self->{hintmode}];
+         } else {
+            $xml .= "error processing '$code($data)' directive";
+         }
+      } else {
+         if ($pod =~ /\G(.+)/) {
+            warn "parse error while expanding $pod (at $1)";
+         }
+         last;
+      }
+   }
+
+   for ($xml) {
+      # create single paragraphs (very hackish)
+      s/(?<=\S)\n(?=\w)/ /g;
+
+      # compress some whitespace
+      s/\s+\n/\n/g; # ws line-ends
+      s/\n\n+/\n/g; # double lines
+      s/^\n+//;     # beginning lines
+      s/\n+$//;     # ending lines
+   }
+
+   $xml
 }
 
+no re 'eval';
+
 sub hintmode {
    $_[0]{hintmode} = $_[1] if @_ > 1;
    $_[0]{hintmode}
@@ -1667,6 +1777,9 @@
 
 sub generate_random_map {
    my ($self, $rmp) = @_;
+
+   my $lock = cf::lock_acquire "generate_random_map"; # the random map generator is NOT reentrant ATM
+
    # mit "rum" bekleckern, nicht
    $self->_create_random_map (
       $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
@@ -1798,7 +1911,7 @@
 sub save_path {
    my ($self) = @_;
 
-   (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
+   (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/go;
    "$TMPDIR/$path.map"
 }
 
@@ -1806,7 +1919,7 @@
 sub uniq_path {
    my ($self) = @_;
 
-   (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
+   (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/go;
    "$UNIQUEDIR/$path"
 }
 
@@ -2262,15 +2375,14 @@
    [
       map {
          utf8::decode $_;
-         /\.map$/
-            ? normalise $_
-            : ()
+         s/\.map$//; # TODO future compatibility hack
+         /\.pst$/ || !/^$PATH_SEP/o # TODO unique maps apparebntly lack the .map suffix :/
+            ? ()
+            : normalise $_
       } @{ aio_readdir $UNIQUEDIR or [] }
    ]
 }
 
-package cf;
-
 =back
 
 =head3 cf::object
@@ -2283,7 +2395,8 @@
 
 =item $ob->inv_recursive
 
-Returns the inventory of the object _and_ their inventories, recursively.
+Returns the inventory of the object I<and> their inventories, recursively,
+but I<not> the object itself.
 
 =cut
 
@@ -2298,7 +2411,7 @@
 
 =item $ref = $ob->ref
 
-creates and returns a persistent reference to an objetc that can be stored as a string.
+Creates and returns a persistent reference to an object that can be stored as a string.
 
 =item $ob = cf::object::deref ($refstring)
 
@@ -2582,7 +2695,7 @@
 
    $rmp->{random_seed} ||= $exit->random_seed;
 
-   my $data = cf::to_json $rmp;
+   my $data = cf::encode_json $rmp;
    my $md5 = Digest::MD5::md5_hex $data;
    my $meta = "$RANDOMDIR/$md5.meta";
 
@@ -2665,6 +2778,7 @@
 
 =cut
 
+# non-persistent channels (usually the info channel)
 our %CHANNEL = (
    "c/identify" => {
       id      => "infobox",
@@ -2678,12 +2792,42 @@
       reply   => undef,
       tooltip => "Signs and other items you examined",
    },
+   "c/book" => {
+      id      => "infobox",
+      title   => "Book",
+      reply   => undef,
+      tooltip => "The contents of a note or book",
+   },
    "c/lookat" => {
       id      => "infobox",
       title   => "Look",
       reply   => undef,
       tooltip => "What you saw there",
    },
+   "c/who" => {
+      id      => "infobox",
+      title   => "Players",
+      reply   => undef,
+      tooltip => "Shows players who are currently online",
+   },
+   "c/body" => {
+      id      => "infobox",
+      title   => "Body Parts",
+      reply   => undef,
+      tooltip => "Shows which body parts you posess and are available",
+   },
+   "c/uptime" => {
+      id      => "infobox",
+      title   => "Uptime",
+      reply   => undef,
+      tooltip => "How long the server has been running since last restart",
+   },
+   "c/mapinfo" => {
+      id      => "infobox",
+      title   => "Map Info",
+      reply   => undef,
+      tooltip => "Information related to the maps",
+   },
 );
 
 sub cf::client::send_msg {
@@ -3061,6 +3205,7 @@
 
       while (my ($face, $info) = each %$faces) {
          my $idx = (cf::face::find $face) || cf::face::alloc $face;
+
          cf::face::set_visibility $idx, $info->{visibility};
          cf::face::set_magicmap   $idx, $info->{magicmap};
          cf::face::set_data $idx, 0, $info->{data32}, Digest::MD5::md5 $info->{data32};
@@ -3071,8 +3216,10 @@
 
       while (my ($face, $info) = each %$faces) {
          next unless $info->{smooth};
+
          my $idx = cf::face::find $face
             or next;
+
          if (my $smooth = cf::face::find $info->{smooth}) {
             cf::face::set_smooth      $idx, $smooth;
             cf::face::set_smoothlevel $idx, $info->{smoothlevel};
@@ -3100,52 +3247,58 @@
       # that gcfclient doesn't grok a >10000 face index.
       my $res = $facedata->{resource};
 
-      my $soundconf = delete $res->{"res/sound.conf"};
-
       while (my ($name, $info) = each %$res) {
-         my $idx = (cf::face::find $name) || cf::face::alloc $name;
-         my $data;
-
-         if ($info->{type} & 1) {
-            # prepend meta info
+         if (defined $info->{type}) {
+            my $idx = (cf::face::find $name) || cf::face::alloc $name;
+            my $data;
+
+            if ($info->{type} & 1) {
+               # prepend meta info
+
+               my $meta = $enc->encode ({
+                  name => $name,
+                  %{ $info->{meta} || {} },
+               });
 
-            my $meta = $enc->encode ({
-               name => $name,
-               %{ $info->{meta} || {} },
-            });
+               $data = pack "(w/a*)*", $meta, $info->{data};
+            } else {
+               $data = $info->{data};
+            }
 
-            $data = pack "(w/a*)*", $meta, $info->{data};
+            cf::face::set_data $idx, 0, $data, Digest::MD5::md5 $data;
+            cf::face::set_type $idx, $info->{type};
          } else {
-            $data = $info->{data};
+            $RESOURCE{$name} = $info;
          }
 
-         cf::face::set_data $idx, 0, $data, Digest::MD5::md5 $data;
-         cf::face::set_type $idx, $info->{type};
-
          cf::cede_to_tick;
       }
+   }
 
-      if ($soundconf) {
-         $soundconf = $enc->decode (delete $soundconf->{data});
+   cf::global->invoke (EVENT_GLOBAL_RESOURCE_UPDATE);
 
-         for (0 .. SOUND_CAST_SPELL_0 - 1) {
-            my $sound = $soundconf->{compat}[$_]
-               or next;
+   1
+}
 
-            my $face = cf::face::find "sound/$sound->[1]";
-            cf::sound::set $sound->[0] => $face;
-            cf::sound::old_sound_index $_, $face; # gcfclient-compat
-         }
+cf::global->attach (on_resource_update => sub {
+   if (my $soundconf = $RESOURCE{"res/sound.conf"}) {
+      $soundconf = JSON::XS->new->utf8->relaxed->decode ($soundconf->{data});
 
-         while (my ($k, $v) = each %{$soundconf->{event}}) {
-            my $face = cf::face::find "sound/$v";
-            cf::sound::set $k => $face;
-         }
+      for (0 .. SOUND_CAST_SPELL_0 - 1) {
+         my $sound = $soundconf->{compat}[$_]
+            or next;
+
+         my $face = cf::face::find "sound/$sound->[1]";
+         cf::sound::set $sound->[0] => $face;
+         cf::sound::old_sound_index $_, $face; # gcfclient-compat
       }
-   }
 
-   1
-}
+      while (my ($k, $v) = each %{$soundconf->{event}}) {
+         my $face = cf::face::find "sound/$v";
+         cf::sound::set $k => $face;
+      }
+   }
+});
 
 register_exticmd fx_want => sub {
    my ($ns, $want) = @_;
@@ -3210,7 +3363,7 @@
       or return;
 
    local $/;
-   *CFG = YAML::Syck::Load <$fh>;
+   *CFG = YAML::Load <$fh>;
 
    $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
 
@@ -3232,7 +3385,7 @@
       Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
       (async {
          $Coro::current->{desc} = "IDLE BUG HANDLER";
-         Event::one_event;
+         EV::loop EV::LOOP_ONESHOT;
       })->prio (Coro::PRIO_MAX);
    };
 
@@ -3240,8 +3393,9 @@
    db_init;
    load_extensions;
 
-   $TICK_WATCHER->start;
-   Event::loop;
+   $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
+   evthread_start IO::AIO::poll_fileno;
+   EV::loop;
 }
 
 #############################################################################
@@ -3249,20 +3403,15 @@
 
 # install some emergency cleanup handlers
 BEGIN {
+   our %SIGWATCHER = ();
    for my $signal (qw(INT HUP TERM)) {
-      Event->signal (
-         reentrant => 0,
-         data      => WF_AUTOCANCEL,
-         signal    => $signal,
-         prio      => 0,
-         cb        => sub {
-            cf::cleanup "SIG$signal";
-         },
-      );
+      $SIGWATCHER{$signal} = EV::signal $signal, sub {
+         cf::cleanup "SIG$signal";
+      };
    }
 }
 
-sub write_runtime {
+sub write_runtime_sync {
    my $runtime = "$LOCALDIR/runtime";
 
    # first touch the runtime file to show we are still running:
@@ -3300,6 +3449,49 @@
    1
 }
 
+our $uuid_lock;
+our $uuid_skip;
+
+sub write_uuid_sync($) {
+   $uuid_skip ||= $_[0];
+
+   return if $uuid_lock;
+   local $uuid_lock = 1;
+
+   my $uuid = "$LOCALDIR/uuid";
+
+   my $fh = aio_open "$uuid~", O_WRONLY | O_CREAT, 0644
+      or return;
+
+   my $value = uuid_str $uuid_skip + uuid_seq uuid_cur;
+   $uuid_skip = 0;
+
+   (aio_write $fh, 0, (length $value), $value, 0) <= 0
+      and return;
+
+   # always fsync - this file is important
+   aio_fsync $fh
+      and return;
+
+   close $fh
+      or return;
+
+   aio_rename "$uuid~", $uuid
+      and return;
+
+   warn "uuid file written ($value).\n";
+
+   1
+
+}
+
+sub write_uuid($$) {
+   my ($skip, $sync) = @_;
+
+   $sync ? write_uuid_sync $skip
+         : async { write_uuid_sync $skip };
+}
+
 sub emergency_save() {
    my $freeze_guard = cf::freeze_mainloop;
 
@@ -3329,6 +3521,10 @@
       warn "begin emergency database checkpoint\n";
       BDB::db_env_txn_checkpoint $DB_ENV;
       warn "end emergency database checkpoint\n";
+
+      warn "begin write uuid\n";
+      write_uuid_sync 1;
+      warn "end write uuid\n";
    };
 
    warn "leave emergency perl save\n";
@@ -3353,25 +3549,20 @@
    warn "entering sync_job";
 
    cf::sync_job {
-      cf::write_runtime; # external watchdog should not bark
+      cf::write_runtime_sync; # external watchdog should not bark
       cf::emergency_save;
-      cf::write_runtime; # external watchdog should not bark
+      cf::write_runtime_sync; # external watchdog should not bark
 
       warn "syncing database to disk";
       BDB::db_env_txn_checkpoint $DB_ENV;
 
       # if anything goes wrong in here, we should simply crash as we already saved
 
-      warn "cancelling all WF_AUTOCANCEL watchers";
-      for (Event::all_watchers) {
-         $_->cancel if $_->data & WF_AUTOCANCEL;
-      }
-
       warn "flushing outstanding aio requests";
       for (;;) {
          BDB::flush;
          IO::AIO::flush;
-         Coro::cede;
+         Coro::cede_notself;
          last unless IO::AIO::nreqs || BDB::nreqs;
          warn "iterate...";
       }
@@ -3457,8 +3648,7 @@
       1
    } or do {
       warn $@;
-      warn "error while reloading, exiting.";
-      exit 1;
+      cf::cleanup "error while reloading, exiting.";
    };
 
    warn "reloaded";
@@ -3470,15 +3660,10 @@
    # doing reload synchronously and two reloads happen back-to-back,
    # coro crashes during coro_state_free->destroy here.
 
-   $RELOAD_WATCHER ||= Event->timer (
-      reentrant => 0,
-      after     => 0,
-      data      => WF_AUTOCANCEL,
-      cb => sub {
-         do_reload_perl;
-         undef $RELOAD_WATCHER;
-      },
-   );
+   $RELOAD_WATCHER ||= EV::timer 0, 0, sub {
+      do_reload_perl;
+      undef $RELOAD_WATCHER;
+   };
 }
 
 register_command "reload" => sub {
@@ -3501,7 +3686,7 @@
 our @WAIT_FOR_TICK_BEGIN;
 
 sub wait_for_tick {
-   return unless $TICK_WATCHER->is_active;
+   return if tick_inhibit;
    return if $Coro::current == $Coro::main;
 
    my $signal = new Coro::Signal;
@@ -3510,7 +3695,7 @@
 }
 
 sub wait_for_tick_begin {
-   return unless $TICK_WATCHER->is_active;
+   return if tick_inhibit;
    return if $Coro::current == $Coro::main;
 
    my $signal = new Coro::Signal;
@@ -3518,83 +3703,49 @@
    $signal->wait;
 }
 
-$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 = $tick_start = Event::time;
-
-      cf::server_tick; # one server iteration
-
-      $RUNTIME   += $TICK;
-      $NEXT_TICK += $TICK;
-
-      if ($NOW >= $NEXT_RUNTIME_WRITE) {
-         $NEXT_RUNTIME_WRITE = $NOW + 10;
-         Coro::async_pool {
-            $Coro::current->{desc} = "runtime saver";
-            write_runtime
-               or warn "ERROR: unable to write runtime file: $!";
-         };
-      }
-
-      if (my $sig = shift @WAIT_FOR_TICK_BEGIN) {
-         $sig->send;
-      }
-      while (my $sig = shift @WAIT_FOR_TICK) {
-         $sig->send;
-      }
+sub tick {
+   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
 
-      # if we are delayed by four ticks or more, skip them all
-      $NEXT_TICK = $NOW if $NOW >= $NEXT_TICK + $TICK * 4;
+   if ($NOW >= $NEXT_RUNTIME_WRITE) {
+      $NEXT_RUNTIME_WRITE = List::Util::max $NEXT_RUNTIME_WRITE + 10, $NOW + 5.;
+      Coro::async_pool {
+         $Coro::current->{desc} = "runtime saver";
+         write_runtime_sync
+            or warn "ERROR: unable to write runtime file: $!";
+      };
+   }
 
-      $TICK_WATCHER->at ($NEXT_TICK);
-      $TICK_WATCHER->start;
+   if (my $sig = shift @WAIT_FOR_TICK_BEGIN) {
+      $sig->send;
+   }
+   while (my $sig = shift @WAIT_FOR_TICK) {
+      $sig->send;
+   }
 
-      $LOAD = ($NOW - $tick_start) / $TICK;
-      $LOADAVG = $LOADAVG * 0.75 + $LOAD * 0.25;
+   $LOAD = ($NOW - $TICK_START) / $TICK;
+   $LOADAVG = $LOADAVG * 0.75 + $LOAD * 0.25;
 
-      _post_tick;
-   },
-);
+   if (0) {
+      if ($NEXT_TICK) {
+         my $jitter = $TICK_START - $NEXT_TICK;
+         $JITTER = $JITTER * 0.75 + $jitter * 0.25;
+         warn "jitter $JITTER\n";#d#
+      }
+   }
+}
 
 {
-   BDB::min_parallel 8;
-   BDB::max_poll_time $TICK * 0.1;
-   $BDB_POLL_WATCHER = Event->io (
-      reentrant => 0,
-      fd        => BDB::poll_fileno,
-      poll      => 'r',
-      prio      => 0,
-      data      => WF_AUTOCANCEL,
-      cb        => \&BDB::poll_cb,
-   );
+   # configure BDB
 
-   BDB::set_sync_prepare {
-      my $status;
-      my $current = $Coro::current;
-      (
-         sub {
-            $status = $!;
-            $current->ready; undef $current;
-         },
-         sub {
-            Coro::schedule while defined $current;
-            $! = $status;
-         },
-      )
-   };
+   BDB::min_parallel 8;
+   BDB::max_poll_reqs $TICK * 0.1;
+   $Coro::BDB::WATCHER->priority (1);
 
    unless ($DB_ENV) {
       $DB_ENV = BDB::db_env_create;
@@ -3619,51 +3770,23 @@
       };
    }
 
-   $BDB_DEADLOCK_WATCHER = Event->timer (
-      after     => 3,
-      interval  => 1,
-      hard      => 1,
-      prio      => 0,
-      data      => WF_AUTOCANCEL,
-      cb        => sub {
-         BDB::db_env_lock_detect $DB_ENV, 0, BDB::LOCK_DEFAULT, 0, sub { };
-      },
-   );
-   $BDB_CHECKPOINT_WATCHER = Event->timer (
-      after     => 11,
-      interval  => 60,
-      hard      => 1,
-      prio      => 0,
-      data      => WF_AUTOCANCEL,
-      cb        => sub {
-         BDB::db_env_txn_checkpoint $DB_ENV, 0, 0, 0, sub { };
-      },
-   );
-   $BDB_TRICKLE_WATCHER = Event->timer (
-      after     => 5,
-      interval  => 10,
-      hard      => 1,
-      prio      => 0,
-      data      => WF_AUTOCANCEL,
-      cb        => sub {
-         BDB::db_env_memp_trickle $DB_ENV, 20, 0, sub { };
-      },
-   );
+   $BDB_DEADLOCK_WATCHER = EV::periodic 0, 3, 0, sub {
+      BDB::db_env_lock_detect $DB_ENV, 0, BDB::LOCK_DEFAULT, 0, sub { };
+   };
+   $BDB_CHECKPOINT_WATCHER = EV::periodic 0, 60, 0, sub {
+      BDB::db_env_txn_checkpoint $DB_ENV, 0, 0, 0, sub { };
+   };
+   $BDB_TRICKLE_WATCHER = EV::periodic 0, 10, 0, sub {
+      BDB::db_env_memp_trickle $DB_ENV, 20, 0, sub { };
+   };
 }
 
 {
-   IO::AIO::min_parallel 8;
+   # configure IO::AIO
 
-   undef $Coro::AIO::WATCHER;
+   IO::AIO::min_parallel 8;
    IO::AIO::max_poll_time $TICK * 0.1;
-   $AIO_POLL_WATCHER = Event->io (
-      reentrant => 0,
-      data      => WF_AUTOCANCEL,
-      fd        => IO::AIO::poll_fileno,
-      poll      => 'r',
-      prio      => 0,
-      cb        => \&IO::AIO::poll_cb,
-   );
+   $Coro::AIO::WATCHER->priority (1);
 }
 
 my $_log_backtrace;