--- deliantra/server/lib/cf.pm 2007/01/13 23:32:43 1.167 +++ deliantra/server/lib/cf.pm 2007/01/20 23:30:16 1.188 @@ -10,7 +10,7 @@ use Safe; use Safe::Hole; -use Coro 3.3 (); +use Coro 3.4 (); use Coro::Event; use Coro::Timer; use Coro::Signal; @@ -46,6 +46,8 @@ our $TICK = MAX_TIME * 1e-6; our $TICK_WATCHER; +our $AIO_POLL_WATCHER; +our $WRITE_RUNTIME_WATCHER; our $NEXT_TICK; our $NOW; @@ -259,7 +261,11 @@ sub freeze_mainloop { return unless $TICK_WATCHER->is_active; - my $guard = Coro::guard { $TICK_WATCHER->start }; + my $guard = Coro::guard { + $TICK_WATCHER->start; + $WRITE_RUNTIME_WATCHER->start; + }; + $WRITE_RUNTIME_WATCHER->stop; $TICK_WATCHER->stop; $guard } @@ -340,14 +346,15 @@ } sub write_runtime { - return unless $TICK_WATCHER->is_active; - my $runtime = cf::localdir . "/runtime"; my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644 or return; - my $value = $cf::RUNTIME + 1 + 10; # 10 is the runtime save interval, for a monotonic clock + 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_write $fh, 0, (length $value), $value, 0) <= 0 and return; @@ -501,6 +508,12 @@ my %attachment; +sub cf::attachable::thawer_merge { + # simply override everything except _meta + local $_[0]{_meta}; + %{$_[0]} = %{$_[1]}; +} + sub _attach_cb($$$$) { my ($registry, $event, $prio, $cb) = @_; @@ -682,6 +695,8 @@ # basically do the same as instantiate, without calling instantiate my ($obj) = @_; + bless $obj, ref $obj; # re-bless in case extensions have been reloaded + my $registry = $obj->registry; @$registry = (); @@ -947,7 +962,7 @@ my ($login) = @_; $cf::PLAYER{$login} - or cf::sync_job { !aio_stat $login } + or cf::sync_job { !aio_stat path $login } } sub find($) { @@ -1103,14 +1118,14 @@ use Coro::AIO; use overload - '""' => \&as_string; + '""' => \&as_string, + fallback => 1; our $MAX_RESET = 3600; our $DEFAULT_RESET = 3000; sub generate_random_map { my ($self, $rmp) = @_; - # mit "rum" bekleckern, nicht $self->_create_random_map ( $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle}, @@ -1127,18 +1142,38 @@ ) } +=item cf::map->register ($regex, $prio) + +Register a handler for the map path matching the given regex at the +givne priority (higher is better, built-in handlers have priority 0, the +default). + +=cut + sub register { - my (undef, $regex) = @_; + my (undef, $regex, $prio) = @_; my $pkg = caller; no strict; push @{"$pkg\::ISA"}, __PACKAGE__; - $EXT_MAP{$pkg} = qr<$regex>; + $EXT_MAP{$pkg} = [$prio, qr<$regex>]; } # also paths starting with '/' -$EXT_MAP{"cf::map"} = qr{^(?=/)}; +$EXT_MAP{"cf::map"} = [0, qr{^(?=/)}]; + +sub thawer_merge { + my ($self, $merge) = @_; + + # we have to keep some variables in memory intact + local $self->{path}; + local $self->{load_path}; + local $self->{deny_save}; + local $self->{deny_reset}; + + $self->SUPER::thawer_merge ($merge); +} sub normalise { my ($path, $base) = @_; @@ -1179,8 +1214,8 @@ $path = normalise $path, $base; - for my $pkg (keys %EXT_MAP) { - if ($path =~ $EXT_MAP{$pkg}) { + for my $pkg (sort { $EXT_MAP{$b}[0] <=> $EXT_MAP{$a}[0] } keys %EXT_MAP) { + if ($path =~ $EXT_MAP{$pkg}[1]) { my $self = bless cf::map::new, $pkg; $self->{path} = $path; $self->path ($path); $self->init; # pass $1 etc. @@ -1245,8 +1280,8 @@ my ($self) = @_; utf8::encode (my $save = $self->save_path); - IO::AIO::aioreq_pri 4; IO::AIO::aio_unlink $save; - IO::AIO::aioreq_pri 4; IO::AIO::aio_unlink "$save.pst"; + IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink $save; + IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink "$save.pst"; } sub load_header_from($) { @@ -1264,35 +1299,46 @@ 1 } -sub load_orig { +sub load_header_orig { my ($self) = @_; $self->load_header_from ($self->load_path) } -sub load_temp { +sub load_header_temp { my ($self) = @_; $self->load_header_from ($self->save_path) } +sub prepare_temp { + my ($self) = @_; + + $self->last_access ((delete $self->{last_access}) + || $cf::RUNTIME); #d# + # safety + $self->{instantiate_time} = $cf::RUNTIME + if $self->{instantiate_time} > $cf::RUNTIME; +} + +sub prepare_orig { + my ($self) = @_; + + $self->{load_original} = 1; + $self->{instantiate_time} = $cf::RUNTIME; + $self->last_access ($cf::RUNTIME); + $self->instantiate; +} + sub load_header { my ($self) = @_; - if ($self->load_temp) { - $self->last_access ((delete $self->{last_access}) - || $cf::RUNTIME); #d# - # safety - $self->{instantiate_time} = $cf::RUNTIME - if $self->{instantiate_time} > $cf::RUNTIME; + if ($self->load_header_temp) { + $self->prepare_temp; } else { - $self->load_orig + $self->load_header_orig or return; - - $self->{load_original} = 1; - $self->{instantiate_time} = $cf::RUNTIME; - $self->last_access ($cf::RUNTIME); - $self->instantiate; + $self->prepare_orig; } 1 @@ -1317,6 +1363,8 @@ or return; if ($map->should_reset) { + # doing this can freeze the server in a sync job, obviously + #$cf::WAIT_FOR_TICK->wait; $map->reset; undef $guard; $map = find $path @@ -1327,6 +1375,9 @@ } } +sub pre_load { } +sub post_load { } + sub load { my ($self) = @_; @@ -1338,6 +1389,9 @@ $self->in_memory (cf::MAP_LOADING); $self->alloc; + + $self->pre_load; + $self->_load_objects ($self->{load_path}, 1) or return; @@ -1369,6 +1423,8 @@ $self->activate; } + $self->post_load; + $self->in_memory (cf::MAP_IN_MEMORY); } @@ -1418,18 +1474,7 @@ } our %MAP_PREFETCH; -our $MAP_PREFETCHER = Coro::async { - while () { - for my $path (keys %MAP_PREFETCH) { - my $map = find $path - or next; - $map->load; - - delete $MAP_PREFETCH{$path}; - } - Coro::schedule; - } -}; +our $MAP_PREFETCHER = undef; sub find_async { my ($path, $origin) = @_; @@ -1440,8 +1485,19 @@ return $map if $map->in_memory == cf::MAP_IN_MEMORY; } - $MAP_PREFETCH{$path} = 0; - $MAP_PREFETCHER->ready; + undef $MAP_PREFETCH{$path}; + $MAP_PREFETCHER ||= cf::async { + while (%MAP_PREFETCH) { + for my $path (keys %MAP_PREFETCH) { + my $map = find $path + or next; + $map->load; + + delete $MAP_PREFETCH{$path}; + } + } + undef $MAP_PREFETCHER; + }; () } @@ -1496,7 +1552,7 @@ my ($self) = @_; # TODO: safety, remove and allow resettable per-player maps - return 1e99 if $self->isa ("ext::map_per_player"); + return 1e99 if $self->isa ("ext::map_per_player");#d# return 1e99 if $self->{deny_reset}; my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access; @@ -1511,20 +1567,6 @@ $self->reset_at <= $cf::RUNTIME } -sub rename { - my ($self, $new_path) = @_; - - normalise $new_path; - - $self->unlink_save; - - delete $cf::MAP{$self->path}; - $self->{path} = $new_path; $self->path ($self->{path}); - $cf::MAP{$self->path} = $self; - - $self->save; -} - sub reset { my ($self) = @_; @@ -1551,9 +1593,18 @@ sub nuke { my ($self) = @_; + delete $cf::MAP{$self->path}; + + $self->unlink_save; + + bless $self, "cf::map"; + delete $self->{deny_reset}; $self->{deny_save} = 1; $self->reset_timeout (1); - $self->rename ("{nuke}/" . ($nuke_counter++)); + $self->path ($self->{path} = "{nuke}/" . ($nuke_counter++)); + + $cf::MAP{$self->path} = $self; + $self->reset; # polite request, might not happen } @@ -1794,8 +1845,10 @@ my ($spec) = @_; my $rmp = { # defaults - xsize => 10, - ysize => 10, + xsize => (cf::rndm 15, 40), + ysize => (cf::rndm 15, 40), + symmetry => (cf::rndm 1, cf::SYMMETRY_XY), + #layout => string, }; for (split /\n/, $spec) { @@ -1810,6 +1863,8 @@ 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 @@ -1827,9 +1882,12 @@ my $data = cf::to_json $rmp; my $md5 = Digest::MD5::md5_hex $data; + my $meta = "$cf::RANDOM_MAPS/$md5.meta"; - if (my $fh = aio_open "$cf::RANDOM_MAPS/$md5.meta", O_WRONLY | O_CREAT, 0666) { + 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; $exit->slaying ("?random/$md5"); $exit->msg (undef); @@ -2149,7 +2207,7 @@ undef $dirty; } - my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, data => WF_AUTOCANCEL, cb => sub { + my $idle = Event->idle (min => 10, max => 20, repeat => 0, data => WF_AUTOCANCEL, cb => sub { db_sync; }); @@ -2209,12 +2267,16 @@ # 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 { Event::one_event }; + (async { + Event::one_event; + })->prio (Coro::PRIO_MAX); }; cfg_load; db_load; load_extensions; + + $TICK_WATCHER->start; Event::loop; } @@ -2266,39 +2328,47 @@ sub reload() { # can/must only be called in main if ($Coro::current != $Coro::main) { - warn "can only reload from main coroutine\n"; + warn "can only reload from main coroutine"; return; } warn "reloading..."; - warn "freezing server"; - my $guard = freeze_mainloop; - cf::emergency_save; + warn "cancelling server ticker"; + $TICK_WATCHER->cancel; - warn "sync database to disk"; - cf::db_sync; - IO::AIO::flush; + cf::emergency_save; eval { # if anything goes wrong in here, we should simply crash as we already saved - warn "cancel all watchers"; + warn "syncing database to disk"; + cf::db_sync; + + warn "cancelling all WF_AUTOCANCEL watchers"; for (Event::all_watchers) { $_->cancel if $_->data & WF_AUTOCANCEL; } - warn "cancel all extension coros"; + warn "flushing outstanding aio requests"; + for (;;) { + IO::AIO::flush; + Coro::cede; + last unless IO::AIO::nreqs; + warn "iterate..."; + } + + warn "cancelling all extension coros"; $_->cancel for values %EXT_CORO; %EXT_CORO = (); - warn "remove commands"; + warn "removing commands"; %COMMAND = (); - warn "remove ext commands"; + warn "removing ext commands"; %EXTCMD = (); - warn "unload/nuke all extensions"; + warn "unloading/nuking all extensions"; for my $pkg (@EXTS) { warn "... unloading $pkg"; @@ -2313,11 +2383,11 @@ Symbol::delete_package $pkg; } - warn "unload all perl modules loaded from $LIBDIR"; + warn "unloading all perl modules loaded from $LIBDIR"; while (my ($k, $v) = each %INC) { next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/; - warn "removing <$k>"; + warn "... unloading $k"; delete $INC{$k}; $k =~ s/\.pm$//; @@ -2330,32 +2400,38 @@ Symbol::delete_package $k; } - warn "get rid of safe::, as good as possible"; + warn "getting rid of safe::, as good as possible"; Symbol::delete_package "safe::$_" for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region); - warn "unload cf.pm \"a bit\""; + warn "unloading cf.pm \"a bit\""; delete $INC{"cf.pm"}; # don't, removes xs symbols, too, # and global variables created in xs #Symbol::delete_package __PACKAGE__; + warn "unload completed, starting to reload now"; + warn "reloading cf.pm"; require cf; cf::_connect_to_perl; # nominally unnecessary, but cannot hurt - warn "load config and database again"; + warn "loading config and database again"; cf::cfg_load; cf::db_load; - warn "load extensions"; + warn "loading extensions"; cf::load_extensions; - warn "reattach attachments to objects/players"; + warn "reattaching attachments to objects/players"; _global_reattach; - warn "reattach attachments to maps"; + warn "reattaching attachments to maps"; reattach $_ for values %MAP; + + warn "restarting server ticker"; + + $TICK_WATCHER->start; }; if ($@) { @@ -2367,24 +2443,41 @@ warn "reloaded"; }; +our $RELOAD_WATCHER; # used only during reload + register_command "reload" => sub { my ($who, $arg) = @_; if ($who->flag (FLAG_WIZ)) { - $who->message ("start of reload."); - reload; - $who->message ("end of reload."); + $who->message ("reloading server."); + + # doing reload synchronously and two reloads happen back-to-back, + # coro crashes during coro_state_free->destroy here. + + $RELOAD_WATCHER ||= Event->timer (after => 0, data => WF_AUTOCANCEL, cb => sub { + reload; + undef $RELOAD_WATCHER; + }); } }; unshift @INC, $LIBDIR; +my $bug_warning = 0; + $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 = Event::time; cf::server_tick; # one server iteration @@ -2404,7 +2497,7 @@ IO::AIO::max_poll_time $TICK * 0.2; -Event->io ( +$AIO_POLL_WATCHER = Event->io ( fd => IO::AIO::poll_fileno, poll => 'r', prio => 5, @@ -2412,15 +2505,14 @@ cb => \&IO::AIO::poll_cb, ); -Event->timer ( +$WRITE_RUNTIME_WATCHER = Event->timer ( data => WF_AUTOCANCEL, - after => 0, + after => 1, interval => 10, - cb => sub { - (Coro::unblock_sub { - write_runtime - or warn "ERROR: unable to write runtime file: $!"; - })->(); + prio => 6, # keep it lowest so it acts like a watchdog + cb => Coro::unblock_sub { + write_runtime + or warn "ERROR: unable to write runtime file: $!"; }, );