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.421 by root, Tue Apr 15 18:43:11 2008 UTC vs.
Revision 1.435 by root, Thu May 29 03:33:20 2008 UTC

… …
25use strict; 25use strict;
26 26
27use Symbol; 27use Symbol;
28use List::Util; 28use List::Util;
29use Socket; 29use Socket;
30use EV 3.2; 30use EV;
31use Opcode; 31use Opcode;
32use Safe; 32use Safe;
33use Safe::Hole; 33use Safe::Hole;
34use Storable (); 34use Storable ();
35 35
36use Coro 4.50 (); 36use Coro ();
37use Coro::State; 37use Coro::State;
38use Coro::Handle; 38use Coro::Handle;
39use Coro::EV; 39use Coro::AnyEvent;
40use Coro::Timer; 40use Coro::Timer;
41use Coro::Signal; 41use Coro::Signal;
42use Coro::Semaphore; 42use Coro::Semaphore;
43use Coro::AnyEvent;
43use Coro::AIO; 44use Coro::AIO;
44use Coro::BDB; 45use Coro::BDB;
45use Coro::Storable; 46use Coro::Storable;
46use Coro::Util (); 47use Coro::Util ();
47 48
… …
49use BDB (); 50use BDB ();
50use Data::Dumper; 51use Data::Dumper;
51use Digest::MD5; 52use Digest::MD5;
52use Fcntl; 53use Fcntl;
53use YAML (); 54use YAML ();
54use IO::AIO 2.51 (); 55use IO::AIO ();
55use Time::HiRes; 56use Time::HiRes;
56use Compress::LZF; 57use Compress::LZF;
57use Digest::MD5 (); 58use Digest::MD5 ();
59
60AnyEvent::detect;
58 61
59# configure various modules to our taste 62# configure various modules to our taste
60# 63#
61$Storable::canonical = 1; # reduce rsync transfers 64$Storable::canonical = 1; # reduce rsync transfers
62Coro::State::cctx_stacksize 256000; # 1-2MB stack, for deep recursions in maze generator 65Coro::State::cctx_stacksize 256000; # 1-2MB stack, for deep recursions in maze generator
… …
90our $RANDOMDIR = "$LOCALDIR/random"; 93our $RANDOMDIR = "$LOCALDIR/random";
91our $BDBDIR = "$LOCALDIR/db"; 94our $BDBDIR = "$LOCALDIR/db";
92our %RESOURCE; 95our %RESOURCE;
93 96
94our $TICK = MAX_TIME * 1e-6; # this is a CONSTANT(!) 97our $TICK = MAX_TIME * 1e-6; # this is a CONSTANT(!)
95our $AIO_POLL_WATCHER;
96our $NEXT_RUNTIME_WRITE; # when should the runtime file be written 98our $NEXT_RUNTIME_WRITE; # when should the runtime file be written
97our $NEXT_TICK; 99our $NEXT_TICK;
98our $USE_FSYNC = 1; # use fsync to write maps - default off 100our $USE_FSYNC = 1; # use fsync to write maps - default off
99 101
100our $BDB_POLL_WATCHER;
101our $BDB_DEADLOCK_WATCHER; 102our $BDB_DEADLOCK_WATCHER;
102our $BDB_CHECKPOINT_WATCHER; 103our $BDB_CHECKPOINT_WATCHER;
103our $BDB_TRICKLE_WATCHER; 104our $BDB_TRICKLE_WATCHER;
104our $DB_ENV; 105our $DB_ENV;
105 106
… …
427 } 428 }
428 } 429 }
429}; 430};
430 431
431sub get_slot($;$$) { 432sub get_slot($;$$) {
432 return if tick_inhibit; 433 return if tick_inhibit || $Coro::current == $Coro::main;
433 434
434 my ($time, $pri, $name) = @_; 435 my ($time, $pri, $name) = @_;
435 436
436 $time = $TICK * .6 if $time > $TICK * .6; 437 $time = $TICK * .6 if $time > $TICK * .6;
437 my $sig = new Coro::Signal; 438 my $sig = new Coro::Signal;
… …
1141 utf8::decode (my $decname = $filename); 1142 utf8::decode (my $decname = $filename);
1142 warn sprintf "saving %s (%d,%d)\n", 1143 warn sprintf "saving %s (%d,%d)\n",
1143 $decname, length $$rdata, scalar @$objs; 1144 $decname, length $$rdata, scalar @$objs;
1144 1145
1145 if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) { 1146 if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {
1146 chmod SAVE_MODE, $fh; 1147 aio_chmod $fh, SAVE_MODE;
1147 aio_write $fh, 0, (length $$rdata), $$rdata, 0; 1148 aio_write $fh, 0, (length $$rdata), $$rdata, 0;
1148 aio_fsync $fh if $cf::USE_FSYNC; 1149 aio_fsync $fh if $cf::USE_FSYNC;
1149 close $fh; 1150 aio_close $fh;
1150 1151
1151 if (@$objs) { 1152 if (@$objs) {
1152 if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) { 1153 if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
1153 chmod SAVE_MODE, $fh; 1154 aio_chmod $fh, SAVE_MODE;
1154 my $data = Coro::Storable::nfreeze { version => 1, objs => $objs }; 1155 my $data = Coro::Storable::nfreeze { version => 1, objs => $objs };
1155 aio_write $fh, 0, (length $data), $data, 0; 1156 aio_write $fh, 0, (length $data), $data, 0;
1156 aio_fsync $fh if $cf::USE_FSYNC; 1157 aio_fsync $fh if $cf::USE_FSYNC;
1157 close $fh; 1158 aio_close $fh;
1158 aio_rename "$filename.pst~", "$filename.pst"; 1159 aio_rename "$filename.pst~", "$filename.pst";
1159 } 1160 }
1160 } else { 1161 } else {
1161 aio_unlink "$filename.pst"; 1162 aio_unlink "$filename.pst";
1162 } 1163 }
… …
1456 my $f = new_from_file cf::object::thawer path $login 1457 my $f = new_from_file cf::object::thawer path $login
1457 or return; 1458 or return;
1458 1459
1459 my $pl = cf::player::load_pl $f 1460 my $pl = cf::player::load_pl $f
1460 or return; 1461 or return;
1462
1461 local $cf::PLAYER_LOADING{$login} = $pl; 1463 local $cf::PLAYER_LOADING{$login} = $pl;
1462 $f->resolve_delayed_derefs; 1464 $f->resolve_delayed_derefs;
1463 $cf::PLAYER{$login} = $pl 1465 $cf::PLAYER{$login} = $pl
1464 } 1466 }
1465 } 1467 }
… …
1522 $pl->{deny_save} = 1; 1524 $pl->{deny_save} = 1;
1523 $pl->password ("*"); # this should lock out the player until we nuked the dir 1525 $pl->password ("*"); # this should lock out the player until we nuked the dir
1524 1526
1525 $pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active; 1527 $pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active;
1526 $pl->deactivate; 1528 $pl->deactivate;
1529 my $killer = cf::arch::get "killer_quit"; $pl->killer ($killer); $killer->destroy;
1530 $pl->ob->check_score;
1527 $pl->invoke (cf::EVENT_PLAYER_QUIT); 1531 $pl->invoke (cf::EVENT_PLAYER_QUIT);
1528 $pl->ns->destroy if $pl->ns; 1532 $pl->ns->destroy if $pl->ns;
1529 1533
1530 my $path = playerdir $pl; 1534 my $path = playerdir $pl;
1531 my $temp = "$path~$cf::RUNTIME~deleting~"; 1535 my $temp = "$path~$cf::RUNTIME~deleting~";
… …
1570 1574
1571 for my $login (@$dirs) { 1575 for my $login (@$dirs) {
1572 my $path = path $login; 1576 my $path = path $login;
1573 1577
1574 # a .pst is a dead give-away for a valid player 1578 # a .pst is a dead give-away for a valid player
1575 unless (-e "$path.pst") { 1579 # if no pst file found, open and chekc for blocked users
1580 if (aio_stat "$path.pst") {
1576 my $fh = aio_open $path, Fcntl::O_RDONLY, 0 or next; 1581 my $fh = aio_open $path, Fcntl::O_RDONLY, 0 or next;
1577 aio_read $fh, 0, 512, my $buf, 0 or next; 1582 aio_read $fh, 0, 512, my $buf, 0 or next;
1578 $buf !~ /^password -------------$/m or next; # official not-valid tag 1583 $buf !~ /^password -------------$/m or next; # official not-valid tag
1579 } 1584 }
1580 1585
… …
2029 2034
2030 cf::lock_wait "map_data:$path";#d#remove 2035 cf::lock_wait "map_data:$path";#d#remove
2031 cf::lock_wait "map_find:$path"; 2036 cf::lock_wait "map_find:$path";
2032 2037
2033 $cf::MAP{$path} || do { 2038 $cf::MAP{$path} || do {
2034 my $guard1 = cf::lock_acquire "map_find:$path";
2035 my $guard2 = cf::lock_acquire "map_data:$path"; # just for the fun of it 2039 my $guard1 = cf::lock_acquire "map_data:$path"; # just for the fun of it
2040 my $guard2 = cf::lock_acquire "map_find:$path";
2036 2041
2037 my $map = new_from_path cf::map $path 2042 my $map = new_from_path cf::map $path
2038 or return; 2043 or return;
2039 2044
2040 $map->{last_save} = $cf::RUNTIME; 2045 $map->{last_save} = $cf::RUNTIME;
… …
2043 or return; 2048 or return;
2044 2049
2045 if ($map->should_reset) {#d#TODO# disabled, crashy (locking issue?) 2050 if ($map->should_reset) {#d#TODO# disabled, crashy (locking issue?)
2046 # doing this can freeze the server in a sync job, obviously 2051 # doing this can freeze the server in a sync job, obviously
2047 #$cf::WAIT_FOR_TICK->wait; 2052 #$cf::WAIT_FOR_TICK->wait;
2053 undef $guard2;
2048 undef $guard1; 2054 undef $guard1;
2049 undef $guard2;
2050 $map->reset; 2055 $map->reset;
2051 return find $path; 2056 return find $path;
2052 } 2057 }
2053 2058
2054 $cf::MAP{$path} = $map 2059 $cf::MAP{$path} = $map
… …
2457can be C<undef>. Does the right thing when the player is currently in a 2462can be C<undef>. Does the right thing when the player is currently in a
2458dialogue with the given NPC character. 2463dialogue with the given NPC character.
2459 2464
2460=cut 2465=cut
2461 2466
2467our $SAY_CHANNEL = {
2468 id => "say",
2469 title => "Map",
2470 reply => "say ",
2471 tooltip => "Things said to and replied from npcs near you and other players on the same map only.",
2472};
2473
2474our $CHAT_CHANNEL = {
2475 id => "chat",
2476 title => "Chat",
2477 reply => "chat ",
2478 tooltip => "Player chat and shouts, global to the server.",
2479};
2480
2462# rough implementation of a future "reply" method that works 2481# rough implementation of a future "reply" method that works
2463# with dialog boxes. 2482# with dialog boxes.
2464#TODO: the first argument must go, split into a $npc->reply_to ( method 2483#TODO: the first argument must go, split into a $npc->reply_to ( method
2465sub cf::object::player::reply($$$;$) { 2484sub cf::object::player::reply($$$;$) {
2466 my ($self, $npc, $msg, $flags) = @_; 2485 my ($self, $npc, $msg, $flags) = @_;
… …
2477 my $dialog = $pl->{npc_dialog}; 2496 my $dialog = $pl->{npc_dialog};
2478 $dialog->{pl}->ext_msg ($dialog->{id}, update => msg => $dialog->{pl}->expand_cfpod ($msg)); 2497 $dialog->{pl}->ext_msg ($dialog->{id}, update => msg => $dialog->{pl}->expand_cfpod ($msg));
2479 2498
2480 } else { 2499 } else {
2481 $msg = $npc->name . " says: $msg" if $npc; 2500 $msg = $npc->name . " says: $msg" if $npc;
2482 $self->message ($msg, $flags); 2501 $self->send_msg ($SAY_CHANNEL => $msg, $flags);
2483 } 2502 }
2484 } 2503 }
2485} 2504}
2486 2505
2487=item $object->send_msg ($channel, $msg, $color, [extra...]) 2506=item $object->send_msg ($channel, $msg, $color, [extra...])
… …
2682} 2701}
2683 2702
2684sub prepare_random_map { 2703sub prepare_random_map {
2685 my ($exit) = @_; 2704 my ($exit) = @_;
2686 2705
2687 my $guard = cf::lock_acquire "exit_prepare:$exit";
2688
2689 # all this does is basically replace the /! path by 2706 # all this does is basically replace the /! path by
2690 # a new random map path (?random/...) with a seed 2707 # a new random map path (?random/...) with a seed
2691 # that depends on the exit object 2708 # that depends on the exit object
2692 2709
2693 my $rmp = parse_random_map_params $exit->msg; 2710 my $rmp = parse_random_map_params $exit->msg;
… …
2695 if ($exit->map) { 2712 if ($exit->map) {
2696 $rmp->{region} = $exit->region->name; 2713 $rmp->{region} = $exit->region->name;
2697 $rmp->{origin_map} = $exit->map->path; 2714 $rmp->{origin_map} = $exit->map->path;
2698 $rmp->{origin_x} = $exit->x; 2715 $rmp->{origin_x} = $exit->x;
2699 $rmp->{origin_y} = $exit->y; 2716 $rmp->{origin_y} = $exit->y;
2717
2718 $exit->map->touch;
2700 } 2719 }
2701 2720
2702 $rmp->{random_seed} ||= $exit->random_seed; 2721 $rmp->{random_seed} ||= $exit->random_seed;
2703 2722
2704 my $data = JSON::XS->new->utf8->pretty->canolicalize->encode ($rmp); 2723 my $data = JSON::XS->new->utf8->pretty->canonical->encode ($rmp);
2705 my $md5 = Digest::MD5::md5_hex $data; 2724 my $md5 = Digest::MD5::md5_hex $data;
2706 my $meta = "$RANDOMDIR/$md5.meta"; 2725 my $meta = "$RANDOMDIR/$md5.meta";
2707 2726
2708 if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) { 2727 if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) {
2709 aio_write $fh, 0, (length $data), $data, 0; 2728 aio_write $fh, 0, (length $data), $data, 0;
2710 undef $fh; 2729 undef $fh;
2711 aio_rename "$meta~", $meta; 2730 aio_rename "$meta~", $meta;
2712 2731
2732 my $slaying = "?random/$md5";
2733
2734 if ($exit->valid) {
2713 $exit->slaying ("?random/$md5"); 2735 $exit->slaying ("?random/$md5");
2714 $exit->msg (undef); 2736 $exit->msg (undef);
2737 }
2715 } 2738 }
2716} 2739}
2717 2740
2718sub cf::object::player::enter_exit { 2741sub cf::object::player::enter_exit {
2719 my ($self, $exit) = @_; 2742 my ($self, $exit) = @_;
2720 2743
2721 return unless $self->type == cf::PLAYER; 2744 return unless $self->type == cf::PLAYER;
2722 2745
2723 if ($exit->slaying eq "/!") {
2724 #TODO: this should de-fi-ni-te-ly not be a sync-job
2725 # the problem is that $exit might not survive long enough
2726 # so it needs to be done right now, right here
2727 cf::sync_job { prepare_random_map $exit };
2728 }
2729
2730 my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
2731 my $hp = $exit->stats->hp;
2732 my $sp = $exit->stats->sp;
2733
2734 $self->enter_link; 2746 $self->enter_link;
2735 2747
2736 # if exit is damned, update players death & WoR home-position
2737 $self->contr->savebed ($slaying, $hp, $sp)
2738 if $exit->flag (FLAG_DAMNED);
2739
2740 (async { 2748 (async {
2741 $Coro::current->{desc} = "enter_exit $slaying $hp $sp"; 2749 $Coro::current->{desc} = "enter_exit";
2742 2750
2743 $self->deactivate_recursive; # just to be sure
2744 unless (eval { 2751 unless (eval {
2752 $self->deactivate_recursive; # just to be sure
2753
2754 # random map handling
2755 {
2756 my $guard = cf::lock_acquire "exit_prepare:$exit";
2757
2758 prepare_random_map $exit
2759 if $exit->slaying eq "/!";
2760 }
2761
2762 my $map = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
2763 my $x = $exit->stats->hp;
2764 my $y = $exit->stats->sp;
2765
2745 $self->goto ($slaying, $hp, $sp); 2766 $self->goto ($map, $x, $y);
2746 2767
2768 # if exit is damned, update players death & WoR home-position
2769 $self->contr->savebed ($map, $x, $y)
2770 if $exit->flag (cf::FLAG_DAMNED);
2771
2747 1; 2772 1
2748 }) { 2773 }) {
2749 $self->message ("Something went wrong deep within the crossfire server. " 2774 $self->message ("Something went wrong deep within the crossfire server. "
2750 . "I'll try to bring you back to the map you were before. " 2775 . "I'll try to bring you back to the map you were before. "
2751 . "Please report this to the dungeon master!", 2776 . "Please report this to the dungeon master!",
2752 cf::NDI_UNIQUE | cf::NDI_RED); 2777 cf::NDI_UNIQUE | cf::NDI_RED);
… …
2832 id => "infobox", 2857 id => "infobox",
2833 title => "Map Info", 2858 title => "Map Info",
2834 reply => undef, 2859 reply => undef,
2835 tooltip => "Information related to the maps", 2860 tooltip => "Information related to the maps",
2836 }, 2861 },
2862 "c/party" => {
2863 id => "party",
2864 title => "Party",
2865 reply => "gsay ",
2866 tooltip => "Messages and chat related to your party",
2867 },
2837); 2868);
2838 2869
2839sub cf::client::send_msg { 2870sub cf::client::send_msg {
2840 my ($self, $channel, $msg, $color, @extra) = @_; 2871 my ($self, $channel, $msg, $color, @extra) = @_;
2841 2872
… …
3078 3109
3079The following functions and methods are available within a safe environment: 3110The following functions and methods are available within a safe environment:
3080 3111
3081 cf::object 3112 cf::object
3082 contr pay_amount pay_player map x y force_find force_add destroy 3113 contr pay_amount pay_player map x y force_find force_add destroy
3083 insert remove name archname title slaying race decrease_ob_nr 3114 insert remove name archname title slaying race decrease split
3084 3115
3085 cf::object::player 3116 cf::object::player
3086 player 3117 player
3087 3118
3088 cf::player 3119 cf::player
… …
3093 3124
3094=cut 3125=cut
3095 3126
3096for ( 3127for (
3097 ["cf::object" => qw(contr pay_amount pay_player map force_find force_add x y 3128 ["cf::object" => qw(contr pay_amount pay_player map force_find force_add x y
3098 insert remove inv name archname title slaying race 3129 insert remove inv nrof name archname title slaying race
3099 decrease_ob_nr destroy)], 3130 decrease split destroy)],
3100 ["cf::object::player" => qw(player)], 3131 ["cf::object::player" => qw(player)],
3101 ["cf::player" => qw(peaceful)], 3132 ["cf::player" => qw(peaceful)],
3102 ["cf::map" => qw(trigger)], 3133 ["cf::map" => qw(trigger)],
3103) { 3134) {
3104 no strict 'refs'; 3135 no strict 'refs';
… …
3312 while (my ($k, $v) = each %$want) { 3343 while (my ($k, $v) = each %$want) {
3313 $ns->fx_want ($k, $v); 3344 $ns->fx_want ($k, $v);
3314 } 3345 }
3315}; 3346};
3316 3347
3348sub load_resource_file($) {
3349 my $guard = lock_acquire "load_resource_file";
3350
3351 my $status = load_resource_file_ $_[0];
3352 get_slot 0.1, 100;
3353 cf::arch::commit_load;
3354
3355 $status
3356}
3357
3317sub reload_regions { 3358sub reload_regions {
3318 # HACK to clear player env face cache, we need some signal framework 3359 # HACK to clear player env face cache, we need some signal framework
3319 # for this (global event?) 3360 # for this (global event?)
3320 %ext::player_env::MUSIC_FACE_CACHE = (); 3361 %ext::player_env::MUSIC_FACE_CACHE = ();
3321 3362
… …
3334} 3375}
3335 3376
3336sub reload_archetypes { 3377sub reload_archetypes {
3337 load_resource_file "$DATADIR/archetypes" 3378 load_resource_file "$DATADIR/archetypes"
3338 or die "unable to load archetypes\n"; 3379 or die "unable to load archetypes\n";
3339 #d# NEED to laod twice to resolve forward references
3340 # this really needs to be done in an extra post-pass
3341 # (which needs to be synchronous, so solve it differently)
3342 load_resource_file "$DATADIR/archetypes"
3343 or die "unable to load archetypes\n";
3344} 3380}
3345 3381
3346sub reload_treasures { 3382sub reload_treasures {
3347 load_resource_file "$DATADIR/treasures" 3383 load_resource_file "$DATADIR/treasures"
3348 or die "unable to load treasurelists\n"; 3384 or die "unable to load treasurelists\n";
3349} 3385}
3350 3386
3351sub reload_resources { 3387sub reload_resources {
3352 warn "reloading resource files...\n"; 3388 warn "reloading resource files...\n";
3353 3389
3390 reload_facedata;
3391 reload_archetypes;
3354 reload_regions; 3392 reload_regions;
3355 reload_facedata;
3356 #reload_archetypes;#d#
3357 reload_archetypes;
3358 reload_treasures; 3393 reload_treasures;
3359 3394
3360 warn "finished reloading resource files\n"; 3395 warn "finished reloading resource files\n";
3361} 3396}
3362 3397
3363sub init { 3398sub init {
3399 my $guard = freeze_mainloop;
3400
3401 evthread_start IO::AIO::poll_fileno;
3402
3364 reload_resources; 3403 reload_resources;
3365} 3404}
3366 3405
3367sub reload_config { 3406sub reload_config {
3368 open my $fh, "<:utf8", "$CONFDIR/config" 3407 open my $fh, "<:utf8", "$CONFDIR/config"
… …
3393 $Coro::current->{desc} = "IDLE BUG HANDLER"; 3432 $Coro::current->{desc} = "IDLE BUG HANDLER";
3394 EV::loop EV::LOOP_ONESHOT; 3433 EV::loop EV::LOOP_ONESHOT;
3395 })->prio (Coro::PRIO_MAX); 3434 })->prio (Coro::PRIO_MAX);
3396 }; 3435 };
3397 3436
3437 {
3438 my $guard = freeze_mainloop;
3398 reload_config; 3439 reload_config;
3399 db_init; 3440 db_init;
3400 load_extensions; 3441 load_extensions;
3401 3442
3402 $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority 3443 $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
3403 evthread_start IO::AIO::poll_fileno; 3444 }
3445
3404 EV::loop; 3446 EV::loop;
3405} 3447}
3406 3448
3407############################################################################# 3449#############################################################################
3408# initialisation and cleanup 3450# initialisation and cleanup
… …
3690 3732
3691our @WAIT_FOR_TICK; 3733our @WAIT_FOR_TICK;
3692our @WAIT_FOR_TICK_BEGIN; 3734our @WAIT_FOR_TICK_BEGIN;
3693 3735
3694sub wait_for_tick { 3736sub wait_for_tick {
3695 return if tick_inhibit;
3696 return if $Coro::current == $Coro::main; 3737 return if tick_inhibit || $Coro::current == $Coro::main;
3697 3738
3698 my $signal = new Coro::Signal; 3739 my $signal = new Coro::Signal;
3699 push @WAIT_FOR_TICK, $signal; 3740 push @WAIT_FOR_TICK, $signal;
3700 $signal->wait; 3741 $signal->wait;
3701} 3742}
3702 3743
3703sub wait_for_tick_begin { 3744sub wait_for_tick_begin {
3704 return if tick_inhibit;
3705 return if $Coro::current == $Coro::main; 3745 return if tick_inhibit || $Coro::current == $Coro::main;
3706 3746
3707 my $signal = new Coro::Signal; 3747 my $signal = new Coro::Signal;
3708 push @WAIT_FOR_TICK_BEGIN, $signal; 3748 push @WAIT_FOR_TICK_BEGIN, $signal;
3709 $signal->wait; 3749 $signal->wait;
3710} 3750}
… …
3749{ 3789{
3750 # configure BDB 3790 # configure BDB
3751 3791
3752 BDB::min_parallel 8; 3792 BDB::min_parallel 8;
3753 BDB::max_poll_reqs $TICK * 0.1; 3793 BDB::max_poll_reqs $TICK * 0.1;
3754 $Coro::BDB::WATCHER->priority (1); 3794 $AnyEvent::BDB::WATCHER->priority (1);
3755 3795
3756 unless ($DB_ENV) { 3796 unless ($DB_ENV) {
3757 $DB_ENV = BDB::db_env_create; 3797 $DB_ENV = BDB::db_env_create;
3758 $DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT | BDB::TXN_NOSYNC 3798 $DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT | BDB::TXN_NOSYNC
3759 | BDB::LOG_AUTOREMOVE, 1); 3799 | BDB::LOG_AUTOREMOVE, 1);
… …
3790{ 3830{
3791 # configure IO::AIO 3831 # configure IO::AIO
3792 3832
3793 IO::AIO::min_parallel 8; 3833 IO::AIO::min_parallel 8;
3794 IO::AIO::max_poll_time $TICK * 0.1; 3834 IO::AIO::max_poll_time $TICK * 0.1;
3795 $Coro::AIO::WATCHER->priority (1); 3835 undef $AnyEvent::AIO::WATCHER;
3796} 3836}
3797 3837
3798my $_log_backtrace; 3838my $_log_backtrace;
3799 3839
3800sub _log_backtrace { 3840sub _log_backtrace {

Diff Legend

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