ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/lib/cf.pm
(Generate patch)

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.125 by root, Tue Jan 2 23:06:39 2007 UTC vs.
Revision 1.131 by root, Thu Jan 4 00:53:54 2007 UTC

… …
8use Storable; 8use Storable;
9use Opcode; 9use Opcode;
10use Safe; 10use Safe;
11use Safe::Hole; 11use Safe::Hole;
12 12
13use Coro 3.3; 13use Coro 3.3 ();
14use Coro::Event; 14use Coro::Event;
15use Coro::Timer; 15use Coro::Timer;
16use Coro::Signal; 16use Coro::Signal;
17use Coro::Semaphore; 17use Coro::Semaphore;
18use Coro::AIO; 18use Coro::AIO;
… …
71mkdir cf::localdir . "/" . cf::uniquedir; 71mkdir cf::localdir . "/" . cf::uniquedir;
72mkdir $RANDOM_MAPS; 72mkdir $RANDOM_MAPS;
73 73
74# a special map that is always available 74# a special map that is always available
75our $LINK_MAP; 75our $LINK_MAP;
76 76our $EMERGENCY_POSITION;
77our $EMERGENCY_POSITION = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37];
78 77
79############################################################################# 78#############################################################################
80 79
81=head2 GLOBAL VARIABLES 80=head2 GLOBAL VARIABLES
82 81
… …
245 # wake up all waiters, to be on the safe side 244 # wake up all waiters, to be on the safe side
246 $_->ready for @{ delete $LOCK{$key} }; 245 $_->ready for @{ delete $LOCK{$key} };
247 } 246 }
248} 247}
249 248
249=item cf::async { BLOCK }
250
251Like C<Coro::async>, but runs the given BLOCK in an eval and only logs the
252error instead of exiting the server in case of a problem.
253
254=cut
255
256sub async(&) {
257 my ($cb) = @_;
258
259 Coro::async {
260 eval { $cb->() };
261 warn $@ if $@;
262 }
263}
264
250=item cf::sync_job { BLOCK } 265=item cf::sync_job { BLOCK }
251 266
252The design of crossfire+ requires that the main coro ($Coro::main) is 267The design of crossfire+ requires that the main coro ($Coro::main) is
253always able to handle events or runnable, as crossfire+ is only partly 268always able to handle events or runnable, as crossfire+ is only partly
254reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable. 269reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
… …
301=cut 316=cut
302 317
303sub coro(&) { 318sub coro(&) {
304 my $cb = shift; 319 my $cb = shift;
305 320
306 my $coro; $coro = async { 321 my $coro = &cf::async ($cb);
307 eval {
308 $cb->();
309 };
310 warn $@ if $@;
311 };
312 322
313 $coro->on_destroy (sub { 323 $coro->on_destroy (sub {
314 delete $EXT_CORO{$coro+0}; 324 delete $EXT_CORO{$coro+0};
315 }); 325 });
316 $EXT_CORO{$coro+0} = $coro; 326 $EXT_CORO{$coro+0} = $coro;
… …
1175 $map->{load_path} = $path; 1185 $map->{load_path} = $path;
1176 1186
1177 $map 1187 $map
1178} 1188}
1179 1189
1190sub find_map;
1180sub find_map { 1191sub find_map {
1181 my ($path, $origin) = @_; 1192 my ($path, $origin) = @_;
1182 1193
1183 #warn "find_map<$path,$origin>\n";#d# 1194 #warn "find_map<$path,$origin>\n";#d#
1184 1195
… …
1220 $map->last_access ($cf::RUNTIME); 1231 $map->last_access ($cf::RUNTIME);
1221 1232
1222 if ($map->should_reset) { 1233 if ($map->should_reset) {
1223 $map->reset; 1234 $map->reset;
1224 undef $guard; 1235 undef $guard;
1225 $map = cf::map::find_map ($path) 1236 $map = find_map $path
1226 or return; 1237 or return;
1227 } 1238 }
1228 1239
1229 $cf::MAP{$key} = $map 1240 $cf::MAP{$key} = $map
1230 } 1241 }
… …
1310} 1321}
1311 1322
1312sub swap_out { 1323sub swap_out {
1313 my ($self) = @_; 1324 my ($self) = @_;
1314 1325
1326 # save first because save cedes
1327 $self->save;
1328
1315 return if $self->players; 1329 return if $self->players;
1316 return if $self->in_memory != cf::MAP_IN_MEMORY; 1330 return if $self->in_memory != cf::MAP_IN_MEMORY;
1317 return if $self->{deny_save}; 1331 return if $self->{deny_save};
1318 1332
1319 $self->save;
1320 $self->clear; 1333 $self->clear;
1321 $self->in_memory (cf::MAP_SWAPPED); 1334 $self->in_memory (cf::MAP_SWAPPED);
1322} 1335}
1323 1336
1324sub reset_at { 1337sub reset_at {
… …
1537 1550
1538 # try to abort aborted map switching on player login :) 1551 # try to abort aborted map switching on player login :)
1539 # should happen only on crashes 1552 # should happen only on crashes
1540 if ($pl->ob->{_link_pos}) { 1553 if ($pl->ob->{_link_pos}) {
1541 $pl->ob->enter_link; 1554 $pl->ob->enter_link;
1542 Coro::async { 1555 cf::async {
1543 # we need this sleep as the login has a concurrent enter_exit running 1556 # we need this sleep as the login has a concurrent enter_exit running
1544 # and this sleep increases chances of the player not ending up in scorn 1557 # and this sleep increases chances of the player not ending up in scorn
1545 Coro::Timer::sleep 1; 1558 Coro::Timer::sleep 1;
1546 $pl->ob->leave_link; 1559 $pl->ob->leave_link;
1547 }; 1560 };
… …
1556sub cf::object::player::goto_map { 1569sub cf::object::player::goto_map {
1557 my ($self, $path, $x, $y) = @_; 1570 my ($self, $path, $x, $y) = @_;
1558 1571
1559 $self->enter_link; 1572 $self->enter_link;
1560 1573
1561 (Coro::async { 1574 (cf::async {
1562 $path = new cf::path $path; 1575 $path = new cf::path $path;
1563 1576
1564 my $map = cf::map::find_map $path->as_string; 1577 my $map = cf::map::find_map $path->as_string;
1565 $map = $map->customise_for ($self) if $map; 1578 $map = $map->customise_for ($self) if $map;
1566 1579
… …
1628 1641
1629 return unless $self->type == cf::PLAYER; 1642 return unless $self->type == cf::PLAYER;
1630 1643
1631 $self->enter_link; 1644 $self->enter_link;
1632 1645
1633 (Coro::async { 1646 (cf::async {
1634 unless (eval { 1647 unless (eval {
1635
1636 prepare_random_map $exit 1648 prepare_random_map $exit
1637 if $exit->slaying eq "/!"; 1649 if $exit->slaying eq "/!";
1638 1650
1639 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path; 1651 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
1640 $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp); 1652 $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
… …
1702 on_reply => sub { 1714 on_reply => sub {
1703 my ($ns, $msg) = @_; 1715 my ($ns, $msg) = @_;
1704 1716
1705 # this weird shuffling is so that direct followup queries 1717 # this weird shuffling is so that direct followup queries
1706 # get handled first 1718 # get handled first
1707 my $queue = delete $ns->{query_queue}; 1719 my $queue = delete $ns->{query_queue}
1720 or return; # be conservative, not sure how that can happen, but we saw a crash here
1708 1721
1709 (shift @$queue)->[1]->($msg); 1722 (shift @$queue)->[1]->($msg);
1710 1723
1711 push @{ $ns->{query_queue} }, @$queue; 1724 push @{ $ns->{query_queue} }, @$queue;
1712 1725
… …
1729=cut 1742=cut
1730 1743
1731sub cf::client::coro { 1744sub cf::client::coro {
1732 my ($self, $cb) = @_; 1745 my ($self, $cb) = @_;
1733 1746
1734 my $coro; $coro = async { 1747 my $coro = &cf::async ($cb);
1735 eval {
1736 $cb->();
1737 };
1738 warn $@ if $@;
1739 };
1740 1748
1741 $coro->on_destroy (sub { 1749 $coro->on_destroy (sub {
1742 delete $self->{_coro}{$coro+0}; 1750 delete $self->{_coro}{$coro+0};
1743 }); 1751 });
1744 1752
… …
1979 open my $fh, "<:utf8", cf::confdir . "/config" 1987 open my $fh, "<:utf8", cf::confdir . "/config"
1980 or return; 1988 or return;
1981 1989
1982 local $/; 1990 local $/;
1983 *CFG = YAML::Syck::Load <$fh>; 1991 *CFG = YAML::Syck::Load <$fh>;
1992
1993 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
1994
1995 if (exists $CFG{mlockall}) {
1996 eval {
1997 $CFG{mlockall} ? &mlockall : &munlockall
1998 and die "WARNING: m(un)lockall failed: $!\n";
1999 };
2000 warn $@ if $@;
2001 }
1984} 2002}
1985 2003
1986sub main { 2004sub main {
1987 # we must not ever block the main coroutine 2005 # we must not ever block the main coroutine
1988 local $Coro::idle = sub { 2006 local $Coro::idle = sub {

Diff Legend

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