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

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.133 by root, Thu Jan 4 16:19:32 2007 UTC vs.
Revision 1.138 by root, Fri Jan 5 17:07:17 2007 UTC

 sub to_json($) {
    $JSON::Syck::ImplicitUnicode = 0;  # work around JSON::Syck bugs
    JSON::Syck::Dump $_[0]
 }
-=item my $guard = cf::guard { BLOCK }
-Run the given callback when the guard object gets destroyed (useful for
-coroutine cancellations).
-You can call C<< ->cancel >> on the guard object to stop the block from
-being executed.
-=cut
-sub guard(&) {
-   bless \(my $cb = $_[0]), cf::guard::;
-}
-sub cf::guard::cancel {
-   ${$_[0]} = sub { };
-}
-sub cf::guard::DESTROY {
-   ${$_[0]}->();
-}
 =item cf::lock_wait $string
 Wait until the given lock is available. See cf::lock_acquire.
 =item my $lock = cf::lock_acquire $string
 Wait until the given lock is available and then acquires it and returns
-a guard object. If the guard object gets destroyed (goes out of scope,
+a Coro::guard object. If the guard object gets destroyed (goes out of scope,
 for example when the coroutine gets canceled), the lock is automatically
 returned.
 Lock names should begin with a unique identifier (for example, cf::map::find
 uses map_find and cf::map::load uses map_load).
    # wait, to be sure we are not locked
    lock_wait $key;
    $LOCK{$key} = [];
-   cf::guard {
+   Coro::guard {
       # wake up all waiters, to be on the safe side
       $_->ready for @{ delete $LOCK{$key} };
    }
 }
-=item cf::async { BLOCK }
-Like C<Coro::async>, but runs the given BLOCK in an eval and only logs the
-error instead of exiting the server in case of a problem.
-=cut
-sub async(&) {
-   my ($cb) = @_;
-   Coro::async {
-      eval { $cb->() };
-      warn $@ if $@;
-   }
-}
 sub freeze_mainloop {
    return unless $TICK_WATCHER->is_active;
-   my $guard = guard { $TICK_WATCHER->start };
+   my $guard = Coro::guard { $TICK_WATCHER->start };
    $TICK_WATCHER->stop;
    $guard
 }
 =item cf::sync_job { BLOCK }
       my $freeze_guard = freeze_mainloop;
       my $busy = 1;
       my @res;
-      (Coro::async {
+      (Coro::async_pool {
          @res = eval { $job->() };
          warn $@ if $@;
          undef $busy;
       })->prio (Coro::PRIO_MAX);
    }
 }
 =item $coro = cf::coro { BLOCK }
-Creates and returns a new coro. This coro is automcatially being canceled
+Creates (and readies) and returns a new coro. This coro is automcatially
-when the extension calling this is being unloaded.
+being canceled when the extension calling this is being unloaded.
 =cut
 sub coro(&) {
    my $cb = shift;
-   my $coro = &cf::async ($cb);
+   my $coro = &Coro::async_pool ($cb);
    $coro->on_destroy (sub {
       delete $EXT_CORO{$coro+0};
    });
    $EXT_CORO{$coro+0} = $coro;
       or return;
    my $map = cf::map::new
       or return;
+   # for better error messages only, will be overwritten
+   $map->path ($path);
    $map->load_header ($path)
      or return;
    $map->{load_path} = $path;
    $cf::MAP{$key} || do {
       my $guard = cf::lock_acquire "map_find:$key";
       # do it the slow way
       my $map = try_load_header $path->save_path;
+      Coro::cede;
       if ($map) {
          $map->last_access ((delete $map->{last_access})
                             || $cf::RUNTIME); #d#
          # safety
       $map->path ($key);
       $map->{path} = $path;
       $map->{last_save} = $cf::RUNTIME;
+      Coro::cede;
       if ($map->should_reset) {
          $map->reset;
          undef $guard;
          $map = find $path
             or return;
       if (aio_open $uniq, O_RDONLY, 0) {
          $self->clear_unique_items;
          $self->load_objects ($uniq, 0);
       }
    }
+   Coro::cede;
    # now do the right thing for maps
    $self->link_multipart_objects;
    if ($self->{path}->is_style_map) {
       $self->difficulty ($self->estimate_difficulty)
          unless $self->difficulty;
       $self->activate;
    }
+   Coro::cede;
    $self->in_memory (cf::MAP_IN_MEMORY);
 }
 sub find_sync {
    my ($path, $origin) = @_;
    cf::sync_job { $map->load };
 }
 sub save {
    my ($self) = @_;
+   my $lock = cf::lock_acquire "map_data:" . $self->path;
    $self->{last_save} = $cf::RUNTIME;
    return unless $self->dirty;
    my ($self) = @_;
    # save first because save cedes
    $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->{deny_save};
    $self->clear;
    $self->save;
 }
 sub reset {
    my ($self) = @_;
+   my $lock = cf::lock_acquire "map_data:" . $self->path;
    return if $self->players;
    return if $self->{path}{user_rel};#d#
    warn "resetting map ", $self->path;#d#
       # try to abort aborted map switching on player login :)
       # should happen only on crashes
       if ($pl->ob->{_link_pos}) {
          $pl->ob->enter_link;
-         cf::async {
+         Coro::async_pool {
             # we need this sleep as the login has a concurrent enter_exit running
             # and this sleep increases chances of the player not ending up in scorn
             Coro::Timer::sleep 1;
             $pl->ob->leave_link;
          };
       }
    },
 );
-=item $player_object->goto_map ($path, $x, $y)
+=item $player_object->goto ($path, $x, $y)
 =cut
-sub cf::object::player::goto_map {
+sub cf::object::player::goto {
    my ($self, $path, $x, $y) = @_;
    $self->enter_link;
-   (cf::async {
+   (Coro::async_pool {
       $path = new cf::path $path;
       my $map = cf::map::find $path->as_string;
       $map = $map->customise_for ($self) if $map;
    return unless $self->type == cf::PLAYER;
    $self->enter_link;
-   (cf::async {
+   (Coro::async_pool {
       $self->deactivate_recursive; # just to be sure
       unless (eval {
          prepare_random_map $exit
             if $exit->slaying eq "/!";
          my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
-         $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
+         $self->goto ($path, $exit->stats->hp, $exit->stats->sp);
          1;
       }) {
          $self->message ("Something went wrong deep within the crossfire server. "
                      . "I'll try to bring you back to the map you were before. "
 =cut
 sub cf::client::coro {
    my ($self, $cb) = @_;
-   my $coro = &cf::async ($cb);
+   my $coro = &Coro::async_pool ($cb);
    $coro->on_destroy (sub {
       delete $self->{_coro}{$coro+0};
    });

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.133 by root, Thu Jan 4 16:19:32 2007 UTC vs. Revision 1.138 by root, Fri Jan 5 17:07:17 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.133 by root, Thu Jan 4 16:19:32 2007 UTC vs.
Revision 1.138 by root, Fri Jan 5 17:07:17 2007 UTC