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.418 by root, Fri Apr 11 21:09:53 2008 UTC vs.
Revision 1.430 by root, Sun May 4 14:12:37 2008 UTC

… …
427 } 427 }
428 } 428 }
429}; 429};
430 430
431sub get_slot($;$$) { 431sub get_slot($;$$) {
432 return if tick_inhibit || $Coro::current == $Coro::main;
433
432 my ($time, $pri, $name) = @_; 434 my ($time, $pri, $name) = @_;
433 435
434 $time = $TICK * .6 if $time > $TICK * .6; 436 $time = $TICK * .6 if $time > $TICK * .6;
435 my $sig = new Coro::Signal; 437 my $sig = new Coro::Signal;
436 438
… …
1139 utf8::decode (my $decname = $filename); 1141 utf8::decode (my $decname = $filename);
1140 warn sprintf "saving %s (%d,%d)\n", 1142 warn sprintf "saving %s (%d,%d)\n",
1141 $decname, length $$rdata, scalar @$objs; 1143 $decname, length $$rdata, scalar @$objs;
1142 1144
1143 if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) { 1145 if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {
1144 chmod SAVE_MODE, $fh; 1146 aio_chmod $fh, SAVE_MODE;
1145 aio_write $fh, 0, (length $$rdata), $$rdata, 0; 1147 aio_write $fh, 0, (length $$rdata), $$rdata, 0;
1146 aio_fsync $fh if $cf::USE_FSYNC; 1148 aio_fsync $fh if $cf::USE_FSYNC;
1147 close $fh; 1149 aio_close $fh;
1148 1150
1149 if (@$objs) { 1151 if (@$objs) {
1150 if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) { 1152 if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
1151 chmod SAVE_MODE, $fh; 1153 aio_chmod $fh, SAVE_MODE;
1152 my $data = Coro::Storable::nfreeze { version => 1, objs => $objs }; 1154 my $data = Coro::Storable::nfreeze { version => 1, objs => $objs };
1153 aio_write $fh, 0, (length $data), $data, 0; 1155 aio_write $fh, 0, (length $data), $data, 0;
1154 aio_fsync $fh if $cf::USE_FSYNC; 1156 aio_fsync $fh if $cf::USE_FSYNC;
1155 close $fh; 1157 aio_close $fh;
1156 aio_rename "$filename.pst~", "$filename.pst"; 1158 aio_rename "$filename.pst~", "$filename.pst";
1157 } 1159 }
1158 } else { 1160 } else {
1159 aio_unlink "$filename.pst"; 1161 aio_unlink "$filename.pst";
1160 } 1162 }
… …
1454 my $f = new_from_file cf::object::thawer path $login 1456 my $f = new_from_file cf::object::thawer path $login
1455 or return; 1457 or return;
1456 1458
1457 my $pl = cf::player::load_pl $f 1459 my $pl = cf::player::load_pl $f
1458 or return; 1460 or return;
1461
1459 local $cf::PLAYER_LOADING{$login} = $pl; 1462 local $cf::PLAYER_LOADING{$login} = $pl;
1460 $f->resolve_delayed_derefs; 1463 $f->resolve_delayed_derefs;
1461 $cf::PLAYER{$login} = $pl 1464 $cf::PLAYER{$login} = $pl
1462 } 1465 }
1463 } 1466 }
… …
1473 1476
1474 return if $pl->{deny_save}; 1477 return if $pl->{deny_save};
1475 1478
1476 aio_mkdir playerdir $pl, 0770; 1479 aio_mkdir playerdir $pl, 0770;
1477 $pl->{last_save} = $cf::RUNTIME; 1480 $pl->{last_save} = $cf::RUNTIME;
1481
1482 cf::get_slot 0.01;
1478 1483
1479 $pl->save_pl ($path); 1484 $pl->save_pl ($path);
1480 cf::cede_to_tick; 1485 cf::cede_to_tick;
1481} 1486}
1482 1487
… …
1566 1571
1567 for my $login (@$dirs) { 1572 for my $login (@$dirs) {
1568 my $path = path $login; 1573 my $path = path $login;
1569 1574
1570 # a .pst is a dead give-away for a valid player 1575 # a .pst is a dead give-away for a valid player
1571 unless (-e "$path.pst") { 1576 # if no pst file found, open and chekc for blocked users
1577 if (aio_stat "$path.pst") {
1572 my $fh = aio_open $path, Fcntl::O_RDONLY, 0 or next; 1578 my $fh = aio_open $path, Fcntl::O_RDONLY, 0 or next;
1573 aio_read $fh, 0, 512, my $buf, 0 or next; 1579 aio_read $fh, 0, 512, my $buf, 0 or next;
1574 $buf !~ /^password -------------$/m or next; # official not-valid tag 1580 $buf !~ /^password -------------$/m or next; # official not-valid tag
1575 } 1581 }
1576 1582
… …
1909 1915
1910# the temporary/swap location 1916# the temporary/swap location
1911sub save_path { 1917sub save_path {
1912 my ($self) = @_; 1918 my ($self) = @_;
1913 1919
1914 (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g; 1920 (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/go;
1915 "$TMPDIR/$path.map" 1921 "$TMPDIR/$path.map"
1916} 1922}
1917 1923
1918# the unique path, undef == no special unique path 1924# the unique path, undef == no special unique path
1919sub uniq_path { 1925sub uniq_path {
1920 my ($self) = @_; 1926 my ($self) = @_;
1921 1927
1922 (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g; 1928 (my $path = $_[0]{path}) =~ s/\//$PATH_SEP/go;
1923 "$UNIQUEDIR/$path" 1929 "$UNIQUEDIR/$path"
1924} 1930}
1925 1931
1926# and all this just because we cannot iterate over 1932# and all this just because we cannot iterate over
1927# all maps in C++... 1933# all maps in C++...
… …
2025 2031
2026 cf::lock_wait "map_data:$path";#d#remove 2032 cf::lock_wait "map_data:$path";#d#remove
2027 cf::lock_wait "map_find:$path"; 2033 cf::lock_wait "map_find:$path";
2028 2034
2029 $cf::MAP{$path} || do { 2035 $cf::MAP{$path} || do {
2030 my $guard1 = cf::lock_acquire "map_find:$path";
2031 my $guard2 = cf::lock_acquire "map_data:$path"; # just for the fun of it 2036 my $guard1 = cf::lock_acquire "map_data:$path"; # just for the fun of it
2037 my $guard2 = cf::lock_acquire "map_find:$path";
2032 2038
2033 my $map = new_from_path cf::map $path 2039 my $map = new_from_path cf::map $path
2034 or return; 2040 or return;
2035 2041
2036 $map->{last_save} = $cf::RUNTIME; 2042 $map->{last_save} = $cf::RUNTIME;
… …
2039 or return; 2045 or return;
2040 2046
2041 if ($map->should_reset) {#d#TODO# disabled, crashy (locking issue?) 2047 if ($map->should_reset) {#d#TODO# disabled, crashy (locking issue?)
2042 # doing this can freeze the server in a sync job, obviously 2048 # doing this can freeze the server in a sync job, obviously
2043 #$cf::WAIT_FOR_TICK->wait; 2049 #$cf::WAIT_FOR_TICK->wait;
2050 undef $guard2;
2044 undef $guard1; 2051 undef $guard1;
2045 undef $guard2;
2046 $map->reset; 2052 $map->reset;
2047 return find $path; 2053 return find $path;
2048 } 2054 }
2049 2055
2050 $cf::MAP{$path} = $map 2056 $cf::MAP{$path} = $map
… …
2113 } 2119 }
2114 2120
2115 $self->{last_save} = $cf::RUNTIME; 2121 $self->{last_save} = $cf::RUNTIME;
2116 $self->last_access ($cf::RUNTIME); 2122 $self->last_access ($cf::RUNTIME);
2117 2123
2118 $self->in_memory (cf::MAP_IN_MEMORY); 2124 $self->in_memory (cf::MAP_ACTIVE);
2119 } 2125 }
2120 2126
2121 $self->post_load; 2127 $self->post_load;
2122} 2128}
2123 2129
… …
2181 my ($path, $origin, $load) = @_; 2187 my ($path, $origin, $load) = @_;
2182 2188
2183 $path = normalise $path, $origin && $origin->{path}; 2189 $path = normalise $path, $origin && $origin->{path};
2184 2190
2185 if (my $map = $cf::MAP{$path}) { 2191 if (my $map = $cf::MAP{$path}) {
2186 return $map if !$load || $map->in_memory == cf::MAP_IN_MEMORY; 2192 return $map if !$load || $map->in_memory == cf::MAP_ACTIVE;
2187 } 2193 }
2188 2194
2189 $MAP_PREFETCH{$path} |= $load; 2195 $MAP_PREFETCH{$path} |= $load;
2190 2196
2191 $MAP_PREFETCHER ||= cf::async { 2197 $MAP_PREFETCHER ||= cf::async {
… …
2228 cf::async { 2234 cf::async {
2229 $Coro::current->{desc} = "map player save"; 2235 $Coro::current->{desc} = "map player save";
2230 $_->contr->save for $self->players; 2236 $_->contr->save for $self->players;
2231 }; 2237 };
2232 2238
2239 cf::get_slot 0.02;
2240
2233 if ($uniq) { 2241 if ($uniq) {
2234 $self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS); 2242 $self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
2235 $self->_save_objects ($uniq, cf::IO_UNIQUES); 2243 $self->_save_objects ($uniq, cf::IO_UNIQUES);
2236 } else { 2244 } else {
2237 $self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES); 2245 $self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
… …
2245 $self->save; 2253 $self->save;
2246 2254
2247 my $lock = cf::lock_acquire "map_data:$self->{path}"; 2255 my $lock = cf::lock_acquire "map_data:$self->{path}";
2248 2256
2249 return if $self->players; 2257 return if $self->players;
2250 return if $self->in_memory != cf::MAP_IN_MEMORY; 2258 return if $self->in_memory != cf::MAP_ACTIVE;
2251 return if $self->{deny_save}; 2259 return if $self->{deny_save};
2252 2260
2253 $self->in_memory (cf::MAP_SWAPPED); 2261 $self->in_memory (cf::MAP_SWAPPED);
2254 2262
2255 $self->deactivate; 2263 $self->deactivate;
… …
2373 2381
2374sub unique_maps() { 2382sub unique_maps() {
2375 [ 2383 [
2376 map { 2384 map {
2377 utf8::decode $_; 2385 utf8::decode $_;
2378 /\.map$/ 2386 s/\.map$//; # TODO future compatibility hack
2387 /\.pst$/ || !/^$PATH_SEP/o # TODO unique maps apparebntly lack the .map suffix :/
2388 ? ()
2379 ? normalise $_ 2389 : normalise $_
2380 : ()
2381 } @{ aio_readdir $UNIQUEDIR or [] } 2390 } @{ aio_readdir $UNIQUEDIR or [] }
2382 ] 2391 ]
2383} 2392}
2384 2393
2385=back 2394=back
… …
2392 2401
2393=over 4 2402=over 4
2394 2403
2395=item $ob->inv_recursive 2404=item $ob->inv_recursive
2396 2405
2397Returns the inventory of the object _and_ their inventories, recursively. 2406Returns the inventory of the object I<and> their inventories, recursively,
2407but I<not> the object itself.
2398 2408
2399=cut 2409=cut
2400 2410
2401sub inv_recursive_; 2411sub inv_recursive_;
2402sub inv_recursive_ { 2412sub inv_recursive_ {
… …
2407 inv_recursive_ inv $_[0] 2417 inv_recursive_ inv $_[0]
2408} 2418}
2409 2419
2410=item $ref = $ob->ref 2420=item $ref = $ob->ref
2411 2421
2412creates and returns a persistent reference to an objetc that can be stored as a string. 2422Creates and returns a persistent reference to an object that can be stored as a string.
2413 2423
2414=item $ob = cf::object::deref ($refstring) 2424=item $ob = cf::object::deref ($refstring)
2415 2425
2416returns the objetc referenced by refstring. may return undef when it cnanot find the object, 2426returns the objetc referenced by refstring. may return undef when it cnanot find the object,
2417even if the object actually exists. May block. 2427even if the object actually exists. May block.
… …
2449can be C<undef>. Does the right thing when the player is currently in a 2459can be C<undef>. Does the right thing when the player is currently in a
2450dialogue with the given NPC character. 2460dialogue with the given NPC character.
2451 2461
2452=cut 2462=cut
2453 2463
2464our $SAY_CHANNEL = {
2465 id => "say",
2466 title => "Map",
2467 reply => "say ",
2468 tooltip => "Things said to and replied from npcs near you and other players on the same map only.",
2469};
2470
2471our $CHAT_CHANNEL = {
2472 id => "chat",
2473 title => "Chat",
2474 reply => "chat ",
2475 tooltip => "Player chat and shouts, global to the server.",
2476};
2477
2454# rough implementation of a future "reply" method that works 2478# rough implementation of a future "reply" method that works
2455# with dialog boxes. 2479# with dialog boxes.
2456#TODO: the first argument must go, split into a $npc->reply_to ( method 2480#TODO: the first argument must go, split into a $npc->reply_to ( method
2457sub cf::object::player::reply($$$;$) { 2481sub cf::object::player::reply($$$;$) {
2458 my ($self, $npc, $msg, $flags) = @_; 2482 my ($self, $npc, $msg, $flags) = @_;
… …
2469 my $dialog = $pl->{npc_dialog}; 2493 my $dialog = $pl->{npc_dialog};
2470 $dialog->{pl}->ext_msg ($dialog->{id}, update => msg => $dialog->{pl}->expand_cfpod ($msg)); 2494 $dialog->{pl}->ext_msg ($dialog->{id}, update => msg => $dialog->{pl}->expand_cfpod ($msg));
2471 2495
2472 } else { 2496 } else {
2473 $msg = $npc->name . " says: $msg" if $npc; 2497 $msg = $npc->name . " says: $msg" if $npc;
2474 $self->message ($msg, $flags); 2498 $self->send_msg ($SAY_CHANNEL => $msg, $flags);
2475 } 2499 }
2476 } 2500 }
2477} 2501}
2478 2502
2479=item $object->send_msg ($channel, $msg, $color, [extra...]) 2503=item $object->send_msg ($channel, $msg, $color, [extra...])
… …
2674} 2698}
2675 2699
2676sub prepare_random_map { 2700sub prepare_random_map {
2677 my ($exit) = @_; 2701 my ($exit) = @_;
2678 2702
2679 my $guard = cf::lock_acquire "exit_prepare:$exit";
2680
2681 # all this does is basically replace the /! path by 2703 # all this does is basically replace the /! path by
2682 # a new random map path (?random/...) with a seed 2704 # a new random map path (?random/...) with a seed
2683 # that depends on the exit object 2705 # that depends on the exit object
2684 2706
2685 my $rmp = parse_random_map_params $exit->msg; 2707 my $rmp = parse_random_map_params $exit->msg;
… …
2687 if ($exit->map) { 2709 if ($exit->map) {
2688 $rmp->{region} = $exit->region->name; 2710 $rmp->{region} = $exit->region->name;
2689 $rmp->{origin_map} = $exit->map->path; 2711 $rmp->{origin_map} = $exit->map->path;
2690 $rmp->{origin_x} = $exit->x; 2712 $rmp->{origin_x} = $exit->x;
2691 $rmp->{origin_y} = $exit->y; 2713 $rmp->{origin_y} = $exit->y;
2714
2715 $exit->map->touch;
2692 } 2716 }
2693 2717
2694 $rmp->{random_seed} ||= $exit->random_seed; 2718 $rmp->{random_seed} ||= $exit->random_seed;
2695 2719
2696 my $data = cf::encode_json $rmp; 2720 my $data = JSON::XS->new->utf8->pretty->canonical->encode ($rmp);
2697 my $md5 = Digest::MD5::md5_hex $data; 2721 my $md5 = Digest::MD5::md5_hex $data;
2698 my $meta = "$RANDOMDIR/$md5.meta"; 2722 my $meta = "$RANDOMDIR/$md5.meta";
2699 2723
2700 if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) { 2724 if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) {
2701 aio_write $fh, 0, (length $data), $data, 0; 2725 aio_write $fh, 0, (length $data), $data, 0;
2702 undef $fh; 2726 undef $fh;
2703 aio_rename "$meta~", $meta; 2727 aio_rename "$meta~", $meta;
2704 2728
2729 my $slaying = "?random/$md5";
2730
2731 if ($exit->valid) {
2705 $exit->slaying ("?random/$md5"); 2732 $exit->slaying ("?random/$md5");
2706 $exit->msg (undef); 2733 $exit->msg (undef);
2734 }
2707 } 2735 }
2708} 2736}
2709 2737
2710sub cf::object::player::enter_exit { 2738sub cf::object::player::enter_exit {
2711 my ($self, $exit) = @_; 2739 my ($self, $exit) = @_;
2712 2740
2713 return unless $self->type == cf::PLAYER; 2741 return unless $self->type == cf::PLAYER;
2714 2742
2715 if ($exit->slaying eq "/!") {
2716 #TODO: this should de-fi-ni-te-ly not be a sync-job
2717 # the problem is that $exit might not survive long enough
2718 # so it needs to be done right now, right here
2719 cf::sync_job { prepare_random_map $exit };
2720 }
2721
2722 my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
2723 my $hp = $exit->stats->hp;
2724 my $sp = $exit->stats->sp;
2725
2726 $self->enter_link; 2743 $self->enter_link;
2727 2744
2728 # if exit is damned, update players death & WoR home-position
2729 $self->contr->savebed ($slaying, $hp, $sp)
2730 if $exit->flag (FLAG_DAMNED);
2731
2732 (async { 2745 (async {
2733 $Coro::current->{desc} = "enter_exit $slaying $hp $sp"; 2746 $Coro::current->{desc} = "enter_exit";
2734 2747
2735 $self->deactivate_recursive; # just to be sure
2736 unless (eval { 2748 unless (eval {
2749 $self->deactivate_recursive; # just to be sure
2750
2751 # random map handling
2752 {
2753 my $guard = cf::lock_acquire "exit_prepare:$exit";
2754
2755 prepare_random_map $exit
2756 if $exit->slaying eq "/!";
2757 }
2758
2759 my $map = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
2760 my $x = $exit->stats->hp;
2761 my $y = $exit->stats->sp;
2762
2737 $self->goto ($slaying, $hp, $sp); 2763 $self->goto ($map, $x, $y);
2738 2764
2765 # if exit is damned, update players death & WoR home-position
2766 $self->contr->savebed ($map, $x, $y)
2767 if $exit->flag (cf::FLAG_DAMNED);
2768
2739 1; 2769 1
2740 }) { 2770 }) {
2741 $self->message ("Something went wrong deep within the crossfire server. " 2771 $self->message ("Something went wrong deep within the crossfire server. "
2742 . "I'll try to bring you back to the map you were before. " 2772 . "I'll try to bring you back to the map you were before. "
2743 . "Please report this to the dungeon master!", 2773 . "Please report this to the dungeon master!",
2744 cf::NDI_UNIQUE | cf::NDI_RED); 2774 cf::NDI_UNIQUE | cf::NDI_RED);
… …
2824 id => "infobox", 2854 id => "infobox",
2825 title => "Map Info", 2855 title => "Map Info",
2826 reply => undef, 2856 reply => undef,
2827 tooltip => "Information related to the maps", 2857 tooltip => "Information related to the maps",
2828 }, 2858 },
2859 "c/party" => {
2860 id => "party",
2861 title => "Party",
2862 reply => "gsay ",
2863 tooltip => "Messages and chat related to your party",
2864 },
2829); 2865);
2830 2866
2831sub cf::client::send_msg { 2867sub cf::client::send_msg {
2832 my ($self, $channel, $msg, $color, @extra) = @_; 2868 my ($self, $channel, $msg, $color, @extra) = @_;
2833 2869
… …
3070 3106
3071The following functions and methods are available within a safe environment: 3107The following functions and methods are available within a safe environment:
3072 3108
3073 cf::object 3109 cf::object
3074 contr pay_amount pay_player map x y force_find force_add destroy 3110 contr pay_amount pay_player map x y force_find force_add destroy
3075 insert remove name archname title slaying race decrease_ob_nr 3111 insert remove name archname title slaying race decrease split
3076 3112
3077 cf::object::player 3113 cf::object::player
3078 player 3114 player
3079 3115
3080 cf::player 3116 cf::player
… …
3086=cut 3122=cut
3087 3123
3088for ( 3124for (
3089 ["cf::object" => qw(contr pay_amount pay_player map force_find force_add x y 3125 ["cf::object" => qw(contr pay_amount pay_player map force_find force_add x y
3090 insert remove inv name archname title slaying race 3126 insert remove inv name archname title slaying race
3091 decrease_ob_nr destroy)], 3127 decrease split destroy)],
3092 ["cf::object::player" => qw(player)], 3128 ["cf::object::player" => qw(player)],
3093 ["cf::player" => qw(peaceful)], 3129 ["cf::player" => qw(peaceful)],
3094 ["cf::map" => qw(trigger)], 3130 ["cf::map" => qw(trigger)],
3095) { 3131) {
3096 no strict 'refs'; 3132 no strict 'refs';
… …
3304 while (my ($k, $v) = each %$want) { 3340 while (my ($k, $v) = each %$want) {
3305 $ns->fx_want ($k, $v); 3341 $ns->fx_want ($k, $v);
3306 } 3342 }
3307}; 3343};
3308 3344
3345sub load_resource_file($) {
3346 my $guard = lock_acquire "load_resource_file";
3347
3348 my $status = load_resource_file_ $_[0];
3349 get_slot 0.1, 100;
3350 cf::arch::commit_load;
3351
3352 $status
3353}
3354
3309sub reload_regions { 3355sub reload_regions {
3310 # HACK to clear player env face cache, we need some signal framework 3356 # HACK to clear player env face cache, we need some signal framework
3311 # for this (global event?) 3357 # for this (global event?)
3312 %ext::player_env::MUSIC_FACE_CACHE = (); 3358 %ext::player_env::MUSIC_FACE_CACHE = ();
3313 3359
… …
3326} 3372}
3327 3373
3328sub reload_archetypes { 3374sub reload_archetypes {
3329 load_resource_file "$DATADIR/archetypes" 3375 load_resource_file "$DATADIR/archetypes"
3330 or die "unable to load archetypes\n"; 3376 or die "unable to load archetypes\n";
3331 #d# NEED to laod twice to resolve forward references
3332 # this really needs to be done in an extra post-pass
3333 # (which needs to be synchronous, so solve it differently)
3334 load_resource_file "$DATADIR/archetypes"
3335 or die "unable to load archetypes\n";
3336} 3377}
3337 3378
3338sub reload_treasures { 3379sub reload_treasures {
3339 load_resource_file "$DATADIR/treasures" 3380 load_resource_file "$DATADIR/treasures"
3340 or die "unable to load treasurelists\n"; 3381 or die "unable to load treasurelists\n";
3341} 3382}
3342 3383
3343sub reload_resources { 3384sub reload_resources {
3344 warn "reloading resource files...\n"; 3385 warn "reloading resource files...\n";
3345 3386
3387 reload_facedata;
3388 reload_archetypes;
3346 reload_regions; 3389 reload_regions;
3347 reload_facedata;
3348 #reload_archetypes;#d#
3349 reload_archetypes;
3350 reload_treasures; 3390 reload_treasures;
3351 3391
3352 warn "finished reloading resource files\n"; 3392 warn "finished reloading resource files\n";
3353} 3393}
3354 3394
3355sub init { 3395sub init {
3396 my $guard = freeze_mainloop;
3397
3356 reload_resources; 3398 reload_resources;
3357} 3399}
3358 3400
3359sub reload_config { 3401sub reload_config {
3360 open my $fh, "<:utf8", "$CONFDIR/config" 3402 open my $fh, "<:utf8", "$CONFDIR/config"
… …
3385 $Coro::current->{desc} = "IDLE BUG HANDLER"; 3427 $Coro::current->{desc} = "IDLE BUG HANDLER";
3386 EV::loop EV::LOOP_ONESHOT; 3428 EV::loop EV::LOOP_ONESHOT;
3387 })->prio (Coro::PRIO_MAX); 3429 })->prio (Coro::PRIO_MAX);
3388 }; 3430 };
3389 3431
3432 {
3433 my $guard = freeze_mainloop;
3390 reload_config; 3434 reload_config;
3391 db_init; 3435 db_init;
3392 load_extensions; 3436 load_extensions;
3393 3437
3394 $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority 3438 $Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
3395 evthread_start IO::AIO::poll_fileno; 3439 evthread_start IO::AIO::poll_fileno;
3440 }
3441
3396 EV::loop; 3442 EV::loop;
3397} 3443}
3398 3444
3399############################################################################# 3445#############################################################################
3400# initialisation and cleanup 3446# initialisation and cleanup
… …
3682 3728
3683our @WAIT_FOR_TICK; 3729our @WAIT_FOR_TICK;
3684our @WAIT_FOR_TICK_BEGIN; 3730our @WAIT_FOR_TICK_BEGIN;
3685 3731
3686sub wait_for_tick { 3732sub wait_for_tick {
3687 return if tick_inhibit;
3688 return if $Coro::current == $Coro::main; 3733 return if tick_inhibit || $Coro::current == $Coro::main;
3689 3734
3690 my $signal = new Coro::Signal; 3735 my $signal = new Coro::Signal;
3691 push @WAIT_FOR_TICK, $signal; 3736 push @WAIT_FOR_TICK, $signal;
3692 $signal->wait; 3737 $signal->wait;
3693} 3738}
3694 3739
3695sub wait_for_tick_begin { 3740sub wait_for_tick_begin {
3696 return if tick_inhibit;
3697 return if $Coro::current == $Coro::main; 3741 return if tick_inhibit || $Coro::current == $Coro::main;
3698 3742
3699 my $signal = new Coro::Signal; 3743 my $signal = new Coro::Signal;
3700 push @WAIT_FOR_TICK_BEGIN, $signal; 3744 push @WAIT_FOR_TICK_BEGIN, $signal;
3701 $signal->wait; 3745 $signal->wait;
3702} 3746}

Diff Legend

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