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.136 by root, Fri Jan 5 01:06:28 2007 UTC vs.
Revision 1.140 by root, Fri Jan 5 20:04:02 2007 UTC

… …
26use Event; $Event::Eval = 1; # no idea why this is required, but it is 26use Event; $Event::Eval = 1; # no idea why this is required, but it is
27 27
28# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode? 28# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
29$YAML::Syck::ImplicitUnicode = 1; 29$YAML::Syck::ImplicitUnicode = 1;
30 30
31$Coro::main->prio (2); # run main coroutine ("the server") with very high priority 31$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
32 32
33sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload 33sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
34 34
35our %COMMAND = (); 35our %COMMAND = ();
36our %COMMAND_TIME = (); 36our %COMMAND_TIME = ();
… …
221 # wake up all waiters, to be on the safe side 221 # wake up all waiters, to be on the safe side
222 $_->ready for @{ delete $LOCK{$key} }; 222 $_->ready for @{ delete $LOCK{$key} };
223 } 223 }
224} 224}
225 225
226=item cf::async { BLOCK }
227
228Like C<Coro::async>, but runs the given BLOCK in an eval and only logs the
229error instead of exiting the server in case of a problem.
230
231=cut
232
233sub async(&) {
234 my ($cb) = @_;
235
236 Coro::async {
237 eval { $cb->() };
238 warn $@ if $@;
239 }
240}
241
242sub freeze_mainloop { 226sub freeze_mainloop {
243 return unless $TICK_WATCHER->is_active; 227 return unless $TICK_WATCHER->is_active;
244 228
245 my $guard = Coro::guard { $TICK_WATCHER->start }; 229 my $guard = Coro::guard { $TICK_WATCHER->start };
246 $TICK_WATCHER->stop; 230 $TICK_WATCHER->stop;
247 $guard 231 $guard
248} 232}
233
234=item cf::async { BLOCK }
235
236Currently the same as Coro::async_pool, meaning you cannot use
237C<on_destroy>, C<join> or other gimmicks on these coroutines. The only
238thing you are allowed to do is call C<prio> on it.
239
240=cut
241
242BEGIN { *async = \&Coro::async_pool }
249 243
250=item cf::sync_job { BLOCK } 244=item cf::sync_job { BLOCK }
251 245
252The design of crossfire+ requires that the main coro ($Coro::main) is 246The design of crossfire+ requires that the main coro ($Coro::main) is
253always able to handle events or runnable, as crossfire+ is only partly 247always able to handle events or runnable, as crossfire+ is only partly
… …
272 my $freeze_guard = freeze_mainloop; 266 my $freeze_guard = freeze_mainloop;
273 267
274 my $busy = 1; 268 my $busy = 1;
275 my @res; 269 my @res;
276 270
277 (Coro::async { 271 (async {
278 @res = eval { $job->() }; 272 @res = eval { $job->() };
279 warn $@ if $@; 273 warn $@ if $@;
280 undef $busy; 274 undef $busy;
281 })->prio (Coro::PRIO_MAX); 275 })->prio (Coro::PRIO_MAX);
282 276
283 while ($busy) { 277 while ($busy) {
284 Coro::cede_notself; 278 unless (Coro::cede) {
285 Event::one_event unless Coro::nready; 279 Coro::nready ? Event::one_event 0 : Event::one_event;
280 Coro::cede_notself unless Coro::cede;
281 }
286 } 282 }
287 283
288 wantarray ? @res : $res[0] 284 wantarray ? @res : $res[0]
289 } else { 285 } else {
290 # we are in another coroutine, how wonderful, everything just works 286 # we are in another coroutine, how wonderful, everything just works
291 287
292 $job->() 288 $job->()
293 } 289 }
294} 290}
295 291
296=item $coro = cf::coro { BLOCK } 292=item $coro = cf::async_ext { BLOCK }
297 293
298Creates and returns a new coro. This coro is automcatially being canceled 294Like async, but this coro is automcatially being canceled when the
299when the extension calling this is being unloaded. 295extension calling this is being unloaded.
300 296
301=cut 297=cut
302 298
303sub coro(&) { 299sub async_ext(&) {
304 my $cb = shift; 300 my $cb = shift;
305 301
306 my $coro = &cf::async ($cb); 302 my $coro = &Coro::async ($cb);
307 303
308 $coro->on_destroy (sub { 304 $coro->on_destroy (sub {
309 delete $EXT_CORO{$coro+0}; 305 delete $EXT_CORO{$coro+0};
310 }); 306 });
311 $EXT_CORO{$coro+0} = $coro; 307 $EXT_CORO{$coro+0} = $coro;
… …
1296} 1292}
1297 1293
1298sub save { 1294sub save {
1299 my ($self) = @_; 1295 my ($self) = @_;
1300 1296
1297 my $lock = cf::lock_acquire "map_data:" . $self->path;
1298
1301 $self->{last_save} = $cf::RUNTIME; 1299 $self->{last_save} = $cf::RUNTIME;
1302 1300
1303 return unless $self->dirty; 1301 return unless $self->dirty;
1304 1302
1305 my $save = $self->{path}->save_path; utf8::encode $save; 1303 my $save = $self->{path}->save_path; utf8::encode $save;
… …
1323 my ($self) = @_; 1321 my ($self) = @_;
1324 1322
1325 # save first because save cedes 1323 # save first because save cedes
1326 $self->save; 1324 $self->save;
1327 1325
1326 my $lock = cf::lock_acquire "map_data:" . $self->path;
1327
1328 return if $self->players; 1328 return if $self->players;
1329 return if $self->in_memory != cf::MAP_IN_MEMORY; 1329 return if $self->in_memory != cf::MAP_IN_MEMORY;
1330 return if $self->{deny_save}; 1330 return if $self->{deny_save};
1331 1331
1332 $self->clear; 1332 $self->clear;
… …
1373 $self->save; 1373 $self->save;
1374} 1374}
1375 1375
1376sub reset { 1376sub reset {
1377 my ($self) = @_; 1377 my ($self) = @_;
1378
1379 my $lock = cf::lock_acquire "map_data:" . $self->path;
1378 1380
1379 return if $self->players; 1381 return if $self->players;
1380 return if $self->{path}{user_rel};#d# 1382 return if $self->{path}{user_rel};#d#
1381 1383
1382 warn "resetting map ", $self->path;#d# 1384 warn "resetting map ", $self->path;#d#
… …
1548 my ($pl) = @_; 1550 my ($pl) = @_;
1549 1551
1550 # try to abort aborted map switching on player login :) 1552 # try to abort aborted map switching on player login :)
1551 # should happen only on crashes 1553 # should happen only on crashes
1552 if ($pl->ob->{_link_pos}) { 1554 if ($pl->ob->{_link_pos}) {
1555
1553 $pl->ob->enter_link; 1556 $pl->ob->enter_link;
1554 cf::async { 1557 (async {
1555 # we need this sleep as the login has a concurrent enter_exit running 1558 # we need this sleep as the login has a concurrent enter_exit running
1556 # and this sleep increases chances of the player not ending up in scorn 1559 # and this sleep increases chances of the player not ending up in scorn
1560 $pl->ob->reply (undef,
1561 "There was an internal problem at your last logout, "
1562 . "the server will try to bring you to your intended destination in a second.",
1563 cf::NDI_RED);
1557 Coro::Timer::sleep 1; 1564 Coro::Timer::sleep 1;
1558 $pl->ob->leave_link; 1565 $pl->ob->leave_link;
1559 }; 1566 })->prio (2);
1560 } 1567 }
1561 }, 1568 },
1562); 1569);
1563 1570
1564=item $player_object->goto ($path, $x, $y) 1571=item $player_object->goto ($path, $x, $y)
… …
1568sub cf::object::player::goto { 1575sub cf::object::player::goto {
1569 my ($self, $path, $x, $y) = @_; 1576 my ($self, $path, $x, $y) = @_;
1570 1577
1571 $self->enter_link; 1578 $self->enter_link;
1572 1579
1573 (cf::async { 1580 (async {
1574 $path = new cf::path $path; 1581 $path = new cf::path $path;
1575 1582
1576 my $map = cf::map::find $path->as_string; 1583 my $map = cf::map::find $path->as_string;
1577 $map = $map->customise_for ($self) if $map; 1584 $map = $map->customise_for ($self) if $map;
1578 1585
… …
1640 1647
1641 return unless $self->type == cf::PLAYER; 1648 return unless $self->type == cf::PLAYER;
1642 1649
1643 $self->enter_link; 1650 $self->enter_link;
1644 1651
1645 (cf::async { 1652 (async {
1646 $self->deactivate_recursive; # just to be sure 1653 $self->deactivate_recursive; # just to be sure
1647 unless (eval { 1654 unless (eval {
1648 prepare_random_map $exit 1655 prepare_random_map $exit
1649 if $exit->slaying eq "/!"; 1656 if $exit->slaying eq "/!";
1650 1657
… …
1731 } 1738 }
1732 } 1739 }
1733 }, 1740 },
1734); 1741);
1735 1742
1736=item $client->coro (\&cb) 1743=item $client->async (\&cb)
1737 1744
1738Create a new coroutine, running the specified callback. The coroutine will 1745Create a new coroutine, running the specified callback. The coroutine will
1739be automatically cancelled when the client gets destroyed (e.g. on logout, 1746be automatically cancelled when the client gets destroyed (e.g. on logout,
1740or loss of connection). 1747or loss of connection).
1741 1748
1742=cut 1749=cut
1743 1750
1744sub cf::client::coro { 1751sub cf::client::async {
1745 my ($self, $cb) = @_; 1752 my ($self, $cb) = @_;
1746 1753
1747 my $coro = &cf::async ($cb); 1754 my $coro = &Coro::async ($cb);
1748 1755
1749 $coro->on_destroy (sub { 1756 $coro->on_destroy (sub {
1750 delete $self->{_coro}{$coro+0}; 1757 delete $self->{_coro}{$coro+0};
1751 }); 1758 });
1752 1759
… …
1990 local $/; 1997 local $/;
1991 *CFG = YAML::Syck::Load <$fh>; 1998 *CFG = YAML::Syck::Load <$fh>;
1992 1999
1993 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37]; 2000 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
1994 2001
2002 $cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
2003 $cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
2004
1995 if (exists $CFG{mlockall}) { 2005 if (exists $CFG{mlockall}) {
1996 eval { 2006 eval {
1997 $CFG{mlockall} ? &mlockall : &munlockall 2007 $CFG{mlockall} ? &mlockall : &munlockall
1998 and die "WARNING: m(un)lockall failed: $!\n"; 2008 and die "WARNING: m(un)lockall failed: $!\n";
1999 }; 2009 };
… …
2003 2013
2004sub main { 2014sub main {
2005 # we must not ever block the main coroutine 2015 # we must not ever block the main coroutine
2006 local $Coro::idle = sub { 2016 local $Coro::idle = sub {
2007 Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d# 2017 Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
2008 (Coro::unblock_sub {
2009 Event::one_event; 2018 async { Event::one_event };
2010 })->();
2011 }; 2019 };
2012 2020
2013 cfg_load; 2021 cfg_load;
2014 db_load; 2022 db_load;
2015 load_extensions; 2023 load_extensions;

Diff Legend

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