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

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.407 by root, Sun Jan 13 09:53:53 2008 UTC vs.
Revision 1.419 by root, Sun Apr 13 01:34:09 2008 UTC

+#
+# 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;
 use strict;
 use Symbol;
 use List::Util;
 use Socket;
-use EV 1.86;
+use EV 3.2;
 use Opcode;
 use Safe;
 use Safe::Hole;
 use Storable ();
-use Coro 4.32 ();
+use Coro 4.50 ();
 use Coro::State;
 use Coro::Handle;
 use Coro::EV;
 use Coro::Timer;
 use Coro::Signal;
 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;
 use Digest::MD5 ();
 # configure various modules to our taste
 #
 $Storable::canonical = 1; # reduce rsync transfers
 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
-# 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
 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 $USE_FSYNC = 1; # use fsync to write maps - default off
 # used to convert map paths into valid unix filenames by replacing / by ∕
 our $PATH_SEP = "∕"; # U+2215, chosen purely for visual reasons
 our $LOAD;       # a number between 0 (idle) and 1 (too many objects)
 our $LOADAVG;    # same thing, but with alpha-smoothing
+our $JITTER;     # average jitter
-our $tick_start; # for load detecting purposes
+our $TICK_START; # for load detecting purposes
 binmode STDOUT;
 binmode STDERR;
 # read virtual server time, if available
       LOG llevError, $msg;
    };
 }
 $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;
+   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';
 @safe::cf::client::ISA         = @cf::client::ISA         = 'cf::attachable';
    ! ! $LOCK{$key}
 }
 sub freeze_mainloop {
-   return unless $TICK_WATCHER->is_active;
+   tick_inhibit_inc;
-   my $guard = Coro::guard {
+   Coro::guard \&tick_inhibit_dec;
-      $TICK_WATCHER->start;
-   };
-   $TICK_WATCHER->stop;
-   $guard
 }
 =item cf::periodic $interval, $cb
 Like EV::periodic, but randomly selects a starting point so that the actions
       # 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;
       my @res;
          } else {
             EV::loop EV::LOOP_ONESHOT;
          }
       }
-      $time = EV::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 {
       # we are in another coroutine, how wonderful, everything just works
       reset_signals;
       &$cb
    }, @args;
    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.
                my $msg = $@ ? "$v->{path}: $@\n"
                             : "$v->{base}: extension inactive.\n";
                if (exists $v->{meta}{mandatory}) {
                   warn $msg;
-                  warn "mandatory extension failed to load, exiting.\n";
+                  cf::cleanup "mandatory extension failed to load, exiting.";
-                  exit 1;
                }
                warn $msg;
             }
 our $MAX_RESET     = 3600;
 our $DEFAULT_RESET = 3000;
 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},
       $rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
       $rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
 # the temporary/swap location
 sub save_path {
    my ($self) = @_;
-   (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
+   (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/go;
    "$TMPDIR/$path.map"
 }
 # the unique path, undef == no special unique path
 sub uniq_path {
    my ($self) = @_;
-   (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
+   (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/go;
    "$UNIQUEDIR/$path"
 }
 # and all this just because we cannot iterate over
 # all maps in C++...
 sub unique_maps() {
    [
       map {
          utf8::decode $_;
-         /\.map$/
+         s/\.map$//; # TODO future compatibility hack
+         /\.pst$/ || !/^$PATH_SEP/o # TODO unique maps apparebntly lack the .map suffix :/
+            ? ()
-            ? normalise $_
+            : normalise $_
-            : ()
       } @{ aio_readdir $UNIQUEDIR or [] }
    ]
 }
-package cf;
 =back
 =head3 cf::object
 =cut
 =over 4
 =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
 sub inv_recursive_;
 sub inv_recursive_ {
    inv_recursive_ inv $_[0]
 }
 =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)
 returns the objetc referenced by refstring. may return undef when it cnanot find the object,
 even if the object actually exists. May block.
 sub reload_config {
    open my $fh, "<:utf8", "$CONFDIR/config"
       or return;
    local $/;
-   *CFG = YAML::Syck::Load <$fh>;
+   *CFG = YAML::Load <$fh>;
    $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
    $cf::map::MAX_RESET     = $CFG{map_max_reset}     if exists $CFG{map_max_reset};
    $cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
    reload_config;
    db_init;
    load_extensions;
-   $TICK_WATCHER->start;
    $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
+   evthread_start IO::AIO::poll_fileno;
    EV::loop;
 }
 #############################################################################
 # initialisation and cleanup
          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:
    # the fsync below can take a very very long time.
       and return;
    warn "runtime file written.\n";
    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;
       warn "end emergency map save\n";
       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";
 }
    warn "reloading...";
    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 "leaving sync_job";
       1
    } or do {
       warn $@;
-      warn "error while reloading, exiting.";
+      cf::cleanup "error while reloading, exiting.";
-      exit 1;
    };
    warn "reloaded";
 };
 sub reload_perl() {
    # doing reload synchronously and two reloads happen back-to-back,
    # coro crashes during coro_state_free->destroy here.
    $RELOAD_WATCHER ||= EV::timer 0, 0, sub {
+      do_reload_perl;
       undef $RELOAD_WATCHER;
-      do_reload_perl;
    };
 }
 register_command "reload" => sub {
    my ($who, $arg) = @_;
 our @WAIT_FOR_TICK;
 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;
    push @WAIT_FOR_TICK, $signal;
    $signal->wait;
 }
 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;
    push @WAIT_FOR_TICK_BEGIN, $signal;
    $signal->wait;
 }
-$TICK_WATCHER = EV::periodic_ns 0, $TICK, 0, sub {
+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 = $tick_start = EV::now;
    cf::server_tick; # one server iteration
-   $RUNTIME += $TICK;
-   $NEXT_TICK = $_[0]->at;
    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
+         write_runtime_sync
             or warn "ERROR: unable to write runtime file: $!";
       };
    }
    if (my $sig = shift @WAIT_FOR_TICK_BEGIN) {
    }
    while (my $sig = shift @WAIT_FOR_TICK) {
       $sig->send;
    }
-   $LOAD = ($NOW - $tick_start) / $TICK;
+   $LOAD = ($NOW - $TICK_START) / $TICK;
    $LOADAVG = $LOADAVG * 0.75 + $LOAD * 0.25;
-   _post_tick;
+   if (0) {
-};
+      if ($NEXT_TICK) {
-$TICK_WATCHER->priority (EV::MAXPRI);
+         my $jitter = $TICK_START - $NEXT_TICK;
+         $JITTER = $JITTER * 0.75 + $jitter * 0.25;
+         warn "jitter $JITTER\n";#d#
+      }
+   }
+}
 {
    # configure BDB
    BDB::min_parallel 8;

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.407 by root, Sun Jan 13 09:53:53 2008 UTC vs. Revision 1.419 by root, Sun Apr 13 01:34:09 2008 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.407 by root, Sun Jan 13 09:53:53 2008 UTC vs.
Revision 1.419 by root, Sun Apr 13 01:34:09 2008 UTC