--- deliantra/server/lib/cf.pm 2007/01/01 13:31:47 1.112 +++ deliantra/server/lib/cf.pm 2007/01/05 01:06:28 1.136 @@ -10,7 +10,7 @@ use Safe; use Safe::Hole; -use Coro 3.3; +use Coro 3.3 (); use Coro::Event; use Coro::Timer; use Coro::Signal; @@ -51,7 +51,6 @@ our %MAP; # all maps our $LINK_MAP; # the special {link} map -our $FREEZE; our $RANDOM_MAPS = cf::localdir . "/random"; our %EXT_CORO; @@ -73,8 +72,7 @@ # a special map that is always available our $LINK_MAP; - -our $EMERGENCY_POSITION = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37]; +our $EMERGENCY_POSITION; ############################################################################# @@ -183,6 +181,72 @@ JSON::Syck::Dump $_[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 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). + +=cut + +our %LOCK; + +sub lock_wait($) { + my ($key) = @_; + + # wait for lock, if any + while ($LOCK{$key}) { + push @{ $LOCK{$key} }, $Coro::current; + Coro::schedule; + } +} + +sub lock_acquire($) { + my ($key) = @_; + + # wait, to be sure we are not locked + lock_wait $key; + + $LOCK{$key} = []; + + Coro::guard { + # wake up all waiters, to be on the safe side + $_->ready for @{ delete $LOCK{$key} }; + } +} + +=item cf::async { BLOCK } + +Like C, 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 = Coro::guard { $TICK_WATCHER->start }; + $TICK_WATCHER->stop; + $guard +} + =item cf::sync_job { BLOCK } The design of crossfire+ requires that the main coro ($Coro::main) is @@ -205,7 +269,7 @@ # TODO: use suspend/resume instead # (but this is cancel-safe) - local $FREEZE = 1; + my $freeze_guard = freeze_mainloop; my $busy = 1; my @res; @@ -239,12 +303,7 @@ sub coro(&) { my $cb = shift; - my $coro; $coro = async { - eval { - $cb->(); - }; - warn $@ if $@; - }; + my $coro = &cf::async ($cb); $coro->on_destroy (sub { delete $EXT_CORO{$coro+0}; @@ -291,7 +350,17 @@ my $self = bless { }, $class; - if ($path =~ s{^\?random/}{}) { + # {... are special paths that are not touched + # ?xxx/... are special absolute paths + # ?random/... random maps + # /! non-realised random map exit + # /... normal maps + # ~/... per-player maps without a specific player (DO NOT USE) + # ~user/... per-player map of a specific user + + if ($path =~ /^{/) { + # fine as it is + } elsif ($path =~ s{^\?random/}{}) { Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data; $self->{random} = cf::from_json $data; } else { @@ -806,9 +875,11 @@ unless (aio_stat "$filename.pst") { (aio_load "$filename.pst", $av) >= 0 or return; - $av = eval { (Storable::thaw <$av>)->{objs} }; + $av = eval { (Storable::thaw $av)->{objs} }; } + warn sprintf "loading %s (%d)\n", + $filename, length $data, scalar @{$av || []};#d# return ($data, $av); } @@ -1052,8 +1123,8 @@ use Fcntl; use Coro::AIO; -our $MAX_RESET = 7200; -our $DEFAULT_RESET = 3600; +our $MAX_RESET = 3600; +our $DEFAULT_RESET = 3000; sub generate_random_map { my ($path, $rmp) = @_; @@ -1079,7 +1150,8 @@ sub change_all_map_light { my ($change) = @_; - $_->change_map_light ($change) for values %cf::MAP; + $_->change_map_light ($change) + for grep $_->outdoor, values %cf::MAP; } sub try_load_header($) { @@ -1092,6 +1164,9 @@ my $map = cf::map::new or return; + # for better error messages only, will be overwritten + $map->path ($path); + $map->load_header ($path) or return; @@ -1100,19 +1175,28 @@ $map } -sub find_map { +sub find; +sub find { my ($path, $origin) = @_; - #warn "find_map<$path,$origin>\n";#d# + #warn "find<$path,$origin>\n";#d# $path = new cf::path $path, $origin && $origin->path; my $key = $path->as_string; + cf::lock_wait "map_find:$key"; + $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->{instantiate_time} = $cf::RUNTIME if $map->{instantiate_time} > $cf::RUNTIME; @@ -1127,6 +1211,7 @@ $map->{load_original} = 1; $map->{instantiate_time} = $cf::RUNTIME; + $map->last_access ($cf::RUNTIME); $map->instantiate; # per-player maps become, after loading, normal maps @@ -1135,11 +1220,15 @@ $map->path ($key); $map->{path} = $path; - $map->last_access ($cf::RUNTIME); + $map->{last_save} = $cf::RUNTIME; + + Coro::cede; if ($map->should_reset) { $map->reset; - $map = find_map $path; + undef $guard; + $map = find $path + or return; } $cf::MAP{$key} = $map @@ -1149,12 +1238,13 @@ sub load { my ($self) = @_; + my $path = $self->{path}; + my $guard = cf::lock_acquire "map_load:" . $path->as_string; + return if $self->in_memory != cf::MAP_SWAPPED; $self->in_memory (cf::MAP_LOADING); - my $path = $self->{path}; - $self->alloc; $self->load_objects ($self->{load_path}, 1) or return; @@ -1170,6 +1260,8 @@ } } + Coro::cede; + # now do the right thing for maps $self->link_multipart_objects; @@ -1186,36 +1278,39 @@ $self->activate; } + Coro::cede; + $self->in_memory (cf::MAP_IN_MEMORY); } -sub load_map_sync { +sub find_sync { my ($path, $origin) = @_; - #warn "load_map_sync<$path, $origin>\n";#d# + cf::sync_job { cf::map::find $path, $origin } +} - cf::sync_job { - my $map = cf::map::find_map $path, $origin - or return; - $map->load; - $map - } +sub do_load_sync { + my ($map) = @_; + + cf::sync_job { $map->load }; } sub save { my ($self) = @_; - my $save = $self->{path}->save_path; utf8::encode $save; - my $uniq = $self->{path}->uniq_path; utf8::encode $uniq; - $self->{last_save} = $cf::RUNTIME; return unless $self->dirty; + my $save = $self->{path}->save_path; utf8::encode $save; + my $uniq = $self->{path}->uniq_path; utf8::encode $uniq; + $self->{load_path} = $save; return if $self->{deny_save}; + local $self->{last_access} = $self->last_access;#d# + if ($uniq) { $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS); $self->save_objects ($uniq, cf::IO_UNIQUES); @@ -1227,11 +1322,13 @@ sub swap_out { my ($self) = @_; + # save first because save cedes + $self->save; + return if $self->players; return if $self->in_memory != cf::MAP_IN_MEMORY; return if $self->{deny_save}; - $self->save; $self->clear; $self->in_memory (cf::MAP_SWAPPED); } @@ -1240,12 +1337,11 @@ my ($self) = @_; # TODO: safety, remove and allow resettable per-player maps - return 1e100 if $self->{path}{user_rel}; - return 1e100 if $self->{deny_reset}; + return 1e99 if $self->{path}{user_rel}; + return 1e99 if $self->{deny_reset}; my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access; - my $to = $self->reset_timeout || $DEFAULT_RESET; - $to = $MAX_RESET if $to > $MAX_RESET; + my $to = List::Util::min $MAX_RESET, $self->reset_timeout || $DEFAULT_RESET; $time + $to } @@ -1264,6 +1360,19 @@ aioreq_pri 3; IO::AIO::aio_unlink "$save.pst"; } +sub rename { + my ($self, $new_path) = @_; + + $self->unlink_save; + + delete $cf::MAP{$self->path}; + $self->{path} = new cf::path $new_path; + $self->path ($self->{path}->as_string); + $cf::MAP{$self->path} = $self; + + $self->save; +} + sub reset { my ($self) = @_; @@ -1280,18 +1389,29 @@ $self->destroy; } +my $nuke_counter = "aaaa"; + +sub nuke { + my ($self) = @_; + + $self->{deny_save} = 1; + $self->reset_timeout (1); + $self->rename ("{nuke}/" . ($nuke_counter++)); + $self->reset; # polite request, might not happen +} + sub customise_for { my ($map, $ob) = @_; if ($map->per_player) { - return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path}; + return cf::map::find "~" . $ob->name . "/" . $map->{path}{path}; } $map } sub emergency_save { - local $cf::FREEZE = 1; + my $freeze_guard = cf::freeze_mainloop; warn "enter emergency map save\n"; @@ -1352,16 +1472,35 @@ : $cf::CFG{"may_$access"}) } +=item $player_object->enter_link + +Freezes the player and moves him/her to a special map (C<{link}>). + +The player should be reaosnably safe there for short amounts of time. You +I call C as soon as possible, though. + +=item $player_object->leave_link ($map, $x, $y) + +Moves the player out of the specila link map onto the given map. If the +map is not valid (or omitted), the player will be moved back to the +location he/she was before the call to C, or, if that fails, +to the emergency map position. + +Might block. + +=cut + sub cf::object::player::enter_link { my ($self) = @_; + $self->deactivate_recursive; + return if $self->map == $LINK_MAP; - $self->{_link_pos} = [$self->map->{path}, $self->x, $self->y] + $self->{_link_pos} ||= [$self->map->{path}, $self->x, $self->y] if $self->map; $self->enter_map ($LINK_MAP, 20, 20); - $self->deactivate_recursive; } sub cf::object::player::leave_link { @@ -1370,15 +1509,13 @@ my $link_pos = delete $self->{_link_pos}; unless ($map) { - $self->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED); - # restore original map position ($map, $x, $y) = @{ $link_pos || [] }; - $map = cf::map::find_map $map; + $map = cf::map::find $map; unless ($map) { ($map, $x, $y) = @$EMERGENCY_POSITION; - $map = cf::map::find_map $map + $map = cf::map::find $map or die "FATAL: cannot load emergency map\n"; } } @@ -1396,23 +1533,53 @@ $self->enter_map ($map, $x, $y); } -=item $player_object->goto_map ($map, $x, $y) +cf::player->attach ( + on_logout => sub { + my ($pl) = @_; + + # abort map switching before logout + if ($pl->ob->{_link_pos}) { + cf::sync_job { + $pl->ob->leave_link + }; + } + }, + on_login => sub { + my ($pl) = @_; + + # 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 { + # 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 ($path, $x, $y) =cut -sub cf::object::player::goto_map { +sub cf::object::player::goto { my ($self, $path, $x, $y) = @_; $self->enter_link; - (Coro::async { + (cf::async { $path = new cf::path $path; - my $map = cf::map::find_map $path->as_string; + my $map = cf::map::find $path->as_string; $map = $map->customise_for ($self) if $map; - warn "entering ", $map->path, " at ($x, $y)\n" - if $map; +# warn "entering ", $map->path, " at ($x, $y)\n" +# if $map; + + $map or $self->message ("The exit is closed", cf::NDI_UNIQUE | cf::NDI_RED); $self->leave_link ($map, $x, $y); })->prio (1); @@ -1475,14 +1642,14 @@ $self->enter_link; - (Coro::async { + (cf::async { + $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; }) { @@ -1549,7 +1716,8 @@ # this weird shuffling is so that direct followup queries # get handled first - my $queue = delete $ns->{query_queue}; + my $queue = delete $ns->{query_queue} + or return; # be conservative, not sure how that can happen, but we saw a crash here (shift @$queue)->[1]->($msg); @@ -1576,12 +1744,7 @@ sub cf::client::coro { my ($self, $cb) = @_; - my $coro; $coro = async { - eval { - $cb->(); - }; - warn $@ if $@; - }; + my $coro = &cf::async ($cb); $coro->on_destroy (sub { delete $self->{_coro}{$coro+0}; @@ -1763,14 +1926,12 @@ my $path = cf::localdir . "/database.pst"; sub db_load() { - warn "loading database $path\n";#d# remove later $DB = stat $path ? Storable::retrieve $path : { }; } my $pid; sub db_save() { - warn "saving database $path\n";#d# remove later waitpid $pid, 0 if $pid; if (0 == ($pid = fork)) { $DB->{_meta}{version} = 1; @@ -1828,12 +1989,22 @@ local $/; *CFG = YAML::Syck::Load <$fh>; + + $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37]; + + if (exists $CFG{mlockall}) { + eval { + $CFG{mlockall} ? &mlockall : &munlockall + and die "WARNING: m(un)lockall failed: $!\n"; + }; + warn $@ if $@; + } } sub main { # we must not ever block the main coroutine local $Coro::idle = sub { - Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d# + Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d# (Coro::unblock_sub { Event::one_event; })->(); @@ -1857,7 +2028,7 @@ warn "reloading..."; - local $FREEZE = 1; + my $guard = freeze_mainloop; cf::emergency_save; eval { @@ -2003,11 +2174,8 @@ at => $NEXT_TICK || $TICK, data => WF_AUTOCANCEL, cb => sub { - unless ($FREEZE) { - cf::server_tick; # one server iteration - $RUNTIME += $TICK; - } - + cf::server_tick; # one server iteration + $RUNTIME += $TICK; $NEXT_TICK += $TICK; # if we are delayed by four ticks or more, skip them all @@ -2040,5 +2208,7 @@ }, ); +END { cf::emergency_save } + 1