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.406 by root, Mon Dec 17 08:27:44 2007 UTC vs.
Revision 1.418 by root, Fri Apr 11 21:09:53 2008 UTC

1#
2# This file is part of Deliantra, the Roguelike Realtime MMORPG.
3#
4# Copyright (©) 2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5#
6# Deliantra is free software: you can redistribute it and/or modify
7# it under the terms of the GNU General Public License as published by
8# the Free Software Foundation, either version 3 of the License, or
9# (at your option) any later version.
10#
11# This program is distributed in the hope that it will be useful,
12# but WITHOUT ANY WARRANTY; without even the implied warranty of
13# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14# GNU General Public License for more details.
15#
16# You should have received a copy of the GNU General Public License
17# along with this program. If not, see <http://www.gnu.org/licenses/>.
18#
19# The authors can be reached via e-mail to <support@deliantra.net>
20#
21
1package cf; 22package cf;
2 23
3use utf8; 24use utf8;
4use strict; 25use strict;
5 26
6use Symbol; 27use Symbol;
7use List::Util; 28use List::Util;
8use Socket; 29use Socket;
9use EV 1.86; 30use EV 3.2;
10use Opcode; 31use Opcode;
11use Safe; 32use Safe;
12use Safe::Hole; 33use Safe::Hole;
13use Storable (); 34use Storable ();
14 35
15use Coro 4.32 (); 36use Coro 4.50 ();
16use Coro::State; 37use Coro::State;
17use Coro::Handle; 38use Coro::Handle;
18use Coro::EV; 39use Coro::EV;
19use Coro::Timer; 40use Coro::Timer;
20use Coro::Signal; 41use Coro::Signal;
… …
27use JSON::XS 2.01 (); 48use JSON::XS 2.01 ();
28use BDB (); 49use BDB ();
29use Data::Dumper; 50use Data::Dumper;
30use Digest::MD5; 51use Digest::MD5;
31use Fcntl; 52use Fcntl;
32use YAML::Syck (); 53use YAML ();
33use IO::AIO 2.51 (); 54use IO::AIO 2.51 ();
34use Time::HiRes; 55use Time::HiRes;
35use Compress::LZF; 56use Compress::LZF;
36use Digest::MD5 (); 57use Digest::MD5 ();
37 58
38# configure various modules to our taste 59# configure various modules to our taste
39# 60#
40$Storable::canonical = 1; # reduce rsync transfers 61$Storable::canonical = 1; # reduce rsync transfers
41Coro::State::cctx_stacksize 256000; # 1-2MB stack, for deep recursions in maze generator 62Coro::State::cctx_stacksize 256000; # 1-2MB stack, for deep recursions in maze generator
42Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later 63Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
43
44# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
45$YAML::Syck::ImplicitUnicode = 1;
46 64
47$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority 65$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
48 66
49sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload 67sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
50 68
… …
72our $RANDOMDIR = "$LOCALDIR/random"; 90our $RANDOMDIR = "$LOCALDIR/random";
73our $BDBDIR = "$LOCALDIR/db"; 91our $BDBDIR = "$LOCALDIR/db";
74our %RESOURCE; 92our %RESOURCE;
75 93
76our $TICK = MAX_TIME * 1e-6; # this is a CONSTANT(!) 94our $TICK = MAX_TIME * 1e-6; # this is a CONSTANT(!)
77our $TICK_WATCHER;
78our $AIO_POLL_WATCHER; 95our $AIO_POLL_WATCHER;
79our $NEXT_RUNTIME_WRITE; # when should the runtime file be written 96our $NEXT_RUNTIME_WRITE; # when should the runtime file be written
80our $NEXT_TICK; 97our $NEXT_TICK;
81our $USE_FSYNC = 1; # use fsync to write maps - default off 98our $USE_FSYNC = 1; # use fsync to write maps - default off
82 99
… …
99# used to convert map paths into valid unix filenames by replacing / by ∕ 116# used to convert map paths into valid unix filenames by replacing / by ∕
100our $PATH_SEP = "∕"; # U+2215, chosen purely for visual reasons 117our $PATH_SEP = "∕"; # U+2215, chosen purely for visual reasons
101 118
102our $LOAD; # a number between 0 (idle) and 1 (too many objects) 119our $LOAD; # a number between 0 (idle) and 1 (too many objects)
103our $LOADAVG; # same thing, but with alpha-smoothing 120our $LOADAVG; # same thing, but with alpha-smoothing
121our $JITTER; # average jitter
104our $tick_start; # for load detecting purposes 122our $TICK_START; # for load detecting purposes
105 123
106binmode STDOUT; 124binmode STDOUT;
107binmode STDERR; 125binmode STDERR;
108 126
109# read virtual server time, if available 127# read virtual server time, if available
… …
193 $msg =~ s/([\x00-\x08\x0b-\x1f])/sprintf "\\x%02x", ord $1/ge; 211 $msg =~ s/([\x00-\x08\x0b-\x1f])/sprintf "\\x%02x", ord $1/ge;
194 212
195 LOG llevError, $msg; 213 LOG llevError, $msg;
196 }; 214 };
197} 215}
216
217$Coro::State::DIEHOOK = sub {
218 return unless $^S eq 0; # "eq", not "=="
219
220 if ($Coro::current == $Coro::main) {#d#
221 warn "DIEHOOK called in main context, Coro bug?\n";#d#
222 return;#d#
223 }#d#
224
225 # kill coroutine otherwise
226 warn Carp::longmess $_[0];
227 Coro::terminate
228};
229
230$SIG{__DIE__} = sub { }; #d#?
198 231
199@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable'; 232@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
200@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable'; 233@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';
201@safe::cf::player::ISA = @cf::player::ISA = 'cf::attachable'; 234@safe::cf::player::ISA = @cf::player::ISA = 'cf::attachable';
202@safe::cf::client::ISA = @cf::client::ISA = 'cf::attachable'; 235@safe::cf::client::ISA = @cf::client::ISA = 'cf::attachable';
… …
327 360
328 ! ! $LOCK{$key} 361 ! ! $LOCK{$key}
329} 362}
330 363
331sub freeze_mainloop { 364sub freeze_mainloop {
332 return unless $TICK_WATCHER->is_active; 365 tick_inhibit_inc;
333 366
334 my $guard = Coro::guard { 367 Coro::guard \&tick_inhibit_dec;
335 $TICK_WATCHER->start;
336 };
337 $TICK_WATCHER->stop;
338 $guard
339} 368}
340 369
341=item cf::periodic $interval, $cb 370=item cf::periodic $interval, $cb
342 371
343Like EV::periodic, but randomly selects a starting point so that the actions 372Like EV::periodic, but randomly selects a starting point so that the actions
… …
444 # this is the main coro, too bad, we have to block 473 # this is the main coro, too bad, we have to block
445 # till the operation succeeds, freezing the server :/ 474 # till the operation succeeds, freezing the server :/
446 475
447 LOG llevError, Carp::longmess "sync job";#d# 476 LOG llevError, Carp::longmess "sync job";#d#
448 477
449 # TODO: use suspend/resume instead
450 # (but this is cancel-safe)
451 my $freeze_guard = freeze_mainloop; 478 my $freeze_guard = freeze_mainloop;
452 479
453 my $busy = 1; 480 my $busy = 1;
454 my @res; 481 my @res;
455 482
… …
466 } else { 493 } else {
467 EV::loop EV::LOOP_ONESHOT; 494 EV::loop EV::LOOP_ONESHOT;
468 } 495 }
469 } 496 }
470 497
471 $time = EV::time - $time; 498 my $time = EV::time - $time;
472 499
473 LOG llevError | logBacktrace, Carp::longmess "long sync job"
474 if $time > $TICK * 0.5 && $TICK_WATCHER->is_active;
475
476 $tick_start += $time; # do not account sync jobs to server load 500 $TICK_START += $time; # do not account sync jobs to server load
477 501
478 wantarray ? @res : $res[0] 502 wantarray ? @res : $res[0]
479 } else { 503 } else {
480 # we are in another coroutine, how wonderful, everything just works 504 # we are in another coroutine, how wonderful, everything just works
481 505
… …
523 reset_signals; 547 reset_signals;
524 &$cb 548 &$cb
525 }, @args; 549 }, @args;
526 550
527 wantarray ? @res : $res[-1] 551 wantarray ? @res : $res[-1]
552}
553
554=item $coin = coin_from_name $name
555
556=cut
557
558our %coin_alias = (
559 "silver" => "silvercoin",
560 "silvercoin" => "silvercoin",
561 "silvercoins" => "silvercoin",
562 "gold" => "goldcoin",
563 "goldcoin" => "goldcoin",
564 "goldcoins" => "goldcoin",
565 "platinum" => "platinacoin",
566 "platinumcoin" => "platinacoin",
567 "platinumcoins" => "platinacoin",
568 "platina" => "platinacoin",
569 "platinacoin" => "platinacoin",
570 "platinacoins" => "platinacoin",
571 "royalty" => "royalty",
572 "royalties" => "royalty",
573);
574
575sub coin_from_name($) {
576 $coin_alias{$_[0]}
577 ? cf::arch::find $coin_alias{$_[0]}
578 : undef
528} 579}
529 580
530=item $value = cf::db_get $family => $key 581=item $value = cf::db_get $family => $key
531 582
532Returns a single value from the environment database. 583Returns a single value from the environment database.
… …
1304 my $msg = $@ ? "$v->{path}: $@\n" 1355 my $msg = $@ ? "$v->{path}: $@\n"
1305 : "$v->{base}: extension inactive.\n"; 1356 : "$v->{base}: extension inactive.\n";
1306 1357
1307 if (exists $v->{meta}{mandatory}) { 1358 if (exists $v->{meta}{mandatory}) {
1308 warn $msg; 1359 warn $msg;
1309 warn "mandatory extension failed to load, exiting.\n"; 1360 cf::cleanup "mandatory extension failed to load, exiting.";
1310 exit 1;
1311 } 1361 }
1312 1362
1313 warn $msg; 1363 warn $msg;
1314 } 1364 }
1315 1365
… …
1725our $MAX_RESET = 3600; 1775our $MAX_RESET = 3600;
1726our $DEFAULT_RESET = 3000; 1776our $DEFAULT_RESET = 3000;
1727 1777
1728sub generate_random_map { 1778sub generate_random_map {
1729 my ($self, $rmp) = @_; 1779 my ($self, $rmp) = @_;
1780
1781 my $lock = cf::lock_acquire "generate_random_map"; # the random map generator is NOT reentrant ATM
1782
1730 # mit "rum" bekleckern, nicht 1783 # mit "rum" bekleckern, nicht
1731 $self->_create_random_map ( 1784 $self->_create_random_map (
1732 $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle}, 1785 $rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
1733 $rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle}, 1786 $rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
1734 $rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map}, 1787 $rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
… …
2326 ? normalise $_ 2379 ? normalise $_
2327 : () 2380 : ()
2328 } @{ aio_readdir $UNIQUEDIR or [] } 2381 } @{ aio_readdir $UNIQUEDIR or [] }
2329 ] 2382 ]
2330} 2383}
2331
2332package cf;
2333 2384
2334=back 2385=back
2335 2386
2336=head3 cf::object 2387=head3 cf::object
2337 2388
… …
3308sub reload_config { 3359sub reload_config {
3309 open my $fh, "<:utf8", "$CONFDIR/config" 3360 open my $fh, "<:utf8", "$CONFDIR/config"
3310 or return; 3361 or return;
3311 3362
3312 local $/; 3363 local $/;
3313 *CFG = YAML::Syck::Load <$fh>; 3364 *CFG = YAML::Load <$fh>;
3314 3365
3315 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37]; 3366 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
3316 3367
3317 $cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset}; 3368 $cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
3318 $cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset}; 3369 $cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
… …
3338 3389
3339 reload_config; 3390 reload_config;
3340 db_init; 3391 db_init;
3341 load_extensions; 3392 load_extensions;
3342 3393
3343 $TICK_WATCHER->start;
3344 $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority 3394 $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
3395 evthread_start IO::AIO::poll_fileno;
3345 EV::loop; 3396 EV::loop;
3346} 3397}
3347 3398
3348############################################################################# 3399#############################################################################
3349# initialisation and cleanup 3400# initialisation and cleanup
… …
3356 cf::cleanup "SIG$signal"; 3407 cf::cleanup "SIG$signal";
3357 }; 3408 };
3358 } 3409 }
3359} 3410}
3360 3411
3361sub write_runtime { 3412sub write_runtime_sync {
3362 my $runtime = "$LOCALDIR/runtime"; 3413 my $runtime = "$LOCALDIR/runtime";
3363 3414
3364 # first touch the runtime file to show we are still running: 3415 # first touch the runtime file to show we are still running:
3365 # the fsync below can take a very very long time. 3416 # the fsync below can take a very very long time.
3366 3417
… …
3392 and return; 3443 and return;
3393 3444
3394 warn "runtime file written.\n"; 3445 warn "runtime file written.\n";
3395 3446
3396 1 3447 1
3448}
3449
3450our $uuid_lock;
3451our $uuid_skip;
3452
3453sub write_uuid_sync($) {
3454 $uuid_skip ||= $_[0];
3455
3456 return if $uuid_lock;
3457 local $uuid_lock = 1;
3458
3459 my $uuid = "$LOCALDIR/uuid";
3460
3461 my $fh = aio_open "$uuid~", O_WRONLY | O_CREAT, 0644
3462 or return;
3463
3464 my $value = uuid_str $uuid_skip + uuid_seq uuid_cur;
3465 $uuid_skip = 0;
3466
3467 (aio_write $fh, 0, (length $value), $value, 0) <= 0
3468 and return;
3469
3470 # always fsync - this file is important
3471 aio_fsync $fh
3472 and return;
3473
3474 close $fh
3475 or return;
3476
3477 aio_rename "$uuid~", $uuid
3478 and return;
3479
3480 warn "uuid file written ($value).\n";
3481
3482 1
3483
3484}
3485
3486sub write_uuid($$) {
3487 my ($skip, $sync) = @_;
3488
3489 $sync ? write_uuid_sync $skip
3490 : async { write_uuid_sync $skip };
3397} 3491}
3398 3492
3399sub emergency_save() { 3493sub emergency_save() {
3400 my $freeze_guard = cf::freeze_mainloop; 3494 my $freeze_guard = cf::freeze_mainloop;
3401 3495
… …
3423 warn "end emergency map save\n"; 3517 warn "end emergency map save\n";
3424 3518
3425 warn "begin emergency database checkpoint\n"; 3519 warn "begin emergency database checkpoint\n";
3426 BDB::db_env_txn_checkpoint $DB_ENV; 3520 BDB::db_env_txn_checkpoint $DB_ENV;
3427 warn "end emergency database checkpoint\n"; 3521 warn "end emergency database checkpoint\n";
3522
3523 warn "begin write uuid\n";
3524 write_uuid_sync 1;
3525 warn "end write uuid\n";
3428 }; 3526 };
3429 3527
3430 warn "leave emergency perl save\n"; 3528 warn "leave emergency perl save\n";
3431} 3529}
3432 3530
… …
3447 warn "reloading..."; 3545 warn "reloading...";
3448 3546
3449 warn "entering sync_job"; 3547 warn "entering sync_job";
3450 3548
3451 cf::sync_job { 3549 cf::sync_job {
3452 cf::write_runtime; # external watchdog should not bark 3550 cf::write_runtime_sync; # external watchdog should not bark
3453 cf::emergency_save; 3551 cf::emergency_save;
3454 cf::write_runtime; # external watchdog should not bark 3552 cf::write_runtime_sync; # external watchdog should not bark
3455 3553
3456 warn "syncing database to disk"; 3554 warn "syncing database to disk";
3457 BDB::db_env_txn_checkpoint $DB_ENV; 3555 BDB::db_env_txn_checkpoint $DB_ENV;
3458 3556
3459 # if anything goes wrong in here, we should simply crash as we already saved 3557 # if anything goes wrong in here, we should simply crash as we already saved
… …
3546 warn "leaving sync_job"; 3644 warn "leaving sync_job";
3547 3645
3548 1 3646 1
3549 } or do { 3647 } or do {
3550 warn $@; 3648 warn $@;
3551 warn "error while reloading, exiting."; 3649 cf::cleanup "error while reloading, exiting.";
3552 exit 1;
3553 }; 3650 };
3554 3651
3555 warn "reloaded"; 3652 warn "reloaded";
3556}; 3653};
3557 3654
… …
3560sub reload_perl() { 3657sub reload_perl() {
3561 # doing reload synchronously and two reloads happen back-to-back, 3658 # doing reload synchronously and two reloads happen back-to-back,
3562 # coro crashes during coro_state_free->destroy here. 3659 # coro crashes during coro_state_free->destroy here.
3563 3660
3564 $RELOAD_WATCHER ||= EV::timer 0, 0, sub { 3661 $RELOAD_WATCHER ||= EV::timer 0, 0, sub {
3662 do_reload_perl;
3565 undef $RELOAD_WATCHER; 3663 undef $RELOAD_WATCHER;
3566 do_reload_perl;
3567 }; 3664 };
3568} 3665}
3569 3666
3570register_command "reload" => sub { 3667register_command "reload" => sub {
3571 my ($who, $arg) = @_; 3668 my ($who, $arg) = @_;
… …
3585 3682
3586our @WAIT_FOR_TICK; 3683our @WAIT_FOR_TICK;
3587our @WAIT_FOR_TICK_BEGIN; 3684our @WAIT_FOR_TICK_BEGIN;
3588 3685
3589sub wait_for_tick { 3686sub wait_for_tick {
3590 return unless $TICK_WATCHER->is_active; 3687 return if tick_inhibit;
3591 return if $Coro::current == $Coro::main; 3688 return if $Coro::current == $Coro::main;
3592 3689
3593 my $signal = new Coro::Signal; 3690 my $signal = new Coro::Signal;
3594 push @WAIT_FOR_TICK, $signal; 3691 push @WAIT_FOR_TICK, $signal;
3595 $signal->wait; 3692 $signal->wait;
3596} 3693}
3597 3694
3598sub wait_for_tick_begin { 3695sub wait_for_tick_begin {
3599 return unless $TICK_WATCHER->is_active; 3696 return if tick_inhibit;
3600 return if $Coro::current == $Coro::main; 3697 return if $Coro::current == $Coro::main;
3601 3698
3602 my $signal = new Coro::Signal; 3699 my $signal = new Coro::Signal;
3603 push @WAIT_FOR_TICK_BEGIN, $signal; 3700 push @WAIT_FOR_TICK_BEGIN, $signal;
3604 $signal->wait; 3701 $signal->wait;
3605} 3702}
3606 3703
3607$TICK_WATCHER = EV::periodic_ns 0, $TICK, 0, sub { 3704sub tick {
3608 if ($Coro::current != $Coro::main) { 3705 if ($Coro::current != $Coro::main) {
3609 Carp::cluck "major BUG: server tick called outside of main coro, skipping it" 3706 Carp::cluck "major BUG: server tick called outside of main coro, skipping it"
3610 unless ++$bug_warning > 10; 3707 unless ++$bug_warning > 10;
3611 return; 3708 return;
3612 } 3709 }
3613 3710
3614 $NOW = $tick_start = EV::now;
3615
3616 cf::server_tick; # one server iteration 3711 cf::server_tick; # one server iteration
3617
3618 $RUNTIME += $TICK;
3619 $NEXT_TICK = $_[0]->at;
3620 3712
3621 if ($NOW >= $NEXT_RUNTIME_WRITE) { 3713 if ($NOW >= $NEXT_RUNTIME_WRITE) {
3622 $NEXT_RUNTIME_WRITE = List::Util::max $NEXT_RUNTIME_WRITE + 10, $NOW + 5.; 3714 $NEXT_RUNTIME_WRITE = List::Util::max $NEXT_RUNTIME_WRITE + 10, $NOW + 5.;
3623 Coro::async_pool { 3715 Coro::async_pool {
3624 $Coro::current->{desc} = "runtime saver"; 3716 $Coro::current->{desc} = "runtime saver";
3625 write_runtime 3717 write_runtime_sync
3626 or warn "ERROR: unable to write runtime file: $!"; 3718 or warn "ERROR: unable to write runtime file: $!";
3627 }; 3719 };
3628 } 3720 }
3629 3721
3630 if (my $sig = shift @WAIT_FOR_TICK_BEGIN) { 3722 if (my $sig = shift @WAIT_FOR_TICK_BEGIN) {
… …
3632 } 3724 }
3633 while (my $sig = shift @WAIT_FOR_TICK) { 3725 while (my $sig = shift @WAIT_FOR_TICK) {
3634 $sig->send; 3726 $sig->send;
3635 } 3727 }
3636 3728
3637 $LOAD = ($NOW - $tick_start) / $TICK; 3729 $LOAD = ($NOW - $TICK_START) / $TICK;
3638 $LOADAVG = $LOADAVG * 0.75 + $LOAD * 0.25; 3730 $LOADAVG = $LOADAVG * 0.75 + $LOAD * 0.25;
3639 3731
3640 _post_tick; 3732 if (0) {
3641}; 3733 if ($NEXT_TICK) {
3642$TICK_WATCHER->priority (EV::MAXPRI); 3734 my $jitter = $TICK_START - $NEXT_TICK;
3735 $JITTER = $JITTER * 0.75 + $jitter * 0.25;
3736 warn "jitter $JITTER\n";#d#
3737 }
3738 }
3739}
3643 3740
3644{ 3741{
3645 # configure BDB 3742 # configure BDB
3646 3743
3647 BDB::min_parallel 8; 3744 BDB::min_parallel 8;

Diff Legend

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