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.429 by root, Sat May 3 15:17:13 2008 UTC vs.
Revision 1.441 by root, Sat Aug 30 05:19:03 2008 UTC

… …
19# The authors can be reached via e-mail to <support@deliantra.net> 19# The authors can be reached via e-mail to <support@deliantra.net>
20# 20#
21 21
22package cf; 22package cf;
23 23
24use 5.10.0;
24use utf8; 25use utf8;
25use strict; 26use strict "vars", "subs";
26 27
27use Symbol; 28use Symbol;
28use List::Util; 29use List::Util;
29use Socket; 30use Socket;
30use EV 3.2; 31use EV;
31use Opcode; 32use Opcode;
32use Safe; 33use Safe;
33use Safe::Hole; 34use Safe::Hole;
34use Storable (); 35use Storable ();
35 36
36use Coro 4.50 (); 37use Coro ();
37use Coro::State; 38use Coro::State;
38use Coro::Handle; 39use Coro::Handle;
39use Coro::EV; 40use Coro::EV;
41use Coro::AnyEvent;
40use Coro::Timer; 42use Coro::Timer;
41use Coro::Signal; 43use Coro::Signal;
42use Coro::Semaphore; 44use Coro::Semaphore;
45use Coro::AnyEvent;
43use Coro::AIO; 46use Coro::AIO;
44use Coro::BDB; 47use Coro::BDB 1.6;
45use Coro::Storable; 48use Coro::Storable;
46use Coro::Util (); 49use Coro::Util ();
47 50
48use JSON::XS 2.01 (); 51use JSON::XS 2.01 ();
49use BDB (); 52use BDB ();
50use Data::Dumper; 53use Data::Dumper;
51use Digest::MD5; 54use Digest::MD5;
52use Fcntl; 55use Fcntl;
53use YAML (); 56use YAML ();
54use IO::AIO 2.51 (); 57use IO::AIO ();
55use Time::HiRes; 58use Time::HiRes;
56use Compress::LZF; 59use Compress::LZF;
57use Digest::MD5 (); 60use Digest::MD5 ();
61
62AnyEvent::detect;
58 63
59# configure various modules to our taste 64# configure various modules to our taste
60# 65#
61$Storable::canonical = 1; # reduce rsync transfers 66$Storable::canonical = 1; # reduce rsync transfers
62Coro::State::cctx_stacksize 256000; # 1-2MB stack, for deep recursions in maze generator 67Coro::State::cctx_stacksize 256000; # 1-2MB stack, for deep recursions in maze generator
… …
90our $RANDOMDIR = "$LOCALDIR/random"; 95our $RANDOMDIR = "$LOCALDIR/random";
91our $BDBDIR = "$LOCALDIR/db"; 96our $BDBDIR = "$LOCALDIR/db";
92our %RESOURCE; 97our %RESOURCE;
93 98
94our $TICK = MAX_TIME * 1e-6; # this is a CONSTANT(!) 99our $TICK = MAX_TIME * 1e-6; # this is a CONSTANT(!)
95our $AIO_POLL_WATCHER;
96our $NEXT_RUNTIME_WRITE; # when should the runtime file be written 100our $NEXT_RUNTIME_WRITE; # when should the runtime file be written
97our $NEXT_TICK; 101our $NEXT_TICK;
98our $USE_FSYNC = 1; # use fsync to write maps - default off 102our $USE_FSYNC = 1; # use fsync to write maps - default off
99 103
100our $BDB_POLL_WATCHER;
101our $BDB_DEADLOCK_WATCHER; 104our $BDB_DEADLOCK_WATCHER;
102our $BDB_CHECKPOINT_WATCHER; 105our $BDB_CHECKPOINT_WATCHER;
103our $BDB_TRICKLE_WATCHER; 106our $BDB_TRICKLE_WATCHER;
104our $DB_ENV; 107our $DB_ENV;
105 108
… …
242for my $pkg (qw( 245for my $pkg (qw(
243 cf::global cf::attachable 246 cf::global cf::attachable
244 cf::object cf::object::player 247 cf::object cf::object::player
245 cf::client cf::player 248 cf::client cf::player
246 cf::arch cf::living 249 cf::arch cf::living
250 cf::map cf::mapspace
247 cf::map cf::party cf::region 251 cf::party cf::region
248)) { 252)) {
249 no strict 'refs';
250 @{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg; 253 @{"safe::$pkg\::wrap::ISA"} = @{"$pkg\::wrap::ISA"} = $pkg;
251} 254}
252 255
253$EV::DIED = sub { 256$EV::DIED = sub {
254 warn "error in event callback: @_"; 257 warn "error in event callback: @_";
… …
1085 1088
1086sub reattach { 1089sub reattach {
1087 # basically do the same as instantiate, without calling instantiate 1090 # basically do the same as instantiate, without calling instantiate
1088 my ($obj) = @_; 1091 my ($obj) = @_;
1089 1092
1093 # no longer needed after getting rid of delete_package?
1090 bless $obj, ref $obj; # re-bless in case extensions have been reloaded 1094 #bless $obj, ref $obj; # re-bless in case extensions have been reloaded
1091 1095
1092 my $registry = $obj->registry; 1096 my $registry = $obj->registry;
1093 1097
1094 @$registry = (); 1098 @$registry = ();
1095 1099
… …
1331 1335
1332 $ext{meta} = { map { (split /=/, $_, 2)[0, 1] } split /\s+/, $1 } 1336 $ext{meta} = { map { (split /=/, $_, 2)[0, 1] } split /\s+/, $1 }
1333 if $source =~ /\A#!.*?perl.*?#\s*(.*)$/m; 1337 if $source =~ /\A#!.*?perl.*?#\s*(.*)$/m;
1334 1338
1335 $ext{source} = 1339 $ext{source} =
1336 "package $pkg; use strict; use utf8;\n" 1340 "package $pkg; use 5.10.0; use strict 'vars', 'subs'; use utf8;\n"
1337 . "#line 1 \"$path\"\n{\n" 1341 . "#line 1 \"$path\"\n{\n"
1338 . $source 1342 . $source
1339 . "\n};\n1"; 1343 . "\n};\n1";
1340 1344
1341 $todo{$base} = \%ext; 1345 $todo{$base} = \%ext;
… …
1523 $pl->{deny_save} = 1; 1527 $pl->{deny_save} = 1;
1524 $pl->password ("*"); # this should lock out the player until we nuked the dir 1528 $pl->password ("*"); # this should lock out the player until we nuked the dir
1525 1529
1526 $pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active; 1530 $pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active;
1527 $pl->deactivate; 1531 $pl->deactivate;
1532 my $killer = cf::arch::get "killer_quit"; $pl->killer ($killer); $killer->destroy;
1533 $pl->ob->check_score;
1528 $pl->invoke (cf::EVENT_PLAYER_QUIT); 1534 $pl->invoke (cf::EVENT_PLAYER_QUIT);
1529 $pl->ns->destroy if $pl->ns; 1535 $pl->ns->destroy if $pl->ns;
1530 1536
1531 my $path = playerdir $pl; 1537 my $path = playerdir $pl;
1532 my $temp = "$path~$cf::RUNTIME~deleting~"; 1538 my $temp = "$path~$cf::RUNTIME~deleting~";
… …
2083 my $f = new_from_file cf::object::thawer $self->{load_path}; 2089 my $f = new_from_file cf::object::thawer $self->{load_path};
2084 $f->skip_block; 2090 $f->skip_block;
2085 $self->_load_objects ($f) 2091 $self->_load_objects ($f)
2086 or return; 2092 or return;
2087 2093
2088 $self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1) 2094 $self->post_load_original
2089 if delete $self->{load_original}; 2095 if delete $self->{load_original};
2090 2096
2091 if (my $uniq = $self->uniq_path) { 2097 if (my $uniq = $self->uniq_path) {
2092 utf8::encode $uniq; 2098 utf8::encode $uniq;
2093 unless (aio_stat $uniq) { 2099 unless (aio_stat $uniq) {
… …
2611her, loading and preparing them map, calling the provided $check callback 2617her, loading and preparing them map, calling the provided $check callback
2612that has to return the map if sucecssful, and then unfreezes the player on 2618that has to return the map if sucecssful, and then unfreezes the player on
2613the new (success) or old (failed) map position. In either case, $done will 2619the new (success) or old (failed) map position. In either case, $done will
2614be called at the end of this process. 2620be called at the end of this process.
2615 2621
2622Note that $check will be called with a potentially non-loaded map, so if
2623it needs a loaded map it has to call C<< ->load >>.
2624
2616=cut 2625=cut
2617 2626
2618our $GOTOGEN; 2627our $GOTOGEN;
2619 2628
2620sub cf::object::player::goto { 2629sub cf::object::player::goto {
… …
2698} 2707}
2699 2708
2700sub prepare_random_map { 2709sub prepare_random_map {
2701 my ($exit) = @_; 2710 my ($exit) = @_;
2702 2711
2703 my $guard = cf::lock_acquire "exit_prepare:$exit";
2704
2705 # all this does is basically replace the /! path by 2712 # all this does is basically replace the /! path by
2706 # a new random map path (?random/...) with a seed 2713 # a new random map path (?random/...) with a seed
2707 # that depends on the exit object 2714 # that depends on the exit object
2708 2715
2709 my $rmp = parse_random_map_params $exit->msg; 2716 my $rmp = parse_random_map_params $exit->msg;
… …
2711 if ($exit->map) { 2718 if ($exit->map) {
2712 $rmp->{region} = $exit->region->name; 2719 $rmp->{region} = $exit->region->name;
2713 $rmp->{origin_map} = $exit->map->path; 2720 $rmp->{origin_map} = $exit->map->path;
2714 $rmp->{origin_x} = $exit->x; 2721 $rmp->{origin_x} = $exit->x;
2715 $rmp->{origin_y} = $exit->y; 2722 $rmp->{origin_y} = $exit->y;
2723
2724 $exit->map->touch;
2716 } 2725 }
2717 2726
2718 $rmp->{random_seed} ||= $exit->random_seed; 2727 $rmp->{random_seed} ||= $exit->random_seed;
2719 2728
2720 my $data = JSON::XS->new->utf8->pretty->canonical->encode ($rmp); 2729 my $data = JSON::XS->new->utf8->pretty->canonical->encode ($rmp);
… …
2724 if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) { 2733 if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) {
2725 aio_write $fh, 0, (length $data), $data, 0; 2734 aio_write $fh, 0, (length $data), $data, 0;
2726 undef $fh; 2735 undef $fh;
2727 aio_rename "$meta~", $meta; 2736 aio_rename "$meta~", $meta;
2728 2737
2738 my $slaying = "?random/$md5";
2739
2740 if ($exit->valid) {
2729 $exit->slaying ("?random/$md5"); 2741 $exit->slaying ("?random/$md5");
2730 $exit->msg (undef); 2742 $exit->msg (undef);
2743 }
2731 } 2744 }
2732} 2745}
2733 2746
2734sub cf::object::player::enter_exit { 2747sub cf::object::player::enter_exit {
2735 my ($self, $exit) = @_; 2748 my ($self, $exit) = @_;
2736 2749
2737 return unless $self->type == cf::PLAYER; 2750 return unless $self->type == cf::PLAYER;
2738 2751
2739 if ($exit->slaying eq "/!") {
2740 #TODO: this should de-fi-ni-te-ly not be a sync-job
2741 # the problem is that $exit might not survive long enough
2742 # so it needs to be done right now, right here
2743 cf::sync_job { prepare_random_map $exit };
2744 }
2745
2746 my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
2747 my $hp = $exit->stats->hp;
2748 my $sp = $exit->stats->sp;
2749
2750 $self->enter_link; 2752 $self->enter_link;
2751 2753
2752 # if exit is damned, update players death & WoR home-position
2753 $self->contr->savebed ($slaying, $hp, $sp)
2754 if $exit->flag (FLAG_DAMNED);
2755
2756 (async { 2754 (async {
2757 $Coro::current->{desc} = "enter_exit $slaying $hp $sp"; 2755 $Coro::current->{desc} = "enter_exit";
2758 2756
2759 $self->deactivate_recursive; # just to be sure
2760 unless (eval { 2757 unless (eval {
2758 $self->deactivate_recursive; # just to be sure
2759
2760 # random map handling
2761 {
2762 my $guard = cf::lock_acquire "exit_prepare:$exit";
2763
2764 prepare_random_map $exit
2765 if $exit->slaying eq "/!";
2766 }
2767
2768 my $map = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
2769 my $x = $exit->stats->hp;
2770 my $y = $exit->stats->sp;
2771
2761 $self->goto ($slaying, $hp, $sp); 2772 $self->goto ($map, $x, $y);
2762 2773
2774 # if exit is damned, update players death & WoR home-position
2775 $self->contr->savebed ($map, $x, $y)
2776 if $exit->flag (cf::FLAG_DAMNED);
2777
2763 1; 2778 1
2764 }) { 2779 }) {
2765 $self->message ("Something went wrong deep within the crossfire server. " 2780 $self->message ("Something went wrong deep within the crossfire server. "
2766 . "I'll try to bring you back to the map you were before. " 2781 . "I'll try to bring you back to the map you were before. "
2767 . "Please report this to the dungeon master!", 2782 . "Please report this to the dungeon master!",
2768 cf::NDI_UNIQUE | cf::NDI_RED); 2783 cf::NDI_UNIQUE | cf::NDI_RED);
… …
3115 3130
3116=cut 3131=cut
3117 3132
3118for ( 3133for (
3119 ["cf::object" => qw(contr pay_amount pay_player map force_find force_add x y 3134 ["cf::object" => qw(contr pay_amount pay_player map force_find force_add x y
3120 insert remove inv name archname title slaying race 3135 insert remove inv nrof name archname title slaying race
3121 decrease split destroy)], 3136 decrease split destroy change_exp)],
3122 ["cf::object::player" => qw(player)], 3137 ["cf::object::player" => qw(player)],
3123 ["cf::player" => qw(peaceful)], 3138 ["cf::player" => qw(peaceful)],
3124 ["cf::map" => qw(trigger)], 3139 ["cf::map" => qw(trigger)],
3125) { 3140) {
3126 no strict 'refs'; 3141 no strict 'refs';
… …
3386 warn "finished reloading resource files\n"; 3401 warn "finished reloading resource files\n";
3387} 3402}
3388 3403
3389sub init { 3404sub init {
3390 my $guard = freeze_mainloop; 3405 my $guard = freeze_mainloop;
3406
3407 evthread_start IO::AIO::poll_fileno;
3391 3408
3392 reload_resources; 3409 reload_resources;
3393} 3410}
3394 3411
3395sub reload_config { 3412sub reload_config {
… …
3428 reload_config; 3445 reload_config;
3429 db_init; 3446 db_init;
3430 load_extensions; 3447 load_extensions;
3431 3448
3432 $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority 3449 $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
3433 evthread_start IO::AIO::poll_fileno;
3434 } 3450 }
3435 3451
3436 EV::loop; 3452 EV::loop;
3437} 3453}
3438 3454
… …
3573 3589
3574 warn Carp::longmess "post_cleanup backtrace" 3590 warn Carp::longmess "post_cleanup backtrace"
3575 if $make_core; 3591 if $make_core;
3576} 3592}
3577 3593
3594# a safer delete_package, copied from Symbol
3595sub clear_package($) {
3596 my $pkg = shift;
3597
3598 # expand to full symbol table name if needed
3599 unless ($pkg =~ /^main::.*::$/) {
3600 $pkg = "main$pkg" if $pkg =~ /^::/;
3601 $pkg = "main::$pkg" unless $pkg =~ /^main::/;
3602 $pkg .= '::' unless $pkg =~ /::$/;
3603 }
3604
3605 my($stem, $leaf) = $pkg =~ m/(.*::)(\w+::)$/;
3606 my $stem_symtab = *{$stem}{HASH};
3607
3608 defined $stem_symtab and exists $stem_symtab->{$leaf}
3609 or return;
3610
3611 # clear all symbols
3612 my $leaf_symtab = *{$stem_symtab->{$leaf}}{HASH};
3613 for my $name (keys %$leaf_symtab) {
3614 _gv_clear *{"$pkg$name"};
3615# use PApp::Util; PApp::Util::sv_dump *{"$pkg$name"};
3616 }
3617 warn "cleared package #$pkg\n";#d#
3618}
3619
3620our $RELOAD; # how many times to reload
3621
3578sub do_reload_perl() { 3622sub do_reload_perl() {
3579 # can/must only be called in main 3623 # can/must only be called in main
3580 if ($Coro::current != $Coro::main) { 3624 if ($Coro::current != $Coro::main) {
3581 warn "can only reload from main coroutine"; 3625 warn "can only reload from main coroutine";
3582 return; 3626 return;
3583 } 3627 }
3584 3628
3629 return if $RELOAD++;
3630
3631 while ($RELOAD) {
3585 warn "reloading..."; 3632 warn "reloading...";
3586 3633
3587 warn "entering sync_job"; 3634 warn "entering sync_job";
3588 3635
3589 cf::sync_job { 3636 cf::sync_job {
3590 cf::write_runtime_sync; # external watchdog should not bark 3637 cf::write_runtime_sync; # external watchdog should not bark
3591 cf::emergency_save; 3638 cf::emergency_save;
3592 cf::write_runtime_sync; # external watchdog should not bark 3639 cf::write_runtime_sync; # external watchdog should not bark
3593 3640
3594 warn "syncing database to disk"; 3641 warn "syncing database to disk";
3595 BDB::db_env_txn_checkpoint $DB_ENV; 3642 BDB::db_env_txn_checkpoint $DB_ENV;
3596 3643
3597 # if anything goes wrong in here, we should simply crash as we already saved 3644 # if anything goes wrong in here, we should simply crash as we already saved
3598 3645
3599 warn "flushing outstanding aio requests"; 3646 warn "flushing outstanding aio requests";
3600 for (;;) {
3601 BDB::flush;
3602 IO::AIO::flush;
3603 Coro::cede_notself;
3604 last unless IO::AIO::nreqs || BDB::nreqs; 3647 while (IO::AIO::nreqs || BDB::nreqs) {
3605 warn "iterate..."; 3648 Coro::EV::timer_once 0.01; # let the sync_job do it's thing
3606 }
3607
3608 ++$RELOAD;
3609
3610 warn "cancelling all extension coros";
3611 $_->cancel for values %EXT_CORO;
3612 %EXT_CORO = ();
3613
3614 warn "removing commands";
3615 %COMMAND = ();
3616
3617 warn "removing ext/exti commands";
3618 %EXTCMD = ();
3619 %EXTICMD = ();
3620
3621 warn "unloading/nuking all extensions";
3622 for my $pkg (@EXTS) {
3623 warn "... unloading $pkg";
3624
3625 if (my $cb = $pkg->can ("unload")) {
3626 eval {
3627 $cb->($pkg);
3628 1
3629 } or warn "$pkg unloaded, but with errors: $@";
3630 } 3649 }
3631 3650
3632 warn "... nuking $pkg"; 3651 warn "cancelling all extension coros";
3633 Symbol::delete_package $pkg; 3652 $_->cancel for values %EXT_CORO;
3634 } 3653 %EXT_CORO = ();
3635 3654
3636 warn "unloading all perl modules loaded from $LIBDIR"; 3655 warn "removing commands";
3637 while (my ($k, $v) = each %INC) { 3656 %COMMAND = ();
3638 next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
3639 3657
3658 warn "removing ext/exti commands";
3659 %EXTCMD = ();
3660 %EXTICMD = ();
3661
3662 warn "unloading/nuking all extensions";
3663 for my $pkg (@EXTS) {
3640 warn "... unloading $k"; 3664 warn "... unloading $pkg";
3641 delete $INC{$k};
3642 3665
3643 $k =~ s/\.pm$//;
3644 $k =~ s/\//::/g;
3645
3646 if (my $cb = $k->can ("unload_module")) { 3666 if (my $cb = $pkg->can ("unload")) {
3667 eval {
3647 $cb->(); 3668 $cb->($pkg);
3669 1
3670 } or warn "$pkg unloaded, but with errors: $@";
3671 }
3672
3673 warn "... clearing $pkg";
3674 clear_package $pkg;
3648 } 3675 }
3649 3676
3650 Symbol::delete_package $k; 3677 warn "unloading all perl modules loaded from $LIBDIR";
3678 while (my ($k, $v) = each %INC) {
3679 next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
3680
3681 warn "... unloading $k";
3682 delete $INC{$k};
3683
3684 $k =~ s/\.pm$//;
3685 $k =~ s/\//::/g;
3686
3687 if (my $cb = $k->can ("unload_module")) {
3688 $cb->();
3689 }
3690
3691 clear_package $k;
3651 } 3692 }
3652 3693
3653 warn "getting rid of safe::, as good as possible"; 3694 warn "getting rid of safe::, as good as possible";
3654 Symbol::delete_package "safe::$_" 3695 clear_package "safe::$_"
3655 for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region); 3696 for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
3656 3697
3657 warn "unloading cf.pm \"a bit\""; 3698 warn "unloading cf.pm \"a bit\"";
3658 delete $INC{"cf.pm"}; 3699 delete $INC{"cf.pm"};
3659 delete $INC{"cf/pod.pm"}; 3700 delete $INC{"cf/pod.pm"};
3660 3701
3661 # don't, removes xs symbols, too, 3702 # don't, removes xs symbols, too,
3662 # and global variables created in xs 3703 # and global variables created in xs
3663 #Symbol::delete_package __PACKAGE__; 3704 #clear_package __PACKAGE__;
3664 3705
3665 warn "unload completed, starting to reload now"; 3706 warn "unload completed, starting to reload now";
3666 3707
3667 warn "reloading cf.pm"; 3708 warn "reloading cf.pm";
3668 require cf; 3709 require cf;
3669 cf::_connect_to_perl; # nominally unnecessary, but cannot hurt 3710 cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
3670 3711
3671 warn "loading config and database again"; 3712 warn "loading config and database again";
3672 cf::reload_config; 3713 cf::reload_config;
3673 3714
3674 warn "loading extensions"; 3715 warn "loading extensions";
3675 cf::load_extensions; 3716 cf::load_extensions;
3676 3717
3677 warn "reattaching attachments to objects/players"; 3718 warn "reattaching attachments to objects/players";
3678 _global_reattach; # objects, sockets 3719 _global_reattach; # objects, sockets
3679 warn "reattaching attachments to maps"; 3720 warn "reattaching attachments to maps";
3680 reattach $_ for values %MAP; 3721 reattach $_ for values %MAP;
3681 warn "reattaching attachments to players"; 3722 warn "reattaching attachments to players";
3682 reattach $_ for values %PLAYER; 3723 reattach $_ for values %PLAYER;
3683 3724
3684 warn "leaving sync_job"; 3725 warn "leaving sync_job";
3685 3726
3686 1 3727 1
3687 } or do { 3728 } or do {
3688 warn $@; 3729 warn $@;
3689 cf::cleanup "error while reloading, exiting."; 3730 cf::cleanup "error while reloading, exiting.";
3690 }; 3731 };
3691 3732
3692 warn "reloaded"; 3733 warn "reloaded";
3734 --$RELOAD;
3735 }
3693}; 3736};
3694 3737
3695our $RELOAD_WATCHER; # used only during reload 3738our $RELOAD_WATCHER; # used only during reload
3696 3739
3697sub reload_perl() { 3740sub reload_perl() {
… …
3779{ 3822{
3780 # configure BDB 3823 # configure BDB
3781 3824
3782 BDB::min_parallel 8; 3825 BDB::min_parallel 8;
3783 BDB::max_poll_reqs $TICK * 0.1; 3826 BDB::max_poll_reqs $TICK * 0.1;
3784 $Coro::BDB::WATCHER->priority (1); 3827 $AnyEvent::BDB::WATCHER->priority (1);
3785 3828
3786 unless ($DB_ENV) { 3829 unless ($DB_ENV) {
3787 $DB_ENV = BDB::db_env_create; 3830 $DB_ENV = BDB::db_env_create;
3788 $DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT | BDB::TXN_NOSYNC 3831 $DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT);
3789 | BDB::LOG_AUTOREMOVE, 1); 3832 $DB_ENV->set_flags (&BDB::LOG_AUTOREMOVE ) if BDB::VERSION v0, v4.7;
3833 $DB_ENV->log_set_config (&BDB::LOG_AUTO_REMOVE) if BDB::VERSION v4.7;
3790 $DB_ENV->set_timeout (30, BDB::SET_TXN_TIMEOUT); 3834 $DB_ENV->set_timeout (30, BDB::SET_TXN_TIMEOUT);
3791 $DB_ENV->set_timeout (30, BDB::SET_LOCK_TIMEOUT); 3835 $DB_ENV->set_timeout (30, BDB::SET_LOCK_TIMEOUT);
3792 3836
3793 cf::sync_job { 3837 cf::sync_job {
3794 eval { 3838 eval {
… …
3820{ 3864{
3821 # configure IO::AIO 3865 # configure IO::AIO
3822 3866
3823 IO::AIO::min_parallel 8; 3867 IO::AIO::min_parallel 8;
3824 IO::AIO::max_poll_time $TICK * 0.1; 3868 IO::AIO::max_poll_time $TICK * 0.1;
3825 $Coro::AIO::WATCHER->priority (1); 3869 undef $AnyEvent::AIO::WATCHER;
3826} 3870}
3827 3871
3828my $_log_backtrace; 3872my $_log_backtrace;
3829 3873
3830sub _log_backtrace { 3874sub _log_backtrace {

Diff Legend

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