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

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.418 by root, Fri Apr 11 21:09:53 2008 UTC vs.
Revision 1.457 by root, Wed Oct 1 05:50:19 2008 UTC

 # The authors can be reached via e-mail to <support@deliantra.net>
 #
 package cf;
+use 5.10.0;
 use utf8;
-use strict;
+use strict "vars", "subs";
 use Symbol;
 use List::Util;
 use Socket;
-use EV 3.2;
+use EV;
 use Opcode;
 use Safe;
 use Safe::Hole;
 use Storable ();
-use Coro 4.50 ();
+use Coro ();
 use Coro::State;
 use Coro::Handle;
 use Coro::EV;
+use Coro::AnyEvent;
 use Coro::Timer;
 use Coro::Signal;
 use Coro::Semaphore;
+use Coro::AnyEvent;
 use Coro::AIO;
-use Coro::BDB;
+use Coro::BDB 1.6;
 use Coro::Storable;
 use Coro::Util ();
 use JSON::XS 2.01 ();
 use BDB ();
 use Data::Dumper;
 use Digest::MD5;
 use Fcntl;
 use YAML ();
-use IO::AIO 2.51 ();
+use IO::AIO ();
 use Time::HiRes;
 use Compress::LZF;
 use Digest::MD5 ();
+AnyEvent::detect;
 # 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
+$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
+# make sure c-lzf reinitialises itself
+Compress::LZF::set_serializer "Storable", "Storable::net_mstore", "Storable::mretrieve";
 Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
-$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 %COMMAND      = ();
 our %COMMAND_TIME = ();
 our %EXTCMD       = ();
 our %EXTICMD      = ();
 our %EXT_CORO     = (); # coroutines bound to extensions
 our %EXT_MAP      = (); # pluggable maps
-our $RELOAD; # number of reloads so far
+our $RELOAD; # number of reloads so far, non-zero while in reload
 our @EVENT;
-our $CONFDIR   = confdir;
+our $CONFDIR     = confdir;
-our $DATADIR   = datadir;
+our $DATADIR     = datadir;
-our $LIBDIR    = "$DATADIR/ext";
+our $LIBDIR      = "$DATADIR/ext";
-our $PODDIR    = "$DATADIR/pod";
+our $PODDIR      = "$DATADIR/pod";
-our $MAPDIR    = "$DATADIR/" . mapdir;
+our $MAPDIR      = "$DATADIR/" . mapdir;
-our $LOCALDIR  = localdir;
+our $LOCALDIR    = localdir;
-our $TMPDIR    = "$LOCALDIR/" . tmpdir;
+our $TMPDIR      = "$LOCALDIR/" . tmpdir;
-our $UNIQUEDIR = "$LOCALDIR/" . uniquedir;
+our $UNIQUEDIR   = "$LOCALDIR/" . uniquedir;
-our $PLAYERDIR = "$LOCALDIR/" . playerdir;
+our $PLAYERDIR   = "$LOCALDIR/" . playerdir;
-our $RANDOMDIR = "$LOCALDIR/random";
+our $RANDOMDIR   = "$LOCALDIR/random";
-our $BDBDIR    = "$LOCALDIR/db";
+our $BDBDIR      = "$LOCALDIR/db";
+our $PIDFILE     = "$LOCALDIR/pid";
+our $RUNTIMEFILE = "$LOCALDIR/runtime";
 our %RESOURCE;
 our $TICK = MAX_TIME * 1e-6; # this is a CONSTANT(!)
-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
-our $BDB_POLL_WATCHER;
 our $BDB_DEADLOCK_WATCHER;
 our $BDB_CHECKPOINT_WATCHER;
 our $BDB_TRICKLE_WATCHER;
 our $DB_ENV;
 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 @POST_INIT;
+our $REATTACH_ON_RELOAD; # ste to true to force object reattach on reload (slow)
 binmode STDOUT;
 binmode STDERR;
 # read virtual server time, if available
-unless ($RUNTIME || !-e "$LOCALDIR/runtime") {
+unless ($RUNTIME || !-e $RUNTIMEFILE) {
-   open my $fh, "<", "$LOCALDIR/runtime"
+   open my $fh, "<", $RUNTIMEFILE
-      or die "unable to read runtime file: $!";
+      or die "unable to read $RUNTIMEFILE file: $!";
    $RUNTIME = <$fh> + 0.;
 }
 mkdir $_
    for $LOCALDIR, $TMPDIR, $UNIQUEDIR, $PLAYERDIR, $RANDOMDIR, $BDBDIR;
 for my $pkg (qw(
    cf::global cf::attachable
    cf::object cf::object::player
    cf::client cf::player
    cf::arch cf::living
+   cf::map cf::mapspace
-   cf::map cf::party cf::region
+   cf::party cf::region
 )) {
-   no strict 'refs';
    @{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;
 }
 $EV::DIED = sub {
    warn "error in event callback: @_";
 our $json_coder = JSON::XS->new->utf8->max_size (1e6); # accept ~1mb max
 sub encode_json($) { $json_coder->encode ($_[0]) }
 sub decode_json($) { $json_coder->decode ($_[0]) }
+=item cf::post_init { BLOCK }
+Execute the given codeblock, I<after> all extensions have been (re-)loaded,
+but I<before> the server starts ticking again.
+The cdoeblock will have a single boolean argument to indicate whether this
+is a reload or not.
+=cut
+sub post_init(&) {
+   push @POST_INIT, shift;
+}
 =item cf::lock_wait $string
 Wait until the given lock is available. See cf::lock_acquire.
 =item my $lock = cf::lock_acquire $string
       return;#d#
    }#d#
    # wait for lock, if any
    while ($LOCK{$key}) {
+      #local $Coro::current->{desc} = "$Coro::current->{desc} <waiting for lock $key>";
       push @{ $LOCK{$key} }, $Coro::current;
       Coro::schedule;
    }
 }
       }
    }
 };
 sub get_slot($;$$) {
+   return if tick_inhibit || $Coro::current == $Coro::main;
    my ($time, $pri, $name) = @_;
    $time = $TICK * .6 if $time > $TICK * .6;
    my $sig = new Coro::Signal;
 #############################################################################
 =head2 ATTACHABLE OBJECTS
-Many objects in crossfire are so-called attachable objects. That means you can
+Many objects in deliantra are so-called attachable objects. That means you can
 attach callbacks/event handlers (a collection of which is called an "attachment")
 to it. All such attachable objects support the following methods.
 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
 =item cf::CLASS::attachment $name, ...
 Register an attachment by C<$name> through which attachable objects of the
 given CLASS can refer to this attachment.
-Some classes such as crossfire maps and objects can specify attachments
+Some classes such as deliantra maps and objects can specify attachments
 that are attached at load/instantiate time, thus the need for a name.
 These calls expect any number of the following handler/hook descriptions:
 =over 4
 sub reattach {
    # basically do the same as instantiate, without calling instantiate
    my ($obj) = @_;
+   # no longer needed after getting rid of delete_package?
-   bless $obj, ref $obj; # re-bless in case extensions have been reloaded
+   #bless $obj, ref $obj; # re-bless in case extensions have been reloaded
    my $registry = $obj->registry;
    @$registry = ();
          utf8::decode (my $decname = $filename);
          warn sprintf "saving %s (%d,%d)\n",
             $decname, length $$rdata, scalar @$objs;
          if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {
-            chmod SAVE_MODE, $fh;
+            aio_chmod $fh, SAVE_MODE;
             aio_write $fh, 0, (length $$rdata), $$rdata, 0;
             aio_fsync $fh if $cf::USE_FSYNC;
-            close $fh;
+            aio_close $fh;
             if (@$objs) {
                if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
-                  chmod SAVE_MODE, $fh;
+                  aio_chmod $fh, SAVE_MODE;
                   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;
+                  aio_close $fh;
                   aio_rename "$filename.pst~", "$filename.pst";
                }
             } else {
                aio_unlink "$filename.pst";
             }
             aio_rename "$filename~", $filename;
+            $filename =~ s%/[^/]+$%%;
+            aio_pathsync $filename if $cf::USE_FSYNC;
          } else {
             warn "FATAL: $filename~: $!\n";
          }
       } else {
          aio_unlink $filename;
    my ($name, $cb) = @_;
    $EXTICMD{$name} = $cb;
 }
+use File::Glob ();
 cf::player->attach (
    on_command => sub {
       my ($pl, $name, $params) = @_;
       my $cb = $COMMAND{$name}
       cf::override;
    },
 );
+# "readahead" all extensions
+sub cache_extensions {
+   my $grp = IO::AIO::aio_group;
+   add $grp IO::AIO::aio_readdir $LIBDIR, sub {
+      for (grep /\.ext$/, @{$_[0]}) {
+         add $grp IO::AIO::aio_load "$LIBDIR/$_", my $data;
+      }
+   };
+   $grp
+}
 sub load_extensions {
    cf::sync_job {
       my %todo;
       for my $path (<$LIBDIR/*.ext>) {
          $ext{meta} = { map { (split /=/, $_, 2)[0, 1] } split /\s+/, $1 }
             if $source =~ /\A#!.*?perl.*?#\s*(.*)$/m;
          $ext{source} =
-            "package $pkg; use strict; use utf8;\n"
+            "package $pkg; use 5.10.0; use strict 'vars', 'subs'; use utf8;\n"
             . "#line 1 \"$path\"\n{\n"
             . $source
             . "\n};\n1";
          $todo{$base} = \%ext;
 =back
 =head2 CORE EXTENSIONS
-Functions and methods that extend core crossfire objects.
+Functions and methods that extend core deliantra objects.
 =cut
 package cf::player;
 sub exists($) {
    my ($login) = @_;
    $cf::PLAYER{$login}
-      or cf::sync_job { !aio_stat path $login }
+      or !aio_stat path $login
 }
 sub find($) {
    return $cf::PLAYER{$_[0]} || do {
       my $login = $_[0];
          my $f = new_from_file cf::object::thawer path $login
             or return;
          my $pl = cf::player::load_pl $f
             or return;
          local $cf::PLAYER_LOADING{$login} = $pl;
          $f->resolve_delayed_derefs;
          $cf::PLAYER{$login} = $pl
       }
    }
    return if $pl->{deny_save};
    aio_mkdir playerdir $pl, 0770;
    $pl->{last_save} = $cf::RUNTIME;
+   cf::get_slot 0.01;
    $pl->save_pl ($path);
    cf::cede_to_tick;
 }
    my ($pl) = @_;
    my $name = $pl->ob->name;
    $pl->{deny_save} = 1;
-   $pl->password ("*"); # this should lock out the player until we nuked the dir
+   $pl->password ("*"); # this should lock out the player until we have nuked the dir
    $pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active;
    $pl->deactivate;
+   my $killer = cf::arch::get "killer_quit"; $pl->killer ($killer); $killer->destroy;
+   $pl->ob->check_score;
    $pl->invoke (cf::EVENT_PLAYER_QUIT);
    $pl->ns->destroy if $pl->ns;
    my $path = playerdir $pl;
    my $temp = "$path~$cf::RUNTIME~deleting~";
    for my $login (@$dirs) {
       my $path = path $login;
       # a .pst is a dead give-away for a valid player
-      unless (-e "$path.pst") {
+      # if no pst file found, open and chekc for blocked users
+      if (aio_stat "$path.pst") {
          my $fh = aio_open $path, Fcntl::O_RDONLY, 0 or next;
          aio_read $fh, 0, 512, my $buf, 0            or next;
          $buf !~ /^password -------------$/m         or next; # official not-valid tag
       }
    }
    \@paths
 }
-=item $protocol_xml = $player->expand_cfpod ($crossfire_pod)
+=item $protocol_xml = $player->expand_cfpod ($cfpod)
-Expand crossfire pod fragments into protocol xml.
+Expand deliantra pod fragments into protocol xml.
-=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, $pod) = @_;
-   my $xml;
-   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}
-}
 =item $player->ext_reply ($msgid, @msg)
 Sends an ext reply to the player.
 # 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++...
    cf::lock_wait "map_data:$path";#d#remove
    cf::lock_wait "map_find:$path";
    $cf::MAP{$path} || do {
-      my $guard1 = cf::lock_acquire "map_find:$path";
-      my $guard2 = cf::lock_acquire "map_data:$path"; # just for the fun of it
+      my $guard1 = cf::lock_acquire "map_data:$path"; # just for the fun of it
+      my $guard2 = cf::lock_acquire "map_find:$path";
       my $map = new_from_path cf::map $path
          or return;
       $map->{last_save} = $cf::RUNTIME;
          or return;
       if ($map->should_reset) {#d#TODO# disabled, crashy (locking issue?)
          # doing this can freeze the server in a sync job, obviously
          #$cf::WAIT_FOR_TICK->wait;
+         undef $guard2;
          undef $guard1;
-         undef $guard2;
          $map->reset;
          return find $path;
       }
       $cf::MAP{$path} = $map
       my $f = new_from_file cf::object::thawer $self->{load_path};
       $f->skip_block;
       $self->_load_objects ($f)
          or return;
-      $self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
+      $self->post_load_original
          if delete $self->{load_original};
       if (my $uniq = $self->uniq_path) {
          utf8::encode $uniq;
          unless (aio_stat $uniq) {
       }
       $self->{last_save} = $cf::RUNTIME;
       $self->last_access ($cf::RUNTIME);
-      $self->in_memory (cf::MAP_IN_MEMORY);
+      $self->in_memory (cf::MAP_ACTIVE);
    }
    $self->post_load;
 }
    my ($path, $origin, $load) = @_;
    $path = normalise $path, $origin && $origin->{path};
    if (my $map = $cf::MAP{$path}) {
-      return $map if !$load || $map->in_memory == cf::MAP_IN_MEMORY;
+      return $map if !$load || $map->in_memory == cf::MAP_ACTIVE;
    }
    $MAP_PREFETCH{$path} |= $load;
    $MAP_PREFETCHER ||= cf::async {
    cf::async {
       $Coro::current->{desc} = "map player save";
       $_->contr->save for $self->players;
    };
+   cf::get_slot 0.02;
    if ($uniq) {
       $self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
       $self->_save_objects ($uniq, cf::IO_UNIQUES);
    } else {
       $self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
    $self->save;
    my $lock = cf::lock_acquire "map_data:$self->{path}";
    return if $self->players;
-   return if $self->in_memory != cf::MAP_IN_MEMORY;
+   return if $self->in_memory != cf::MAP_ACTIVE;
    return if $self->{deny_save};
    $self->in_memory (cf::MAP_SWAPPED);
    $self->deactivate;
 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 [] }
    ]
 }
 =back
 =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.
 can be C<undef>. Does the right thing when the player is currently in a
 dialogue with the given NPC character.
 =cut
+our $SAY_CHANNEL = {
+   id      => "say",
+   title   => "Map",
+   reply   => "say ",
+   tooltip => "Things said to and replied from npcs near you and other players on the same map only.",
+};
+our $CHAT_CHANNEL = {
+   id      => "chat",
+   title   => "Chat",
+   reply   => "chat ",
+   tooltip => "Player chat and shouts, global to the server.",
+};
 # rough implementation of a future "reply" method that works
 # with dialog boxes.
 #TODO: the first argument must go, split into a $npc->reply_to ( method
 sub cf::object::player::reply($$$;$) {
    my ($self, $npc, $msg, $flags) = @_;
          my $dialog = $pl->{npc_dialog};
          $dialog->{pl}->ext_msg ($dialog->{id}, update => msg => $dialog->{pl}->expand_cfpod ($msg));
       } else {
          $msg = $npc->name . " says: $msg" if $npc;
-         $self->message ($msg, $flags);
+         $self->send_msg ($SAY_CHANNEL => $msg, $flags);
       }
    }
 }
 =item $object->send_msg ($channel, $msg, $color, [extra...])
 =item $player_object->enter_link
 Freezes the player and moves him/her to a special map (C<{link}>).
-The player should be reasonably safe there for short amounts of time. You
+The player should be reasonably safe there for short amounts of time (e.g.
-I<MUST> call C<leave_link> as soon as possible, though.
+for loading a map). You I<MUST> call C<leave_link> as soon as possible,
+though, as the palyer cannot control the character while it is on the link
+map.
 Will never block.
 =item $player_object->leave_link ($map, $x, $y)
    $map->load;
    $map->load_neighbours;
    return unless $self->contr->active;
+   $self->flag (cf::FLAG_DEBUG, 0);#d# temp
    $self->activate_recursive;
    local $self->{_prev_pos} = $link_pos; # ugly hack for rent.ext
    $self->enter_map ($map, $x, $y);
 }
 Moves the player to the given map-path and coordinates by first freezing
 her, loading and preparing them map, calling the provided $check callback
 that has to return the map if sucecssful, and then unfreezes the player on
 the new (success) or old (failed) map position. In either case, $done will
 be called at the end of this process.
+Note that $check will be called with a potentially non-loaded map, so if
+it needs a loaded map it has to call C<< ->load >>.
 =cut
 our $GOTOGEN;
 }
 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
    my $rmp = parse_random_map_params $exit->msg;
    if ($exit->map) {
       $rmp->{region}     = $exit->region->name;
       $rmp->{origin_map} = $exit->map->path;
       $rmp->{origin_x}   = $exit->x;
       $rmp->{origin_y}   = $exit->y;
+      $exit->map->touch;
    }
    $rmp->{random_seed} ||= $exit->random_seed;
-   my $data = cf::encode_json $rmp;
+   my $data = JSON::XS->new->utf8->pretty->canonical->encode ($rmp);
    my $md5 = Digest::MD5::md5_hex $data;
    my $meta = "$RANDOMDIR/$md5.meta";
    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;
+      my $slaying = "?random/$md5";
+      if ($exit->valid) {
-      $exit->slaying ("?random/$md5");
+         $exit->slaying ("?random/$md5");
-      $exit->msg (undef);
+         $exit->msg (undef);
+      }
    }
 }
 sub cf::object::player::enter_exit {
    my ($self, $exit) = @_;
    return unless $self->type == cf::PLAYER;
-   if ($exit->slaying eq "/!") {
-      #TODO: this should de-fi-ni-te-ly not be a sync-job
-      # the problem is that $exit might not survive long enough
-      # so it needs to be done right now, right here
-      cf::sync_job { prepare_random_map $exit };
-   }
-   my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
-   my $hp      = $exit->stats->hp;
-   my $sp      = $exit->stats->sp;
    $self->enter_link;
-   # if exit is damned, update players death & WoR home-position
-   $self->contr->savebed ($slaying, $hp, $sp)
-      if $exit->flag (FLAG_DAMNED);
    (async {
-      $Coro::current->{desc} = "enter_exit $slaying $hp $sp";
+      $Coro::current->{desc} = "enter_exit";
-      $self->deactivate_recursive; # just to be sure
       unless (eval {
+         $self->deactivate_recursive; # just to be sure
+         # random map handling
+         {
+            my $guard = cf::lock_acquire "exit_prepare:$exit";
+            prepare_random_map $exit
+               if $exit->slaying eq "/!";
+         }
+         my $map = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
+         my $x   = $exit->stats->hp;
+         my $y   = $exit->stats->sp;
-         $self->goto ($slaying, $hp, $sp);
+         $self->goto ($map, $x, $y);
+         # if exit is damned, update players death & WoR home-position
+         $self->contr->savebed ($map, $x, $y)
+            if $exit->flag (cf::FLAG_DAMNED);
-         1;
+         1
       }) {
-         $self->message ("Something went wrong deep within the crossfire server. "
+         $self->message ("Something went wrong deep within the deliantra server. "
                        . "I'll try to bring you back to the map you were before. "
                        . "Please report this to the dungeon master!",
                          cf::NDI_UNIQUE | cf::NDI_RED);
          warn "ERROR in enter_exit: $@";
       id      => "infobox",
       title   => "Body Parts",
       reply   => undef,
       tooltip => "Shows which body parts you posess and are available",
    },
+   "c/skills" => {
+      id      => "infobox",
+      title   => "Skills",
+      reply   => undef,
+      tooltip => "Shows your experience per skill and item power",
+   },
    "c/uptime" => {
       id      => "infobox",
       title   => "Uptime",
       reply   => undef,
       tooltip => "How long the server has been running since last restart",
       id      => "infobox",
       title   => "Map Info",
       reply   => undef,
       tooltip => "Information related to the maps",
    },
+   "c/party" => {
+      id      => "party",
+      title   => "Party",
+      reply   => "gsay ",
+      tooltip => "Messages and chat related to your party",
+   },
 );
 sub cf::client::send_msg {
    my ($self, $channel, $msg, $color, @extra) = @_;
-   $msg = $self->pl->expand_cfpod ($msg);
+   $msg = $self->pl->expand_cfpod ($msg)
+      unless $color & cf::NDI_VERBATIM;
    $color &= cf::NDI_CLIENT_MASK; # just in case...
    # check predefined channels, for the benefit of C
    if ($CHANNEL{$channel}) {
    if ($self->can_msg) {
       # default colour, mask it out
       $color &= ~(cf::NDI_COLOR_MASK | cf::NDI_DEF)
          if $color & cf::NDI_DEF;
-      $self->send_packet ("msg " . $self->{json_coder}->encode (
+      my $pkt = "msg "
+                . $self->{json_coder}->encode (
-         [$color & cf::NDI_CLIENT_MASK, $channel, $msg, @extra]));
+                   [$color & cf::NDI_CLIENT_MASK, $channel, $msg, @extra]
+                );
+      # try lzf for large packets
+      $pkt = "lzf " . Compress::LZF::compress $pkt
+         if 1024 <= length $pkt and $self->{can_lzf};
+      # split very large packets
+      if (8192 < length $pkt and $self->{can_lzf}) {
+         $self->send_packet ("frag $_") for unpack "(a8192)*", $pkt;
+         $pkt = "frag";
+      }
+      $self->send_packet ($pkt);
    } else {
       if ($color >= 0) {
          # replace some tags by gcfclient-compatible ones
          for ($msg) {
             1 while
 The following functions and methods are available within a safe environment:
   cf::object
      contr pay_amount pay_player map x y force_find force_add destroy
-     insert remove name archname title slaying race decrease_ob_nr
+     insert remove name archname title slaying race decrease split
   cf::object::player
      player
   cf::player
 =cut
 for (
    ["cf::object"         => qw(contr pay_amount pay_player map force_find force_add x y
-                               insert remove inv name archname title slaying race
+                               insert remove inv nrof name archname title slaying race
-                               decrease_ob_nr destroy)],
+                               decrease split destroy change_exp)],
    ["cf::object::player" => qw(player)],
    ["cf::player"         => qw(peaceful)],
    ["cf::map"            => qw(trigger)],
 ) {
    no strict 'refs';
    while (my ($k, $v) = each %$want) {
       $ns->fx_want ($k, $v);
    }
 };
+sub load_resource_file($) {
+   my $guard = lock_acquire "load_resource_file";
+   my $status = load_resource_file_ $_[0];
+   get_slot 0.1, 100;
+   cf::arch::commit_load;
+   $status
+}
 sub reload_regions {
    # HACK to clear player env face cache, we need some signal framework
    # for this (global event?)
    %ext::player_env::MUSIC_FACE_CACHE = ();
 }
 sub reload_archetypes {
    load_resource_file "$DATADIR/archetypes"
       or die "unable to load archetypes\n";
-   #d# NEED to laod twice to resolve forward references
-   # this really needs to be done in an extra post-pass
-   # (which needs to be synchronous, so solve it differently)
-   load_resource_file "$DATADIR/archetypes"
-      or die "unable to load archetypes\n";
 }
 sub reload_treasures {
    load_resource_file "$DATADIR/treasures"
       or die "unable to load treasurelists\n";
 }
 sub reload_resources {
    warn "reloading resource files...\n";
+   reload_facedata;
+   reload_archetypes;
    reload_regions;
-   reload_facedata;
-   #reload_archetypes;#d#
-   reload_archetypes;
    reload_treasures;
    warn "finished reloading resource files\n";
-}
-sub init {
-   reload_resources;
 }
 sub reload_config {
    open my $fh, "<:utf8", "$CONFDIR/config"
       or return;
       };
       warn $@ if $@;
    }
 }
+sub pidfile() {
+   sysopen my $fh, $PIDFILE, O_RDWR | O_CREAT
+      or die "$PIDFILE: $!";
+   flock $fh, &Fcntl::LOCK_EX
+      or die "$PIDFILE: flock: $!";
+   $fh
+}
+# make sure only one server instance is running at any one time
+sub atomic {
+   my $fh = pidfile;
+   my $pid = <$fh>;
+   kill 9, $pid if $pid > 0;
+   seek $fh, 0, 0;
+   print $fh $$;
+}
 sub main {
+   cf::init_globals; # initialise logging
+   LOG llevInfo, "Welcome to Deliantra, v" . VERSION;
+   LOG llevInfo, "Copyright (C) 2005-2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team.";
+   LOG llevInfo, "Copyright (C) 1994 Mark Wedel.";
+   LOG llevInfo, "Copyright (C) 1992 Frank Tore Johansen.";
+   cf::init_experience;
+   cf::init_anim;
+   cf::init_attackmess;
+   cf::init_dynamic;
+   cf::init_block;
+   $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
    # 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 {
          $Coro::current->{desc} = "IDLE BUG HANDLER";
          EV::loop EV::LOOP_ONESHOT;
       })->prio (Coro::PRIO_MAX);
    };
-   reload_config;
-   db_init;
-   load_extensions;
-   $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
    evthread_start IO::AIO::poll_fileno;
+   cf::sync_job {
+      reload_resources;
+      reload_config;
+      db_init;
+      cf::load_settings;
+      cf::load_materials;
+      cf::init_uuid;
+      cf::init_signals;
+      cf::init_commands;
+      cf::init_skills;
+      cf::init_beforeplay;
+      atomic;
+      load_extensions;
+      utime time, time, $RUNTIMEFILE;
+      # no (long-running) fork's whatsoever before this point(!)
+      POSIX::close delete $ENV{LOCKUTIL_LOCK_FD} if exists $ENV{LOCKUTIL_LOCK_FD};
+      (pop @POST_INIT)->(0) while @POST_INIT;
+   };
    EV::loop;
 }
 #############################################################################
 # initialisation and cleanup
       };
    }
 }
 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.
-   IO::AIO::aio_utime $runtime, undef, undef;
+   IO::AIO::aio_utime $RUNTIMEFILE, undef, undef;
    my $guard = cf::lock_acquire "write_runtime";
-   my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
+   my $fh = aio_open "$RUNTIMEFILE~", O_WRONLY | O_CREAT, 0644
       or return;
    my $value = $cf::RUNTIME + 90 + 10;
    # 10 is the runtime save interval, for a monotonic clock
    # 60 allows for the watchdog to kill the server.
    aio_utime $fh, undef, undef;
    close $fh
       or return;
-   aio_rename "$runtime~", $runtime
+   aio_rename "$RUNTIMEFILE~", $RUNTIMEFILE
       and return;
    warn "runtime file written.\n";
    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;
+   my $value = uuid_seq uuid_cur;
+   unless ($value) {
+      warn "cowardly refusing to write zero uuid value!\n";
+      return;
+   }
+   my $value = uuid_str $value + $uuid_skip;
    $uuid_skip = 0;
    (aio_write $fh, 0, (length $value), $value, 0) <= 0
       and return;
 }
 sub emergency_save() {
    my $freeze_guard = cf::freeze_mainloop;
-   warn "enter emergency perl save\n";
+   warn "emergency_perl_save: enter\n";
    cf::sync_job {
+      # this is a trade-off: we want to be very quick here, so
+      # save all maps without fsync, and later call a global sync
+      # (which in turn might be very very slow)
+      local $USE_FSYNC = 0;
       # use a peculiar iteration method to avoid tripping on perl
       # refcount bugs in for. also avoids problems with players
       # and maps saved/destroyed asynchronously.
-      warn "begin emergency player save\n";
+      warn "emergency_perl_save: begin player save\n";
       for my $login (keys %cf::PLAYER) {
          my $pl = $cf::PLAYER{$login} or next;
          $pl->valid or next;
          delete $pl->{unclean_save}; # not strictly necessary, but cannot hurt
          $pl->save;
       }
-      warn "end emergency player save\n";
+      warn "emergency_perl_save: end player save\n";
-      warn "begin emergency map save\n";
+      warn "emergency_perl_save: begin map save\n";
       for my $path (keys %cf::MAP) {
          my $map = $cf::MAP{$path} or next;
          $map->valid or next;
          $map->save;
       }
-      warn "end emergency map save\n";
+      warn "emergency_perl_save: end map save\n";
-      warn "begin emergency database checkpoint\n";
+      warn "emergency_perl_save: begin database checkpoint\n";
       BDB::db_env_txn_checkpoint $DB_ENV;
-      warn "end emergency database checkpoint\n";
+      warn "emergency_perl_save: end database checkpoint\n";
-      warn "begin write uuid\n";
+      warn "emergency_perl_save: begin write uuid\n";
       write_uuid_sync 1;
-      warn "end write uuid\n";
+      warn "emergency_perl_save: end write uuid\n";
    };
+   warn "emergency_perl_save: starting sync()\n";
+   IO::AIO::aio_sync sub {
+      warn "emergency_perl_save: finished sync()\n";
+   };
-   warn "leave emergency perl save\n";
+   warn "emergency_perl_save: leave\n";
 }
 sub post_cleanup {
    my ($make_core) = @_;
    warn Carp::longmess "post_cleanup backtrace"
       if $make_core;
+   my $fh = pidfile;
+   unlink $PIDFILE if <$fh> == $$;
+}
+# a safer delete_package, copied from Symbol
+sub clear_package($) {
+   my $pkg = shift;
+   # expand to full symbol table name if needed
+   unless ($pkg =~ /^main::.*::$/) {
+      $pkg = "main$pkg"       if      $pkg =~ /^::/;
+      $pkg = "main::$pkg"     unless  $pkg =~ /^main::/;
+      $pkg .= '::'            unless  $pkg =~ /::$/;
+   }
+   my($stem, $leaf) = $pkg =~ m/(.*::)(\w+::)$/;
+   my $stem_symtab = *{$stem}{HASH};
+   defined $stem_symtab and exists $stem_symtab->{$leaf}
+      or return;
+   # clear all symbols
+   my $leaf_symtab = *{$stem_symtab->{$leaf}}{HASH};
+   for my $name (keys %$leaf_symtab) {
+      _gv_clear *{"$pkg$name"};
+#      use PApp::Util; PApp::Util::sv_dump *{"$pkg$name"};
+   }
+   warn "cleared package $pkg\n";#d#
 }
 sub do_reload_perl() {
    # can/must only be called in main
    if ($Coro::current != $Coro::main) {
       warn "can only reload from main coroutine";
       return;
    }
+   return if $RELOAD++;
+   my $t1 = EV::time;
+   while ($RELOAD) {
-   warn "reloading...";
+      warn "reloading...";
-   warn "entering sync_job";
+      warn "entering sync_job";
-   cf::sync_job {
+      cf::sync_job {
-      cf::write_runtime_sync; # external watchdog should not bark
+         cf::write_runtime_sync; # external watchdog should not bark
-      cf::emergency_save;
+         cf::emergency_save;
-      cf::write_runtime_sync; # external watchdog should not bark
+         cf::write_runtime_sync; # external watchdog should not bark
-      warn "syncing database to disk";
+         warn "syncing database to disk";
-      BDB::db_env_txn_checkpoint $DB_ENV;
+         BDB::db_env_txn_checkpoint $DB_ENV;
-      # if anything goes wrong in here, we should simply crash as we already saved
+         # if anything goes wrong in here, we should simply crash as we already saved
-      warn "flushing outstanding aio requests";
+         warn "flushing outstanding aio requests";
-      for (;;) {
-         BDB::flush;
-         IO::AIO::flush;
-         Coro::cede_notself;
-         last unless IO::AIO::nreqs || BDB::nreqs;
+         while (IO::AIO::nreqs || BDB::nreqs) {
-         warn "iterate...";
+            Coro::EV::timer_once 0.01; # let the sync_job do it's thing
-      }
-      ++$RELOAD;
-      warn "cancelling all extension coros";
-      $_->cancel for values %EXT_CORO;
-      %EXT_CORO = ();
-      warn "removing commands";
-      %COMMAND = ();
-      warn "removing ext/exti commands";
-      %EXTCMD  = ();
-      %EXTICMD = ();
-      warn "unloading/nuking all extensions";
-      for my $pkg (@EXTS) {
-         warn "... unloading $pkg";
-         if (my $cb = $pkg->can ("unload")) {
-            eval {
-               $cb->($pkg);
-               1
-            } or warn "$pkg unloaded, but with errors: $@";
          }
-         warn "... nuking $pkg";
+         warn "cancelling all extension coros";
-         Symbol::delete_package $pkg;
+         $_->cancel for values %EXT_CORO;
-      }
+         %EXT_CORO = ();
-      warn "unloading all perl modules loaded from $LIBDIR";
+         warn "removing commands";
-      while (my ($k, $v) = each %INC) {
+         %COMMAND = ();
-         next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
+         warn "removing ext/exti commands";
+         %EXTCMD  = ();
+         %EXTICMD = ();
+         warn "unloading/nuking all extensions";
+         for my $pkg (@EXTS) {
-         warn "... unloading $k";
+            warn "... unloading $pkg";
-         delete $INC{$k};
-         $k =~ s/\.pm$//;
-         $k =~ s/\//::/g;
-         if (my $cb = $k->can ("unload_module")) {
+            if (my $cb = $pkg->can ("unload")) {
+               eval {
-            $cb->();
+                  $cb->($pkg);
+                  1
+               } or warn "$pkg unloaded, but with errors: $@";
+            }
+            warn "... clearing $pkg";
+            clear_package $pkg;
          }
-         Symbol::delete_package $k;
+         warn "unloading all perl modules loaded from $LIBDIR";
+         while (my ($k, $v) = each %INC) {
+            next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
+            warn "... unloading $k";
+            delete $INC{$k};
+            $k =~ s/\.pm$//;
+            $k =~ s/\//::/g;
+            if (my $cb = $k->can ("unload_module")) {
+               $cb->();
+            }
+            clear_package $k;
-      }
+         }
-      warn "getting rid of safe::, as good as possible";
+         warn "getting rid of safe::, as good as possible";
-      Symbol::delete_package "safe::$_"
+         clear_package "safe::$_"
-         for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
+            for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
-      warn "unloading cf.pm \"a bit\"";
+         warn "unloading cf.pm \"a bit\"";
-      delete $INC{"cf.pm"};
+         delete $INC{"cf.pm"};
-      delete $INC{"cf/pod.pm"};
+         delete $INC{"cf/pod.pm"};
-      # don't, removes xs symbols, too,
+         # don't, removes xs symbols, too,
-      # and global variables created in xs
+         # and global variables created in xs
-      #Symbol::delete_package __PACKAGE__;
+         #clear_package __PACKAGE__;
-      warn "unload completed, starting to reload now";
+         warn "unload completed, starting to reload now";
-      warn "reloading cf.pm";
+         warn "reloading cf.pm";
-      require cf;
+         require cf;
-      cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
+         cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
-      warn "loading config and database again";
+         warn "loading config and database again";
-      cf::reload_config;
+         cf::reload_config;
-      warn "loading extensions";
+         warn "loading extensions";
-      cf::load_extensions;
+         cf::load_extensions;
+         if ($REATTACH_ON_RELOAD) {
-      warn "reattaching attachments to objects/players";
+            warn "reattaching attachments to objects/players";
-      _global_reattach; # objects, sockets
+            _global_reattach; # objects, sockets
-      warn "reattaching attachments to maps";
+            warn "reattaching attachments to maps";
-      reattach $_ for values %MAP;
+            reattach $_ for values %MAP;
-      warn "reattaching attachments to players";
+            warn "reattaching attachments to players";
-      reattach $_ for values %PLAYER;
+            reattach $_ for values %PLAYER;
+         }
+         warn "running post_init jobs";
+         (pop @POST_INIT)->(1) while @POST_INIT;
-      warn "leaving sync_job";
+         warn "leaving sync_job";
-      1
+         1
-   } or do {
+      } or do {
-      warn $@;
+         warn $@;
-      cf::cleanup "error while reloading, exiting.";
+         cf::cleanup "error while reloading, exiting.";
-   };
+      };
-   warn "reloaded";
+      warn "reloaded";
+      --$RELOAD;
+   }
+   $t1 = EV::time - $t1;
+   warn "reload completed in ${t1}s\n";
 };
 our $RELOAD_WATCHER; # used only during reload
 sub reload_perl() {
    # doing reload synchronously and two reloads happen back-to-back,
    # coro crashes during coro_state_free->destroy here.
+   $RELOAD_WATCHER ||= cf::async {
+      Coro::AIO::aio_wait cache_extensions;
-   $RELOAD_WATCHER ||= EV::timer 0, 0, sub {
+      $RELOAD_WATCHER = EV::timer $TICK * 1.5, 0, sub {
-      do_reload_perl;
+         do_reload_perl;
-      undef $RELOAD_WATCHER;
+         undef $RELOAD_WATCHER;
+      };
    };
 }
 register_command "reload" => sub {
    my ($who, $arg) = @_;
 our @WAIT_FOR_TICK;
 our @WAIT_FOR_TICK_BEGIN;
 sub wait_for_tick {
-   return if tick_inhibit;
-   return if $Coro::current == $Coro::main;
+   return if tick_inhibit || $Coro::current == $Coro::main;
    my $signal = new Coro::Signal;
    push @WAIT_FOR_TICK, $signal;
    $signal->wait;
 }
 sub wait_for_tick_begin {
-   return if tick_inhibit;
-   return if $Coro::current == $Coro::main;
+   return if tick_inhibit || $Coro::current == $Coro::main;
    my $signal = new Coro::Signal;
    push @WAIT_FOR_TICK_BEGIN, $signal;
    $signal->wait;
 }
 {
    # configure BDB
    BDB::min_parallel 8;
    BDB::max_poll_reqs $TICK * 0.1;
-   $Coro::BDB::WATCHER->priority (1);
+   $AnyEvent::BDB::WATCHER->priority (1);
    unless ($DB_ENV) {
       $DB_ENV = BDB::db_env_create;
-      $DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT | BDB::TXN_NOSYNC
+      $DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT);
-                          | BDB::LOG_AUTOREMOVE, 1);
+      $DB_ENV->set_flags      (&BDB::LOG_AUTOREMOVE ) if BDB::VERSION v0, v4.7;
+      $DB_ENV->log_set_config (&BDB::LOG_AUTO_REMOVE) if BDB::VERSION v4.7;
       $DB_ENV->set_timeout (30, BDB::SET_TXN_TIMEOUT);
       $DB_ENV->set_timeout (30, BDB::SET_LOCK_TIMEOUT);
       cf::sync_job {
          eval {
 {
    # configure IO::AIO
    IO::AIO::min_parallel 8;
    IO::AIO::max_poll_time $TICK * 0.1;
-   $Coro::AIO::WATCHER->priority (1);
+   undef $AnyEvent::AIO::WATCHER;
 }
 my $_log_backtrace;
 sub _log_backtrace {
    $msg =~ s/\n//;
    # limit the # of concurrent backtraces
    if ($_log_backtrace < 2) {
       ++$_log_backtrace;
+      my $perl_bt = Carp::longmess $msg;
       async {
          $Coro::current->{desc} = "abt $msg";
          my @bt = fork_call {
             @addr = map { sprintf "%x", $_ } @addr;
             }
             @funcs
          };
-         LOG llevInfo, "[ABT] $msg\n";
+         LOG llevInfo, "[ABT] $perl_bt\n";
+         LOG llevInfo, "[ABT] --- C backtrace follows ---\n";
          LOG llevInfo, "[ABT] $_\n" for @bt;
          --$_log_backtrace;
       };
    } else {
       LOG llevInfo, "[ABT] $msg\n";

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.418 by root, Fri Apr 11 21:09:53 2008 UTC vs. Revision 1.457 by root, Wed Oct 1 05:50:19 2008 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.418 by root, Fri Apr 11 21:09:53 2008 UTC vs.
Revision 1.457 by root, Wed Oct 1 05:50:19 2008 UTC