ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/lib/cf.pm

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.533 by root, Thu Apr 29 07:59:17 2010 UTC vs.
Revision 1.583 by root, Mon Oct 29 23:12:37 2012 UTC

1	#	1	#
2	# This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	# This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	#	3	#
4	# Copyright (©) 2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	# Copyright (©) 2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	#	5	#
6	# Deliantra is free software: you can redistribute it and/or modify it under	6	# Deliantra is free software: you can redistribute it and/or modify it under
7	# the terms of the Affero GNU General Public License as published by the	7	# the terms of the Affero GNU General Public License as published by the
8	# Free Software Foundation, either version 3 of the License, or (at your	8	# Free Software Foundation, either version 3 of the License, or (at your
9	# option) any later version.	9	# option) any later version.
10	#	10	#
11	# This program is distributed in the hope that it will be useful,	11	# This program is distributed in the hope that it will be useful,
12	# but WITHOUT ANY WARRANTY; without even the implied warranty of	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	# GNU General Public License for more details.	14	# GNU General Public License for more details.
15	#	15	#
16	# You should have received a copy of the Affero GNU General Public License	16	# You should have received a copy of the Affero GNU General Public License
17	# and the GNU General Public License along with this program. If not, see	17	# and the GNU General Public License along with this program. If not, see
18	# <http://www.gnu.org/licenses/>.	18	# <http://www.gnu.org/licenses/>.
19	#	19	#
20	# The authors can be reached via e-mail to <support@deliantra.net>	20	# The authors can be reached via e-mail to <support@deliantra.net>
21	#	21	#
22		22
23	package cf;	23	package cf;
24		24
25	use 5.10.0;	25	use common::sense;
26	use utf8;
27	use strict qw(vars subs);
28		26
29	use Symbol;	27	use Symbol;
30	use List::Util;	28	use List::Util;
31	use Socket;	29	use Socket;
32	use EV;	30	use EV;
…		…
78	# strictly for debugging	76	# strictly for debugging
79	$SIG{QUIT} = sub { Carp::cluck "SIGQUIT" };	77	$SIG{QUIT} = sub { Carp::cluck "SIGQUIT" };
80		78
81	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload	79	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
82		80
		81	our @ORIG_INC;
		82
83	our %COMMAND = ();	83	our %COMMAND = ();
84	our %COMMAND_TIME = ();	84	our %COMMAND_TIME = ();
85		85
86	our @EXTS = (); # list of extension package names	86	our @EXTS = (); # list of extension package names
87	our %EXTCMD = ();	87	our %EXTCMD = ();
…		…
93	our @EVENT;	93	our @EVENT;
94	our @REFLECT; # set by XS	94	our @REFLECT; # set by XS
95	our %REFLECT; # set by us	95	our %REFLECT; # set by us
96		96
97	our $CONFDIR = confdir;	97	our $CONFDIR = confdir;
		98
98	our $DATADIR = datadir;	99	our $DATADIR = datadir;
99	our $LIBDIR = "$DATADIR/ext";	100	our $LIBDIR = "$DATADIR/ext";
100	our $PODDIR = "$DATADIR/pod";	101	our $PODDIR = "$DATADIR/pod";
101	our $MAPDIR = "$DATADIR/" . mapdir;	102	our $MAPDIR = "$DATADIR/" . mapdir;
		103
102	our $LOCALDIR = localdir;	104	our $LOCALDIR = localdir;
103	our $TMPDIR = "$LOCALDIR/" . tmpdir;	105	our $TMPDIR = "$LOCALDIR/" . tmpdir;
104	our $UNIQUEDIR = "$LOCALDIR/" . uniquedir;	106	our $UNIQUEDIR = "$LOCALDIR/" . uniquedir;
105	our $PLAYERDIR = "$LOCALDIR/" . playerdir;	107	our $PLAYERDIR = "$LOCALDIR/" . playerdir;
106	our $RANDOMDIR = "$LOCALDIR/random";	108	our $RANDOMDIR = "$LOCALDIR/random";
107	our $BDBDIR = "$LOCALDIR/db";	109	our $BDBDIR = "$LOCALDIR/db";
108	our $PIDFILE = "$LOCALDIR/pid";	110	our $PIDFILE = "$LOCALDIR/pid";
109	our $RUNTIMEFILE = "$LOCALDIR/runtime";	111	our $RUNTIMEFILE = "$LOCALDIR/runtime";
110		112
111	our %RESOURCE; # unused	113	#our %RESOURCE; # unused
112		114
113	our $OUTPUT_RATE_MIN = 3000;	115	our $OUTPUT_RATE_MIN = 3000;
114	our $OUTPUT_RATE_MAX = 1000000;	116	our $OUTPUT_RATE_MAX = 1000000;
115		117
116	our $MAX_LINKS = 32; # how many chained exits to follow	118	our $MAX_LINKS = 32; # how many chained exits to follow
…		…
124	our $BDB_DEADLOCK_WATCHER;	126	our $BDB_DEADLOCK_WATCHER;
125	our $BDB_CHECKPOINT_WATCHER;	127	our $BDB_CHECKPOINT_WATCHER;
126	our $BDB_TRICKLE_WATCHER;	128	our $BDB_TRICKLE_WATCHER;
127	our $DB_ENV;	129	our $DB_ENV;
128		130
129	our @EXTRA_MODULES = qw(pod match mapscript);	131	our @EXTRA_MODULES = qw(pod match mapscript incloader);
130		132
131	our %CFG;	133	our %CFG;
		134	our %EXT_CFG; # cfgkeyname => [var-ref, defaultvalue]
132		135
133	our $UPTIME; $UPTIME ||= time;	136	our $UPTIME; $UPTIME ||= time;
134	our $RUNTIME;	137	our $RUNTIME = 0;
		138	our $SERVER_TICK = 0;
135	our $NOW;	139	our $NOW;
136		140
137	our (%PLAYER, %PLAYER_LOADING); # all users	141	our (%PLAYER, %PLAYER_LOADING); # all users
138	our (%MAP, %MAP_LOADING ); # all maps	142	our (%MAP, %MAP_LOADING ); # all maps
139	our $LINK_MAP; # the special {link} map, which is always available	143	our $LINK_MAP; # the special {link} map, which is always available
…		…
148		152
149	our @POST_INIT;	153	our @POST_INIT;
150		154
151	our $REATTACH_ON_RELOAD; # set to true to force object reattach on reload (slow)	155	our $REATTACH_ON_RELOAD; # set to true to force object reattach on reload (slow)
152	our $REALLY_UNLOOP; # never set to true, please :)	156	our $REALLY_UNLOOP; # never set to true, please :)
		157
		158	our $WAIT_FOR_TICK = new Coro::Signal;
		159	our @WAIT_FOR_TICK_BEGIN;
153		160
154	binmode STDOUT;	161	binmode STDOUT;
155	binmode STDERR;	162	binmode STDERR;
156		163
157	# read virtual server time, if available	164	# read virtual server time, if available
…		…
191		198
192	=over 4	199	=over 4
193		200
194	=item $cf::UPTIME	201	=item $cf::UPTIME
195		202
196	The timestamp of the server start (so not actually an uptime).	203	The timestamp of the server start (so not actually an "uptime").
		204
		205	=item $cf::SERVER_TICK
		206
		207	An unsigned integer that starts at zero when the server is started and is
		208	incremented on every tick.
		209
		210	=item $cf::NOW
		211
		212	The (real) time of the last (current) server tick - updated before and
		213	after tick processing, so this is useful only as a rough "what time is it
		214	now" estimate.
		215
		216	=item $cf::TICK
		217
		218	The interval between each server tick, in seconds.
197		219
198	=item $cf::RUNTIME	220	=item $cf::RUNTIME
199		221
200	The time this server has run, starts at 0 and is increased by $cf::TICK on	222	The time this server has run, starts at 0 and is increased by $cf::TICK on
201	every server tick.	223	every server tick.
…		…
207	Various directories - "/etc", read-only install directory, perl-library	229	Various directories - "/etc", read-only install directory, perl-library
208	directory, pod-directory, read-only maps directory, "/var", "/var/tmp",	230	directory, pod-directory, read-only maps directory, "/var", "/var/tmp",
209	unique-items directory, player file directory, random maps directory and	231	unique-items directory, player file directory, random maps directory and
210	database environment.	232	database environment.
211		233
212	=item $cf::NOW
213
214	The time of the last (current) server tick.
215
216	=item $cf::TICK
217
218	The interval between server ticks, in seconds.
219
220	=item $cf::LOADAVG	234	=item $cf::LOADAVG
221		235
222	The current CPU load on the server (alpha-smoothed), as a value between 0	236	The current CPU load on the server (alpha-smoothed), as a value between 0
223	(none) and 1 (overloaded), indicating how much time is spent on processing	237	(none) and 1 (overloaded), indicating how much time is spent on processing
224	objects per tick. Healthy values are < 0.5.	238	objects per tick. Healthy values are < 0.5.
…		…
233	from wherever your confdir points to.	247	from wherever your confdir points to.
234		248
235	=item cf::wait_for_tick, cf::wait_for_tick_begin	249	=item cf::wait_for_tick, cf::wait_for_tick_begin
236		250
237	These are functions that inhibit the current coroutine one tick. cf::wait_for_tick_begin only	251	These are functions that inhibit the current coroutine one tick. cf::wait_for_tick_begin only
238	returns directly I<after> the tick processing (and consequently, can only wake one process	252	returns directly I<after> the tick processing (and consequently, can only wake one thread
239	per tick), while cf::wait_for_tick wakes up all waiters after tick processing.	253	per tick), while cf::wait_for_tick wakes up all waiters after tick processing.
		254
		255	Note that cf::Wait_for_tick will immediately return when the server is not
		256	ticking, making it suitable for small pauses in threads that need to run
		257	when the server is paused. If that is not applicable (i.e. you I<really>
		258	want to wait, use C<$cf::WAIT_FOR_TICK>).
		259
		260	=item $cf::WAIT_FOR_TICK
		261
		262	Note that C<cf::wait_for_tick> is probably the correct thing to use. This
		263	variable contains a L<Coro::Signal> that is broadcats after every server
		264	tick. Calling C<< ->wait >> on it will suspend the caller until after the
		265	next server tick.
		266
		267	=cut
		268
		269	sub wait_for_tick();
		270	sub wait_for_tick_begin();
240		271
241	=item @cf::INVOKE_RESULTS	272	=item @cf::INVOKE_RESULTS
242		273
243	This array contains the results of the last C<invoke ()> call. When	274	This array contains the results of the last C<invoke ()> call. When
244	C<cf::override> is called C<@cf::INVOKE_RESULTS> is set to the parameters of	275	C<cf::override> is called C<@cf::INVOKE_RESULTS> is set to the parameters of
…		…
307	}	338	}
308		339
309	$EV::DIED = sub {	340	$EV::DIED = sub {
310	Carp::cluck "error in event callback: @_";	341	Carp::cluck "error in event callback: @_";
311	};	342	};
		343
		344	#############################################################################
		345
		346	sub fork_call(&@);
		347	sub get_slot($;$$);
312		348
313	#############################################################################	349	#############################################################################
314		350
315	=head2 UTILITY FUNCTIONS	351	=head2 UTILITY FUNCTIONS
316		352
…		…
337	$d =~ s/([\x00-\x07\x09\x0b\x0c\x0e-\x1f])/sprintf "\\x%02x", ord($1)/ge;	373	$d =~ s/([\x00-\x07\x09\x0b\x0c\x0e-\x1f])/sprintf "\\x%02x", ord($1)/ge;
338	$d	374	$d
339	} || "[unable to dump $_[0]: '$@']";	375	} || "[unable to dump $_[0]: '$@']";
340	}	376	}
341		377
		378	=item $scalar = cf::load_file $path
		379
		380	Loads the given file from path and returns its contents. Croaks on error
		381	and can block.
		382
		383	=cut
		384
		385	sub load_file($) {
		386	0 <= aio_load $_[0], my $data
		387	or Carp::croak "$_[0]: $!";
		388
		389	$data
		390	}
		391
		392	=item $success = cf::replace_file $path, $data, $sync
		393
		394	Atomically replaces the file at the given $path with new $data, and
		395	optionally $sync the data to disk before replacing the file.
		396
		397	=cut
		398
		399	sub replace_file($$;$) {
		400	my ($path, $data, $sync) = @_;
		401
		402	my $lock = cf::lock_acquire ("replace_file:$path");
		403
		404	my $fh = aio_open "$path~", Fcntl::O_WRONLY | Fcntl::O_CREAT | Fcntl::O_TRUNC, 0644
		405	or return;
		406
		407	$data = $data->() if ref $data;
		408
		409	length $data == aio_write $fh, 0, (length $data), $data, 0
		410	or return;
		411
		412	!$sync
		413	or !aio_fsync $fh
		414	or return;
		415
		416	aio_close $fh
		417	and return;
		418
		419	aio_rename "$path~", $path
		420	and return;
		421
		422	if ($sync) {
		423	$path =~ s%/[^/]*$%%;
		424	aio_pathsync $path;
		425	}
		426
		427	1
		428	}
		429
342	=item $ref = cf::decode_json $json	430	=item $ref = cf::decode_json $json
343		431
344	Converts a JSON string into the corresponding perl data structure.	432	Converts a JSON string into the corresponding perl data structure.
345		433
346	=item $json = cf::encode_json $ref	434	=item $json = cf::encode_json $ref
…		…
352	our $json_coder = JSON::XS->new->utf8->max_size (1e6); # accept ~1mb max	440	our $json_coder = JSON::XS->new->utf8->max_size (1e6); # accept ~1mb max
353		441
354	sub encode_json($) { $json_coder->encode ($_[0]) }	442	sub encode_json($) { $json_coder->encode ($_[0]) }
355	sub decode_json($) { $json_coder->decode ($_[0]) }	443	sub decode_json($) { $json_coder->decode ($_[0]) }
356		444
		445	=item $ref = cf::decode_storable $scalar
		446
		447	Same as Coro::Storable::thaw, so blocks.
		448
		449	=cut
		450
		451	BEGIN { *decode_storable = \&Coro::Storable::thaw }
		452
		453	=item $ref = cf::decode_yaml $scalar
		454
		455	Same as YAML::XS::Load, but doesn't leak, because it forks (and thus blocks).
		456
		457	=cut
		458
		459	sub decode_yaml($) {
		460	fork_call { YAML::XS::Load $_[0] } @_
		461	}
		462
		463	=item $scalar = cf::unlzf $scalar
		464
		465	Same as Compress::LZF::compress, but takes server ticks into account, so
		466	blocks.
		467
		468	=cut
		469
		470	sub unlzf($) {
		471	# we assume 100mb/s minimum decompression speed (noncompressible data on a ~2ghz machine)
		472	cf::get_slot +(length $_[0]) / 100_000_000, 0, "unlzf";
		473	Compress::LZF::decompress $_[0]
		474	}
		475
357	=item cf::post_init { BLOCK }	476	=item cf::post_init { BLOCK }
358		477
359	Execute the given codeblock, I<after> all extensions have been (re-)loaded,	478	Execute the given codeblock, I<after> all extensions have been (re-)loaded,
360	but I<before> the server starts ticking again.	479	but I<before> the server starts ticking again.
361		480
362	The cdoeblock will have a single boolean argument to indicate whether this	481	The codeblock will have a single boolean argument to indicate whether this
363	is a reload or not.	482	is a reload or not.
364		483
365	=cut	484	=cut
366		485
367	sub post_init(&) {	486	sub post_init(&) {
368	push @POST_INIT, shift;	487	push @POST_INIT, shift;
		488	}
		489
		490	sub _post_init {
		491	trace "running post_init jobs";
		492
		493	# run them in parallel...
		494
		495	my @join;
		496
		497	while () {
		498	push @join, map &Coro::async ($_, 0), @POST_INIT;
		499	@POST_INIT = ();
		500
		501	@join or last;
		502
		503	(pop @join)->join;
		504	}
369	}	505	}
370		506
371	=item cf::lock_wait $string	507	=item cf::lock_wait $string
372		508
373	Wait until the given lock is available. See cf::lock_acquire.	509	Wait until the given lock is available. See cf::lock_acquire.
…		…
426	EV::periodic $start, $interval, 0, $cb	562	EV::periodic $start, $interval, 0, $cb
427	}	563	}
428		564
429	=item cf::get_slot $time[, $priority[, $name]]	565	=item cf::get_slot $time[, $priority[, $name]]
430		566
431	Allocate $time seconds of blocking CPU time at priority C<$priority>:	567	Allocate $time seconds of blocking CPU time at priority C<$priority>
432	This call blocks and returns only when you have at least C<$time> seconds	568	(default: 0): This call blocks and returns only when you have at least
433	of cpu time till the next tick. The slot is only valid till the next cede.	569	C<$time> seconds of cpu time till the next tick. The slot is only valid
		570	till the next cede.
		571
		572	Background jobs should use a priority les than zero, interactive jobs
		573	should use 100 or more.
434		574
435	The optional C<$name> can be used to identify the job to run. It might be	575	The optional C<$name> can be used to identify the job to run. It might be
436	used for statistical purposes and should identify the same time-class.	576	used for statistical purposes and should identify the same time-class.
437		577
438	Useful for short background jobs.	578	Useful for short background jobs.
…		…
467	}	607	}
468	}	608	}
469		609
470	if (@SLOT_QUEUE) {	610	if (@SLOT_QUEUE) {
471	# we do not use wait_for_tick() as it returns immediately when tick is inactive	611	# we do not use wait_for_tick() as it returns immediately when tick is inactive
472	push @cf::WAIT_FOR_TICK, $signal;	612	$WAIT_FOR_TICK->wait;
473	$signal->wait;
474	} else {	613	} else {
475	$busy = 0;	614	$busy = 0;
476	Coro::schedule;	615	Coro::schedule;
477	}	616	}
478	}	617	}
…		…
518	=cut	657	=cut
519		658
520	sub sync_job(&) {	659	sub sync_job(&) {
521	my ($job) = @_;	660	my ($job) = @_;
522		661
523	if ($Coro::current == $Coro::main) {	662	if (in_main) {
524	my $time = AE::time;	663	my $time = AE::time;
525		664
526	# this is the main coro, too bad, we have to block	665	# this is the main coro, too bad, we have to block
527	# till the operation succeeds, freezing the server :/	666	# till the operation succeeds, freezing the server :/
528		667
529	LOG llevError, Carp::longmess "sync job";#d#	668	#LOG llevError, Carp::longmess "sync job";#d#
530		669
531	my $freeze_guard = freeze_mainloop;	670	my $freeze_guard = freeze_mainloop;
532		671
533	my $busy = 1;	672	my $busy = 1;
534	my @res;	673	my @res;
…		…
578	$EXT_CORO{$coro+0} = $coro;	717	$EXT_CORO{$coro+0} = $coro;
579		718
580	$coro	719	$coro
581	}	720	}
582		721
583	=item fork_call { }, $args	722	=item fork_call { }, @args
584		723
585	Executes the given code block with the given arguments in a seperate	724	Executes the given code block with the given arguments in a seperate
586	process, returning the results. Everything must be serialisable with	725	process, returning the results. Everything must be serialisable with
587	Coro::Storable. May, of course, block. Note that the executed sub may	726	Coro::Storable. May, of course, block. Note that the executed sub may
588	never block itself or use any form of event handling.	727	never block itself or use any form of event handling.
589		728
590	=cut	729	=cut
591		730
		731	sub post_fork {
		732	reset_signals;
		733	}
		734
592	sub fork_call(&@) {	735	sub fork_call(&@) {
593	my ($cb, @args) = @_;	736	my ($cb, @args) = @_;
594		737
595	# we seemingly have to make a local copy of the whole thing,	738	# we seemingly have to make a local copy of the whole thing,
596	# otherwise perl prematurely frees the stuff :/	739	# otherwise perl prematurely frees the stuff :/
597	# TODO: investigate and fix (likely this will be rather laborious)	740	# TODO: investigate and fix (likely this will be rather laborious)
598		741
599	my @res = Coro::Util::fork_eval {	742	my @res = Coro::Util::fork_eval {
600	reset_signals;	743	cf::post_fork;
601	&$cb	744	&$cb
602	}, @args;	745	} @args;
603		746
604	wantarray ? @res : $res[-1]	747	wantarray ? @res : $res[-1]
605	}	748	}
606		749
607	sub objinfo {	750	sub objinfo {
…		…
657	within each server.	800	within each server.
658		801
659	=cut	802	=cut
660		803
661	sub db_table($) {	804	sub db_table($) {
		805	cf::error "db_get called from main context"
		806	if $Coro::current == $Coro::main;
		807
662	my ($name) = @_;	808	my ($name) = @_;
663	my $db = BDB::db_create $DB_ENV;	809	my $db = BDB::db_create $DB_ENV;
664		810
665	eval {	811	eval {
666	$db->set_flags (BDB::CHKSUM);	812	$db->set_flags (BDB::CHKSUM);
…		…
676	}	822	}
677		823
678	our $DB;	824	our $DB;
679		825
680	sub db_init {	826	sub db_init {
681	cf::sync_job {
682	$DB ||= db_table "db";	827	$DB ||= db_table "db";
683	};
684	}	828	}
685		829
686	sub db_get($$) {	830	sub db_get($$) {
687	my $key = "$_[0]/$_[1]";	831	my $key = "$_[0]/$_[1]";
688		832
689	cf::sync_job {	833	cf::error "db_get called from main context"
		834	if $Coro::current == $Coro::main;
		835
690	BDB::db_get $DB, undef, $key, my $data;	836	BDB::db_get $DB, undef, $key, my $data;
691		837
692	$! ? ()	838	$! ? ()
693	: $data	839	: $data
694	}
695	}	840	}
696		841
697	sub db_put($$$) {	842	sub db_put($$$) {
698	BDB::dbreq_pri 4;	843	BDB::dbreq_pri 4;
699	BDB::db_put $DB, undef, "$_[0]/$_[1]", $_[2], 0, sub { };	844	BDB::db_put $DB, undef, "$_[0]/$_[1]", $_[2], 0, sub { };
…		…
727		872
728	my @data;	873	my @data;
729	my $md5;	874	my $md5;
730		875
731	for (0 .. $#$src) {	876	for (0 .. $#$src) {
732	0 <= aio_load $src->[$_], $data[$_]	877	$data[$_] = load_file $src->[$_];
733	or Carp::croak "$src->[$_]: $!";
734	}	878	}
735		879
736	# if processing is expensive, check	880	# if processing is expensive, check
737	# checksum first	881	# checksum first
738	if (1) {	882	if (1) {
…		…
1356	my ($pl, $buf) = @_;	1500	my ($pl, $buf) = @_;
1357		1501
1358	my $msg = eval { $pl->ns->{json_coder}->decode ($buf) };	1502	my $msg = eval { $pl->ns->{json_coder}->decode ($buf) };
1359		1503
1360	if (ref $msg) {	1504	if (ref $msg) {
1361	my ($type, $reply, @payload) =	1505	my ($type, $reply, @payload) = @$msg; # version 1 used %type, $id, %$hash
1362	"ARRAY" eq ref $msg
1363	? @$msg
1364	: ($msg->{msgtype}, $msg->{msgid}, %$msg); # TODO: version 1, remove
1365		1506
1366	my @reply;	1507	my @reply;
1367		1508
1368	if (my $cb = $EXTCMD{$type}) {	1509	if (my $cb = $EXTCMD{$type}) {
1369	@reply = $cb->($pl, @payload);	1510	@reply = $cb->($pl, @payload);
…		…
1391	};	1532	};
1392		1533
1393	$grp	1534	$grp
1394	}	1535	}
1395		1536
		1537	sub _ext_cfg_reg($$$$) {
		1538	my ($rvar, $varname, $cfgname, $default) = @_;
		1539
		1540	$cfgname = lc $varname
		1541	unless length $cfgname;
		1542
		1543	$EXT_CFG{$cfgname} = [$rvar, $default];
		1544
		1545	$$rvar = exists $CFG{$cfgname} ? $CFG{$cfgname} : $default;
		1546	}
		1547
1396	sub load_extensions {	1548	sub load_extensions {
1397	info "loading extensions...";	1549	info "loading extensions...";
		1550
		1551	%EXT_CFG = ();
1398		1552
1399	cf::sync_job {	1553	cf::sync_job {
1400	my %todo;	1554	my %todo;
1401		1555
1402	for my $path (<$LIBDIR/*.ext>) {	1556	for my $path (<$LIBDIR/*.ext>) {
…		…
1421		1575
1422	$ext{meta} = { map { (split /=/, $_, 2)[0, 1] } split /\s+/, $1 }	1576	$ext{meta} = { map { (split /=/, $_, 2)[0, 1] } split /\s+/, $1 }
1423	if $source =~ /\A#!.*?perl.*?#\s*(.*)$/m;	1577	if $source =~ /\A#!.*?perl.*?#\s*(.*)$/m;
1424		1578
1425	$ext{source} =	1579	$ext{source} =
1426	"package $pkg; use 5.10.0; use strict 'vars', 'subs'; use utf8;\n"	1580	"package $pkg; use common::sense;\n"
1427	. "#line 1 \"$path\"\n{\n"	1581	. "#line 1 \"$path\"\n{\n"
1428	. $source	1582	. $source
1429	. "\n};\n1";	1583	. "\n};\n1";
1430		1584
1431	$todo{$base} = \%ext;	1585	$todo{$base} = \%ext;
…		…
1445	unless exists $done{$_};	1599	unless exists $done{$_};
1446	}	1600	}
1447		1601
1448	trace "... pass $pass, loading '$k' into '$v->{pkg}'\n";	1602	trace "... pass $pass, loading '$k' into '$v->{pkg}'\n";
1449		1603
		1604	my $source = $v->{source};
		1605
		1606	# support "CONF varname :confname = default" pseudo-statements
		1607	$source =~ s{
		1608	^ CONF \s+ ([^\s:=]+) \s* (?:: \s* ([^\s:=]+) \s* )? = ([^\n#]+)
		1609	}{
		1610	"our \$$1; BEGIN { cf::_ext_cfg_reg \\\$$1, q\x00$1\x00, q\x00$2\x00, $3 }";
		1611	}gmxe;
		1612
1450	my $active = eval $v->{source};	1613	my $active = eval $source;
1451		1614
1452	if (length $@) {	1615	if (length $@) {
1453	error "$v->{path}: $@\n";	1616	error "$v->{path}: $@\n";
1454		1617
1455	cf::cleanup "mandatory extension '$k' failed to load, exiting."	1618	cf::cleanup "mandatory extension '$k' failed to load, exiting."
…		…
1472		1635
1473	while (my ($k, $v) = each %todo) {	1636	while (my ($k, $v) = each %todo) {
1474	cf::cleanup "mandatory extension '$k' has unresolved dependencies, exiting."	1637	cf::cleanup "mandatory extension '$k' has unresolved dependencies, exiting."
1475	if exists $v->{meta}{mandatory};	1638	if exists $v->{meta}{mandatory};
1476	}	1639	}
		1640
		1641	last;
1477	}	1642	}
1478	}	1643	}
1479	};	1644	};
1480	}	1645	}
1481		1646
…		…
1639	my $name = $pl->ob->name;	1804	my $name = $pl->ob->name;
1640		1805
1641	$pl->{deny_save} = 1;	1806	$pl->{deny_save} = 1;
1642	$pl->password ("*"); # this should lock out the player until we have nuked the dir	1807	$pl->password ("*"); # this should lock out the player until we have nuked the dir
1643		1808
1644	$pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active;	1809	$pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->ns;
1645	$pl->deactivate;	1810	$pl->deactivate;
		1811
1646	my $killer = cf::arch::get "killer_quit"; $pl->killer ($killer); $killer->destroy;	1812	my $killer = cf::arch::get "killer_quit"; $pl->killer ($killer); $killer->destroy;
1647	$pl->invoke (cf::EVENT_PLAYER_QUIT);	1813	$pl->invoke (cf::EVENT_PLAYER_QUIT) if $pl->ns;
		1814	ext::highscore::check ($pl->ob);
		1815
1648	$pl->ns->destroy if $pl->ns;	1816	$pl->ns->destroy if $pl->ns;
1649		1817
1650	my $path = playerdir $pl;	1818	my $path = playerdir $pl;
1651	my $temp = "$path~$cf::RUNTIME~deleting~";	1819	my $temp = "$path~$cf::RUNTIME~deleting~";
1652	aio_rename $path, $temp;	1820	aio_rename $path, $temp;
…		…
1818	sub generate_random_map {	1986	sub generate_random_map {
1819	my ($self, $rmp) = @_;	1987	my ($self, $rmp) = @_;
1820		1988
1821	my $lock = cf::lock_acquire "generate_random_map"; # the random map generator is NOT reentrant ATM	1989	my $lock = cf::lock_acquire "generate_random_map"; # the random map generator is NOT reentrant ATM
1822		1990
1823	# mit "rum" bekleckern, nicht
1824	$self->_create_random_map (	1991	$self->_create_random_map ($rmp);
1825	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
1826	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle}, $rmp->{miningstyle},
1827	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
1828	$rmp->{exit_on_final_map},
1829	$rmp->{xsize}, $rmp->{ysize},
1830	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
1831	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
1832	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
1833	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
1834	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
1835	(cf::region::find $rmp->{region}), $rmp->{custom}
1836	)
1837	}	1992	}
1838		1993
1839	=item cf::map->register ($regex, $prio)	1994	=item cf::map->register ($regex, $prio)
1840		1995
1841	Register a handler for the map path matching the given regex at the	1996	Register a handler for the map path matching the given regex at the
…		…
1846		2001
1847	sub register {	2002	sub register {
1848	my (undef, $regex, $prio) = @_;	2003	my (undef, $regex, $prio) = @_;
1849	my $pkg = caller;	2004	my $pkg = caller;
1850		2005
1851	no strict;
1852	push @{"$pkg\::ISA"}, __PACKAGE__;	2006	push @{"$pkg\::ISA"}, __PACKAGE__;
1853		2007
1854	$EXT_MAP{$pkg} = [$prio, qr<$regex>];	2008	$EXT_MAP{$pkg} = [$prio, qr<$regex>];
1855	}	2009	}
1856		2010
…		…
1868	}	2022	}
1869		2023
1870	sub normalise {	2024	sub normalise {
1871	my ($path, $base) = @_;	2025	my ($path, $base) = @_;
1872		2026
1873	$path = "$path"; # make sure its a string	2027	$path = "$path"; # make sure it's a string
1874		2028
1875	$path =~ s/\.map$//;	2029	$path =~ s/\.map$//;
1876		2030
1877	# map plan:	2031	# map plan:
1878	#	2032	#
…		…
1893	$base =~ s{[^/]+/?$}{};	2047	$base =~ s{[^/]+/?$}{};
1894	$path = "$base/$path";	2048	$path = "$base/$path";
1895	}	2049	}
1896		2050
1897	for ($path) {	2051	for ($path) {
1898	redo if s{//}{/};
1899	redo if s{/\.?/}{/};	2052	redo if s{/\.?/}{/};
1900	redo if s{/[^/]+/\.\./}{/};	2053	redo if s{/[^/]+/\.\./}{/};
1901	}	2054	}
1902		2055
1903	$path	2056	$path
…		…
1917	$self->init; # pass $1 etc.	2070	$self->init; # pass $1 etc.
1918	return $self;	2071	return $self;
1919	}	2072	}
1920	}	2073	}
1921		2074
1922	Carp::cluck "unable to resolve path '$path' (base '$base').";	2075	Carp::cluck "unable to resolve path '$path' (base '$base')";
1923	()	2076	()
1924	}	2077	}
1925		2078
		2079	# may re-bless or do other evil things
1926	sub init {	2080	sub init {
1927	my ($self) = @_;	2081	my ($self) = @_;
1928		2082
1929	$self	2083	$self
1930	}	2084	}
…		…
1995	$self->{load_path} = $path;	2149	$self->{load_path} = $path;
1996		2150
1997	1	2151	1
1998	}	2152	}
1999		2153
		2154	# used to laod the header of an original map
2000	sub load_header_orig {	2155	sub load_header_orig {
2001	my ($self) = @_;	2156	my ($self) = @_;
2002		2157
2003	$self->load_header_from ($self->load_path)	2158	$self->load_header_from ($self->load_path)
2004	}	2159	}
2005		2160
		2161	# used to laod the header of an instantiated map
2006	sub load_header_temp {	2162	sub load_header_temp {
2007	my ($self) = @_;	2163	my ($self) = @_;
2008		2164
2009	$self->load_header_from ($self->save_path)	2165	$self->load_header_from ($self->save_path)
2010	}	2166	}
2011		2167
		2168	# called after loading the header from an instantiated map
2012	sub prepare_temp {	2169	sub prepare_temp {
2013	my ($self) = @_;	2170	my ($self) = @_;
2014		2171
2015	$self->last_access ((delete $self->{last_access})	2172	$self->last_access ((delete $self->{last_access})
2016	|| $cf::RUNTIME); #d#	2173	|| $cf::RUNTIME); #d#
2017	# safety	2174	# safety
2018	$self->{instantiate_time} = $cf::RUNTIME	2175	$self->{instantiate_time} = $cf::RUNTIME
2019	if $self->{instantiate_time} > $cf::RUNTIME;	2176	if $self->{instantiate_time} > $cf::RUNTIME;
2020	}	2177	}
2021		2178
		2179	# called after loading the header from an original map
2022	sub prepare_orig {	2180	sub prepare_orig {
2023	my ($self) = @_;	2181	my ($self) = @_;
2024		2182
2025	$self->{load_original} = 1;	2183	$self->{load_original} = 1;
2026	$self->{instantiate_time} = $cf::RUNTIME;	2184	$self->{instantiate_time} = $cf::RUNTIME;
…		…
2050		2208
2051	sub find;	2209	sub find;
2052	sub find {	2210	sub find {
2053	my ($path, $origin) = @_;	2211	my ($path, $origin) = @_;
2054		2212
		2213	cf::cede_to_tick;
		2214
2055	$path = normalise $path, $origin && $origin->path;	2215	$path = normalise $path, $origin;
2056		2216
2057	my $guard1 = cf::lock_acquire "map_data:$path";#d#remove	2217	my $guard1 = cf::lock_acquire "map_data:$path";#d#remove
2058	my $guard2 = cf::lock_acquire "map_find:$path";	2218	my $guard2 = cf::lock_acquire "map_find:$path";
2059		2219
2060	$cf::MAP{$path} || do {	2220	$cf::MAP{$path} || do {
…		…
2091		2251
2092	{	2252	{
2093	my $guard = cf::lock_acquire "map_data:$path";	2253	my $guard = cf::lock_acquire "map_data:$path";
2094		2254
2095	return unless $self->valid;	2255	return unless $self->valid;
2096	return unless $self->in_memory == cf::MAP_SWAPPED;	2256	return unless $self->state == cf::MAP_SWAPPED;
2097
2098	$self->in_memory (cf::MAP_LOADING);
2099		2257
2100	$self->alloc;	2258	$self->alloc;
2101		2259
2102	$self->pre_load;	2260	$self->pre_load;
2103	cf::cede_to_tick;	2261	cf::cede_to_tick;
2104		2262
		2263	if (exists $self->{load_path}) {
2105	my $f = new_from_file cf::object::thawer $self->{load_path};	2264	my $f = new_from_file cf::object::thawer $self->{load_path};
2106	$f->skip_block;	2265	$f->skip_block;
2107	$self->_load_objects ($f)	2266	$self->_load_objects ($f)
2108	or return;	2267	or return;
2109		2268
2110	$self->post_load_original	2269	$self->post_load_original
2111	if delete $self->{load_original};	2270	if delete $self->{load_original};
2112		2271
2113	if (my $uniq = $self->uniq_path) {	2272	if (my $uniq = $self->uniq_path) {
2114	utf8::encode $uniq;	2273	utf8::encode $uniq;
2115	unless (aio_stat $uniq) {	2274	unless (aio_stat $uniq) {
2116	if (my $f = new_from_file cf::object::thawer $uniq) {	2275	if (my $f = new_from_file cf::object::thawer $uniq) {
2117	$self->clear_unique_items;	2276	$self->clear_unique_items;
2118	$self->_load_objects ($f);	2277	$self->_load_objects ($f);
2119	$f->resolve_delayed_derefs;	2278	$f->resolve_delayed_derefs;
		2279	}
2120	}	2280	}
2121	}	2281	}
2122	}
2123		2282
2124	$f->resolve_delayed_derefs;	2283	$f->resolve_delayed_derefs;
		2284	} else {
		2285	$self->post_load_original
		2286	if delete $self->{load_original};
		2287	}
		2288
		2289	$self->state (cf::MAP_INACTIVE);
2125		2290
2126	cf::cede_to_tick;	2291	cf::cede_to_tick;
2127	# now do the right thing for maps	2292	# now do the right thing for maps
2128	$self->link_multipart_objects;	2293	$self->link_multipart_objects;
2129	$self->difficulty ($self->estimate_difficulty)	2294	$self->difficulty ($self->estimate_difficulty)
…		…
2133	unless ($self->{deny_activate}) {	2298	unless ($self->{deny_activate}) {
2134	$self->decay_objects;	2299	$self->decay_objects;
2135	$self->fix_auto_apply;	2300	$self->fix_auto_apply;
2136	$self->update_buttons;	2301	$self->update_buttons;
2137	cf::cede_to_tick;	2302	cf::cede_to_tick;
2138	$self->activate;	2303	#$self->activate; # no longer activate maps automatically
2139	}	2304	}
2140		2305
2141	$self->{last_save} = $cf::RUNTIME;	2306	$self->{last_save} = $cf::RUNTIME;
2142	$self->last_access ($cf::RUNTIME);	2307	$self->last_access ($cf::RUNTIME);
2143
2144	$self->in_memory (cf::MAP_ACTIVE);
2145	}	2308	}
2146		2309
2147	$self->post_load;	2310	$self->post_load;
		2311
		2312	1
2148	}	2313	}
2149		2314
2150	# customize the map for a given player, i.e.	2315	# customize the map for a given player, i.e.
2151	# return the _real_ map. used by e.g. per-player	2316	# return the _real_ map. used by e.g. per-player
2152	# maps to change the path to ~playername/mappath	2317	# maps to change the path to ~playername/mappath
…		…
2160	# if $self->per_party;	2325	# if $self->per_party;
2161		2326
2162	$self	2327	$self
2163	}	2328	}
2164		2329
2165	# find and load all maps in the 3x3 area around a map
2166	sub load_neighbours {
2167	my ($map) = @_;
2168
2169	my @neigh; # diagonal neighbours
2170
2171	for (0 .. 3) {
2172	my $neigh = $map->tile_path ($_)
2173	or next;
2174	$neigh = find $neigh, $map
2175	or next;
2176	$neigh->load;
2177
2178	# now find the diagonal neighbours
2179	push @neigh,
2180	[$neigh->tile_path (($_ + 3) % 4), $neigh],
2181	[$neigh->tile_path (($_ + 1) % 4), $neigh];
2182	}
2183
2184	for (grep defined $_->[0], @neigh) {
2185	my ($path, $origin) = @$_;
2186	my $neigh = find $path, $origin
2187	or next;
2188	$neigh->load;
2189	}
2190	}
2191
2192	sub find_sync {	2330	sub find_sync {
2193	my ($path, $origin) = @_;	2331	my ($path, $origin) = @_;
2194		2332
2195	cf::sync_job { find $path, $origin }	2333	# it's a bug to call this from the main context
		2334	return cf::LOG cf::llevError | cf::logBacktrace, "do_find_sync"
		2335	if $Coro::current == $Coro::main;
		2336
		2337	find $path, $origin
2196	}	2338	}
2197		2339
2198	sub do_load_sync {	2340	sub do_load_sync {
2199	my ($map) = @_;	2341	my ($map) = @_;
2200		2342
		2343	# it's a bug to call this from the main context
2201	cf::LOG cf::llevDebug | cf::logBacktrace, "do_load_sync"	2344	return cf::LOG cf::llevError | cf::logBacktrace, "do_load_sync"
2202	if $Coro::current == $Coro::main;	2345	if $Coro::current == $Coro::main;
2203		2346
2204	cf::sync_job { $map->load };	2347	$map->load;
2205	}	2348	}
2206		2349
2207	our %MAP_PREFETCH;	2350	our %MAP_PREFETCH;
2208	our $MAP_PREFETCHER = undef;	2351	our $MAP_PREFETCHER = undef;
2209		2352
2210	sub find_async {	2353	sub find_async {
2211	my ($path, $origin, $load) = @_;	2354	my ($path, $origin, $load) = @_;
2212		2355
2213	$path = normalise $path, $origin && $origin->{path};	2356	$path = normalise $path, $origin;
2214		2357
2215	if (my $map = $cf::MAP{$path}) {	2358	if (my $map = $cf::MAP{$path}) {
2216	return $map if !$load || $map->in_memory == cf::MAP_ACTIVE;	2359	return $map if !$load || $map->linkable;
2217	}	2360	}
2218		2361
2219	$MAP_PREFETCH{$path} |= $load;	2362	$MAP_PREFETCH{$path} |= $load;
2220		2363
2221	$MAP_PREFETCHER ||= cf::async {	2364	$MAP_PREFETCHER ||= cf::async {
…		…
2280	sub swap_out {	2423	sub swap_out {
2281	my ($self) = @_;	2424	my ($self) = @_;
2282		2425
2283	my $lock = cf::lock_acquire "map_data:$self->{path}";	2426	my $lock = cf::lock_acquire "map_data:$self->{path}";
2284		2427
2285	return if $self->in_memory != cf::MAP_ACTIVE;	2428	return if !$self->linkable;
2286	return if $self->{deny_save};	2429	return if $self->{deny_save};
2287	return if $self->players;	2430	return if $self->players;
2288		2431
2289	# first deactivate the map and "unlink" it from the core	2432	# first deactivate the map and "unlink" it from the core
2290	$self->deactivate;	2433	$self->deactivate;
2291	$_->clear_links_to ($self) for values %cf::MAP;	2434	$_->clear_links_to ($self) for values %cf::MAP;
2292	$self->in_memory (cf::MAP_SWAPPED);	2435	$self->state (cf::MAP_SWAPPED);
2293		2436
2294	# then atomically save	2437	# then atomically save
2295	$self->_save;	2438	$self->_save;
2296		2439
2297	# then free the map	2440	# then free the map
…		…
2323		2466
2324	return if $self->players;	2467	return if $self->players;
2325		2468
2326	cf::trace "resetting map ", $self->path, "\n";	2469	cf::trace "resetting map ", $self->path, "\n";
2327		2470
2328	$self->in_memory (cf::MAP_SWAPPED);	2471	$self->state (cf::MAP_SWAPPED);
2329		2472
2330	# need to save uniques path	2473	# need to save uniques path
2331	unless ($self->{deny_save}) {	2474	unless ($self->{deny_save}) {
2332	my $uniq = $self->uniq_path; utf8::encode $uniq;	2475	my $uniq = $self->uniq_path; utf8::encode $uniq;
2333		2476
…		…
2663	# use -1 or undef as default coordinates, not 0, 0	2806	# use -1 or undef as default coordinates, not 0, 0
2664	($x, $y) = ($map->enter_x, $map->enter_y)	2807	($x, $y) = ($map->enter_x, $map->enter_y)
2665	if $x <= 0 && $y <= 0;	2808	if $x <= 0 && $y <= 0;
2666		2809
2667	$map->load;	2810	$map->load;
2668	$map->load_neighbours;
2669		2811
2670	return unless $self->contr->active;	2812	return unless $self->contr->active;
2671		2813
2672	local $self->{_prev_pos} = $link_pos; # ugly hack for rent.ext	2814	local $self->{_prev_pos} = $link_pos; # ugly hack for rent.ext
2673	if ($self->enter_map ($map, $x, $y)) {	2815	if ($self->enter_map ($map, $x, $y)) {
…		…
2729	($path, $x, $y) = (undef, undef, undef);	2871	($path, $x, $y) = (undef, undef, undef);
2730	}	2872	}
2731	}	2873	}
2732		2874
2733	my $map = eval {	2875	my $map = eval {
2734	my $map = defined $path ? cf::map::find $path : undef;	2876	my $map = defined $path ? cf::map::find $path, $self->map : undef;
2735		2877
2736	if ($map) {	2878	if ($map) {
2737	$map = $map->customise_for ($self);	2879	$map = $map->customise_for ($self);
2738	$map = $check->($map, $x, $y, $self) if $check && $map;	2880	$map = $check->($map, $x, $y, $self) if $check && $map;
2739	} else {	2881	} else {
…		…
2829	$Coro::current->{desc} = "enter_exit";	2971	$Coro::current->{desc} = "enter_exit";
2830		2972
2831	unless (eval {	2973	unless (eval {
2832	$self->deactivate_recursive; # just to be sure	2974	$self->deactivate_recursive; # just to be sure
2833		2975
2834	# random map handling
2835	{
2836	my $guard = cf::lock_acquire "exit_prepare:$exit";
2837
2838	prepare_random_map $exit
2839	if $exit->slaying eq "/!";
2840	}
2841
2842	my $map = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;	2976	my $map = cf::map::normalise $exit->slaying, $exit->map;
2843	my $x = $exit->stats->hp;	2977	my $x = $exit->stats->hp;
2844	my $y = $exit->stats->sp;	2978	my $y = $exit->stats->sp;
		2979
		2980	# special map handling
		2981	my $slaying = $exit->slaying;
		2982
		2983	# special map handling
		2984	if ($slaying eq "/!") {
		2985	my $guard = cf::lock_acquire "exit_prepare:$exit";
		2986
		2987	prepare_random_map $exit
		2988	if $exit->slaying eq "/!"; # need to re-check after getting the lock
		2989
		2990	$map = $exit->slaying;
		2991
		2992	} elsif ($slaying eq '!up') {
		2993	$map = $exit->map->tile_path (cf::TILE_UP);
		2994	$x = $exit->x;
		2995	$y = $exit->y;
		2996
		2997	} elsif ($slaying eq '!down') {
		2998	$map = $exit->map->tile_path (cf::TILE_DOWN);
		2999	$x = $exit->x;
		3000	$y = $exit->y;
		3001	}
2845		3002
2846	$self->goto ($map, $x, $y);	3003	$self->goto ($map, $x, $y);
2847		3004
2848	# if exit is damned, update players death & WoR home-position	3005	# if exit is damned, update players death & WoR home-position
2849	$self->contr->savebed ($map, $x, $y)	3006	$self->contr->savebed ($map, $x, $y)
…		…
3091	=cut	3248	=cut
3092		3249
3093	sub cf::client::ext_reply($$@) {	3250	sub cf::client::ext_reply($$@) {
3094	my ($self, $id, @msg) = @_;	3251	my ($self, $id, @msg) = @_;
3095		3252
3096	if ($self->extcmd == 2) {	3253	return unless $self->extcmd == 2;
		3254
3097	$self->send_big_packet ("ext " . $self->{json_coder}->encode (["reply-$id", @msg]));	3255	$self->send_big_packet ("ext " . $self->{json_coder}->encode (["reply-$id", @msg]));
3098	} elsif ($self->extcmd == 1) {
3099	#TODO: version 1, remove
3100	unshift @msg, msgtype => "reply", msgid => $id;
3101	$self->send_big_packet ("ext " . $self->{json_coder}->encode ({@msg}));
3102	}
3103	}	3256	}
3104		3257
3105	=item $success = $client->query ($flags, "text", \&cb)	3258	=item $success = $client->query ($flags, "text", \&cb)
3106		3259
3107	Queues a query to the client, calling the given callback with	3260	Queues a query to the client, calling the given callback with
…		…
3162	my ($ns, $buf) = @_;	3315	my ($ns, $buf) = @_;
3163		3316
3164	my $msg = eval { $ns->{json_coder}->decode ($buf) };	3317	my $msg = eval { $ns->{json_coder}->decode ($buf) };
3165		3318
3166	if (ref $msg) {	3319	if (ref $msg) {
3167	my ($type, $reply, @payload) =	3320	my ($type, $reply, @payload) = @$msg; # version 1 used %type, $id, %$hash
3168	"ARRAY" eq ref $msg
3169	? @$msg
3170	: ($msg->{msgtype}, $msg->{msgid}, %$msg); # TODO: version 1, remove
3171		3321
3172	my @reply;	3322	my @reply;
3173		3323
3174	if (my $cb = $EXTICMD{$type}) {	3324	if (my $cb = $EXTICMD{$type}) {
3175	@reply = $cb->($ns, @payload);	3325	@reply = $cb->($ns, @payload);
…		…
3268	decrease split destroy change_exp value msg lore send_msg)],	3418	decrease split destroy change_exp value msg lore send_msg)],
3269	["cf::object::player" => qw(player)],	3419	["cf::object::player" => qw(player)],
3270	["cf::player" => qw(peaceful send_msg)],	3420	["cf::player" => qw(peaceful send_msg)],
3271	["cf::map" => qw(trigger)],	3421	["cf::map" => qw(trigger)],
3272	) {	3422	) {
3273	no strict 'refs';
3274	my ($pkg, @funs) = @$_;	3423	my ($pkg, @funs) = @$_;
3275	*{"safe::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})	3424	*{"safe::$pkg\::$_"} = $safe_hole->wrap (\&{"$pkg\::$_"})
3276	for @funs;	3425	for @funs;
3277	}	3426	}
3278		3427
…		…
3365		3514
3366	my $enc = JSON::XS->new->utf8->canonical->relaxed;	3515	my $enc = JSON::XS->new->utf8->canonical->relaxed;
3367		3516
3368	trace "loading facedata from $path\n";	3517	trace "loading facedata from $path\n";
3369		3518
3370	my $facedata;	3519	my $facedata = decode_storable load_file $path;
3371	0 < aio_load $path, $facedata
3372	or die "$path: $!";
3373
3374	$facedata = Coro::Storable::thaw $facedata;
3375		3520
3376	$facedata->{version} == 2	3521	$facedata->{version} == 2
3377	or cf::cleanup "$path: version mismatch, cannot proceed.";	3522	or cf::cleanup "$path: version mismatch, cannot proceed.";
3378		3523
3379	# patch in the exptable	3524	# patch in the exptable
…		…
3393		3538
3394	cf::face::set_visibility $idx, $info->{visibility};	3539	cf::face::set_visibility $idx, $info->{visibility};
3395	cf::face::set_magicmap $idx, $info->{magicmap};	3540	cf::face::set_magicmap $idx, $info->{magicmap};
3396	cf::face::set_data $idx, 0, $info->{data32}, $info->{hash32};	3541	cf::face::set_data $idx, 0, $info->{data32}, $info->{hash32};
3397	cf::face::set_data $idx, 1, $info->{data64}, $info->{hash64};	3542	cf::face::set_data $idx, 1, $info->{data64}, $info->{hash64};
		3543	cf::face::set_data $idx, 2, $info->{glyph} , $info->{glyph} ;
3398		3544
3399	cf::cede_to_tick;	3545	cf::cede_to_tick;
3400	}	3546	}
3401		3547
3402	while (my ($face, $info) = each %$faces) {	3548	while (my ($face, $info) = each %$faces) {
…		…
3429		3575
3430	{	3576	{
3431	my $res = $facedata->{resource};	3577	my $res = $facedata->{resource};
3432		3578
3433	while (my ($name, $info) = each %$res) {	3579	while (my ($name, $info) = each %$res) {
3434	if (defined $info->{type}) {	3580	if (defined (my $type = $info->{type})) {
		3581	# TODO: different hash - must free and use new index, or cache ixface data queue
3435	my $idx = (cf::face::find $name) || cf::face::alloc $name;	3582	my $idx = (cf::face::find $name) || cf::face::alloc $name;
3436		3583
3437	cf::face::set_data $idx, 0, $info->{data}, $info->{hash};	3584	cf::face::set_data $idx, 0, $info->{data}, $info->{hash};
3438	cf::face::set_type $idx, $info->{type};	3585	cf::face::set_type $idx, $type;
		3586	cf::face::set_meta $idx, $type & 1 ? undef : $info->{meta}; # preserve meta unless prepended already
3439	} else {	3587	} else {
3440	$RESOURCE{$name} = $info; # unused	3588	# $RESOURCE{$name} = $info; # unused
3441	}	3589	}
3442		3590
3443	cf::cede_to_tick;	3591	cf::cede_to_tick;
3444	}	3592	}
3445	}	3593	}
…		…
3497	}	3645	}
3498		3646
3499	sub reload_sound {	3647	sub reload_sound {
3500	trace "loading sound config from $DATADIR/sound\n";	3648	trace "loading sound config from $DATADIR/sound\n";
3501		3649
3502	0 < Coro::AIO::aio_load "$DATADIR/sound", my $data
3503	or die "$DATADIR/sound $!";
3504
3505	my $soundconf = JSON::XS->new->utf8->relaxed->decode ($data);	3650	my $soundconf = JSON::XS->new->utf8->relaxed->decode (load_file "$DATADIR/sound");
3506		3651
3507	for (0 .. SOUND_CAST_SPELL_0 - 1) {	3652	for (0 .. SOUND_CAST_SPELL_0 - 1) {
3508	my $sound = $soundconf->{compat}[$_]	3653	my $sound = $soundconf->{compat}[$_]
3509	or next;	3654	or next;
3510		3655
…		…
3520	}	3665	}
3521		3666
3522	sub reload_resources {	3667	sub reload_resources {
3523	trace "reloading resource files...\n";	3668	trace "reloading resource files...\n";
3524		3669
		3670	reload_exp_table;
		3671	reload_materials;
3525	reload_facedata;	3672	reload_facedata;
3526	reload_sound;	3673	reload_sound;
3527	reload_archetypes;	3674	reload_archetypes;
3528	reload_regions;	3675	reload_regions;
3529	reload_treasures;	3676	reload_treasures;
…		…
3532	}	3679	}
3533		3680
3534	sub reload_config {	3681	sub reload_config {
3535	trace "reloading config file...\n";	3682	trace "reloading config file...\n";
3536		3683
3537	open my $fh, "<:utf8", "$CONFDIR/config"	3684	my $config = load_file "$CONFDIR/config";
3538	or return;	3685	utf8::decode $config;
3539		3686	*CFG = decode_yaml $config;
3540	local $/;
3541	*CFG = YAML::XS::Load scalar <$fh>;
3542		3687
3543	$EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_104_115", 49, 38];	3688	$EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_104_115", 49, 38];
3544		3689
3545	$cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};	3690	$cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
3546	$cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};	3691	$cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
…		…
3550	$CFG{mlockall} ? eval "mlockall()" : eval "munlockall()"	3695	$CFG{mlockall} ? eval "mlockall()" : eval "munlockall()"
3551	and die "WARNING: m(un)lockall failed: $!\n";	3696	and die "WARNING: m(un)lockall failed: $!\n";
3552	};	3697	};
3553	warn $@ if $@;	3698	warn $@ if $@;
3554	}	3699	}
3555
3556	trace "finished reloading resource files\n";
3557	}	3700	}
3558		3701
3559	sub pidfile() {	3702	sub pidfile() {
3560	sysopen my $fh, $PIDFILE, O_RDWR | O_CREAT	3703	sysopen my $fh, $PIDFILE, O_RDWR | O_CREAT
3561	or die "$PIDFILE: $!";	3704	or die "$PIDFILE: $!";
…		…
3586		3729
3587	sub main {	3730	sub main {
3588	cf::init_globals; # initialise logging	3731	cf::init_globals; # initialise logging
3589		3732
3590	LOG llevInfo, "Welcome to Deliantra, v" . VERSION;	3733	LOG llevInfo, "Welcome to Deliantra, v" . VERSION;
3591	LOG llevInfo, "Copyright (C) 2005-2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team.";	3734	LOG llevInfo, "Copyright (C) 2005-2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team.";
3592	LOG llevInfo, "Copyright (C) 1994 Mark Wedel.";	3735	LOG llevInfo, "Copyright (C) 1994 Mark Wedel.";
3593	LOG llevInfo, "Copyright (C) 1992 Frank Tore Johansen.";	3736	LOG llevInfo, "Copyright (C) 1992 Frank Tore Johansen.";
3594		3737
3595	$Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority	3738	$Coro::current->prio (Coro::PRIO_MAX); # give the main loop max. priority
3596		3739
…		…
3604	};	3747	};
3605		3748
3606	evthread_start IO::AIO::poll_fileno;	3749	evthread_start IO::AIO::poll_fileno;
3607		3750
3608	cf::sync_job {	3751	cf::sync_job {
3609	cf::init_experience;	3752	cf::incloader::init ();
		3753
3610	cf::init_anim;	3754	cf::init_anim;
3611	cf::init_attackmess;	3755	cf::init_attackmess;
3612	cf::init_dynamic;	3756	cf::init_dynamic;
3613		3757
3614	cf::load_settings;	3758	cf::load_settings;
3615	cf::load_materials;
3616		3759
3617	reload_resources;	3760	reload_resources;
3618	reload_config;	3761	reload_config;
3619	db_init;	3762	db_init;
3620		3763
…		…
3632		3775
3633	# no (long-running) fork's whatsoever before this point(!)	3776	# no (long-running) fork's whatsoever before this point(!)
3634	use POSIX ();	3777	use POSIX ();
3635	POSIX::close delete $ENV{LOCKUTIL_LOCK_FD} if exists $ENV{LOCKUTIL_LOCK_FD};	3778	POSIX::close delete $ENV{LOCKUTIL_LOCK_FD} if exists $ENV{LOCKUTIL_LOCK_FD};
3636		3779
3637	(pop @POST_INIT)->(0) while @POST_INIT;	3780	cf::_post_init 0;
3638	};	3781	};
3639		3782
3640	cf::object::thawer::errors_are_fatal 0;	3783	cf::object::thawer::errors_are_fatal 0;
3641	info "parse errors in files are no longer fatal from this point on.\n";	3784	info "parse errors in files are no longer fatal from this point on.\n";
3642		3785
		3786	AE::postpone {
		3787	undef &main; # free gobs of memory :)
		3788	};
		3789
3643	main_loop;	3790	goto &main_loop;
3644	}	3791	}
3645		3792
3646	#############################################################################	3793	#############################################################################
3647	# initialisation and cleanup	3794	# initialisation and cleanup
3648		3795
…		…
3747	sub emergency_save() {	3894	sub emergency_save() {
3748	my $freeze_guard = cf::freeze_mainloop;	3895	my $freeze_guard = cf::freeze_mainloop;
3749		3896
3750	info "emergency_perl_save: enter\n";	3897	info "emergency_perl_save: enter\n";
3751		3898
		3899	# this is a trade-off: we want to be very quick here, so
		3900	# save all maps without fsync, and later call a global sync
		3901	# (which in turn might be very very slow)
		3902	local $USE_FSYNC = 0;
		3903
3752	cf::sync_job {	3904	cf::sync_job {
3753	# this is a trade-off: we want to be very quick here, so	3905	cf::write_runtime_sync; # external watchdog should not bark
3754	# save all maps without fsync, and later call a global sync
3755	# (which in turn might be very very slow)
3756	local $USE_FSYNC = 0;
3757		3906
3758	# use a peculiar iteration method to avoid tripping on perl	3907	# use a peculiar iteration method to avoid tripping on perl
3759	# refcount bugs in for. also avoids problems with players	3908	# refcount bugs in for. also avoids problems with players
3760	# and maps saved/destroyed asynchronously.	3909	# and maps saved/destroyed asynchronously.
3761	info "emergency_perl_save: begin player save\n";	3910	info "emergency_perl_save: begin player save\n";
…		…
3765	delete $pl->{unclean_save}; # not strictly necessary, but cannot hurt	3914	delete $pl->{unclean_save}; # not strictly necessary, but cannot hurt
3766	$pl->save;	3915	$pl->save;
3767	}	3916	}
3768	info "emergency_perl_save: end player save\n";	3917	info "emergency_perl_save: end player save\n";
3769		3918
		3919	cf::write_runtime_sync; # external watchdog should not bark
		3920
3770	info "emergency_perl_save: begin map save\n";	3921	info "emergency_perl_save: begin map save\n";
3771	for my $path (keys %cf::MAP) {	3922	for my $path (keys %cf::MAP) {
3772	my $map = $cf::MAP{$path} or next;	3923	my $map = $cf::MAP{$path} or next;
3773	$map->valid or next;	3924	$map->valid or next;
3774	$map->save;	3925	$map->save;
3775	}	3926	}
3776	info "emergency_perl_save: end map save\n";	3927	info "emergency_perl_save: end map save\n";
3777		3928
		3929	cf::write_runtime_sync; # external watchdog should not bark
		3930
3778	info "emergency_perl_save: begin database checkpoint\n";	3931	info "emergency_perl_save: begin database checkpoint\n";
3779	BDB::db_env_txn_checkpoint $DB_ENV;	3932	BDB::db_env_txn_checkpoint $DB_ENV;
3780	info "emergency_perl_save: end database checkpoint\n";	3933	info "emergency_perl_save: end database checkpoint\n";
3781		3934
3782	info "emergency_perl_save: begin write uuid\n";	3935	info "emergency_perl_save: begin write uuid\n";
3783	write_uuid_sync 1;	3936	write_uuid_sync 1;
3784	info "emergency_perl_save: end write uuid\n";	3937	info "emergency_perl_save: end write uuid\n";
3785	};
3786		3938
		3939	cf::write_runtime_sync; # external watchdog should not bark
		3940
		3941	trace "emergency_perl_save: syncing database to disk";
		3942	BDB::db_env_txn_checkpoint $DB_ENV;
		3943
3787	info "emergency_perl_save: starting sync()\n";	3944	info "emergency_perl_save: starting sync\n";
3788	IO::AIO::aio_sync sub {	3945	IO::AIO::aio_sync sub {
3789	info "emergency_perl_save: finished sync()\n";	3946	info "emergency_perl_save: finished sync\n";
		3947	};
		3948
		3949	cf::write_runtime_sync; # external watchdog should not bark
		3950
		3951	trace "emergency_perl_save: flushing outstanding aio requests";
		3952	while (IO::AIO::nreqs || BDB::nreqs) {
		3953	Coro::AnyEvent::sleep 0.01; # let the sync_job do it's thing
		3954	}
		3955
		3956	cf::write_runtime_sync; # external watchdog should not bark
3790	};	3957	};
3791		3958
3792	info "emergency_perl_save: leave\n";	3959	info "emergency_perl_save: leave\n";
3793	}	3960	}
3794		3961
3795	sub post_cleanup {	3962	sub post_cleanup {
3796	my ($make_core) = @_;	3963	my ($make_core) = @_;
		3964
		3965	IO::AIO::flush;
3797		3966
3798	error Carp::longmess "post_cleanup backtrace"	3967	error Carp::longmess "post_cleanup backtrace"
3799	if $make_core;	3968	if $make_core;
3800		3969
3801	my $fh = pidfile;	3970	my $fh = pidfile;
…		…
3827	}	3996	}
3828	}	3997	}
3829		3998
3830	sub do_reload_perl() {	3999	sub do_reload_perl() {
3831	# can/must only be called in main	4000	# can/must only be called in main
3832	if (in_main) {	4001	unless (in_main) {
3833	error "can only reload from main coroutine";	4002	error "can only reload from main coroutine";
3834	return;	4003	return;
3835	}	4004	}
3836		4005
3837	return if $RELOAD++;	4006	return if $RELOAD++;
3838		4007
3839	my $t1 = AE::time;	4008	my $t1 = AE::time;
3840		4009
3841	while ($RELOAD) {	4010	while ($RELOAD) {
		4011	cf::get_slot 0.1, -1, "reload_perl";
3842	info "reloading...";	4012	info "perl_reload: reloading...";
3843		4013
3844	trace "entering sync_job";	4014	trace "perl_reload: entering sync_job";
3845		4015
3846	cf::sync_job {	4016	cf::sync_job {
3847	cf::write_runtime_sync; # external watchdog should not bark
3848	cf::emergency_save;	4017	#cf::emergency_save;
3849	cf::write_runtime_sync; # external watchdog should not bark
3850		4018
3851	trace "syncing database to disk";
3852	BDB::db_env_txn_checkpoint $DB_ENV;
3853
3854	# if anything goes wrong in here, we should simply crash as we already saved
3855
3856	trace "flushing outstanding aio requests";
3857	while (IO::AIO::nreqs || BDB::nreqs) {
3858	Coro::EV::timer_once 0.01; # let the sync_job do it's thing
3859	}
3860
3861	trace "cancelling all extension coros";	4019	trace "perl_reload: cancelling all extension coros";
3862	$_->cancel for values %EXT_CORO;	4020	$_->cancel for values %EXT_CORO;
3863	%EXT_CORO = ();	4021	%EXT_CORO = ();
3864		4022
3865	trace "removing commands";	4023	trace "perl_reload: removing commands";
3866	%COMMAND = ();	4024	%COMMAND = ();
3867		4025
3868	trace "removing ext/exti commands";	4026	trace "perl_reload: removing ext/exti commands";
3869	%EXTCMD = ();	4027	%EXTCMD = ();
3870	%EXTICMD = ();	4028	%EXTICMD = ();
3871		4029
3872	trace "unloading/nuking all extensions";	4030	trace "perl_reload: unloading/nuking all extensions";
3873	for my $pkg (@EXTS) {	4031	for my $pkg (@EXTS) {
3874	trace "... unloading $pkg";	4032	trace "... unloading $pkg";
3875		4033
3876	if (my $cb = $pkg->can ("unload")) {	4034	if (my $cb = $pkg->can ("unload")) {
3877	eval {	4035	eval {
…		…
3882		4040
3883	trace "... clearing $pkg";	4041	trace "... clearing $pkg";
3884	clear_package $pkg;	4042	clear_package $pkg;
3885	}	4043	}
3886		4044
3887	trace "unloading all perl modules loaded from $LIBDIR";	4045	trace "perl_reload: unloading all perl modules loaded from $LIBDIR";
3888	while (my ($k, $v) = each %INC) {	4046	while (my ($k, $v) = each %INC) {
3889	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;	4047	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
3890		4048
3891	trace "... unloading $k";	4049	trace "... unloading $k";
3892	delete $INC{$k};	4050	delete $INC{$k};
…		…
3899	}	4057	}
3900		4058
3901	clear_package $k;	4059	clear_package $k;
3902	}	4060	}
3903		4061
3904	trace "getting rid of safe::, as good as possible";	4062	trace "perl_reload: getting rid of safe::, as good as possible";
3905	clear_package "safe::$_"	4063	clear_package "safe::$_"
3906	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);	4064	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
3907		4065
3908	trace "unloading cf.pm \"a bit\"";	4066	trace "perl_reload: unloading cf.pm \"a bit\"";
3909	delete $INC{"cf.pm"};	4067	delete $INC{"cf.pm"};
3910	delete $INC{"cf/$_.pm"} for @EXTRA_MODULES;	4068	delete $INC{"cf/$_.pm"} for @EXTRA_MODULES;
3911		4069
3912	# don't, removes xs symbols, too,	4070	# don't, removes xs symbols, too,
3913	# and global variables created in xs	4071	# and global variables created in xs
3914	#clear_package __PACKAGE__;	4072	#clear_package __PACKAGE__;
3915		4073
3916	info "unload completed, starting to reload now";	4074	info "perl_reload: unload completed, starting to reload now";
3917		4075
3918	trace "reloading cf.pm";	4076	trace "perl_reload: reloading cf.pm";
3919	require cf;	4077	require cf;
3920	cf::_connect_to_perl_1;	4078	cf::_connect_to_perl_1;
3921		4079
3922	trace "loading config and database again";	4080	trace "perl_reload: loading config and database again";
3923	cf::reload_config;	4081	cf::reload_config;
3924		4082
3925	trace "loading extensions";	4083	trace "perl_reload: loading extensions";
3926	cf::load_extensions;	4084	cf::load_extensions;
3927		4085
3928	if ($REATTACH_ON_RELOAD) {	4086	if ($REATTACH_ON_RELOAD) {
3929	trace "reattaching attachments to objects/players";	4087	trace "perl_reload: reattaching attachments to objects/players";
3930	_global_reattach; # objects, sockets	4088	_global_reattach; # objects, sockets
3931	trace "reattaching attachments to maps";	4089	trace "perl_reload: reattaching attachments to maps";
3932	reattach $_ for values %MAP;	4090	reattach $_ for values %MAP;
3933	trace "reattaching attachments to players";	4091	trace "perl_reload: reattaching attachments to players";
3934	reattach $_ for values %PLAYER;	4092	reattach $_ for values %PLAYER;
3935	}	4093	}
3936		4094
3937	trace "running post_init jobs";	4095	cf::_post_init 1;
3938	(pop @POST_INIT)->(1) while @POST_INIT;
3939		4096
3940	trace "leaving sync_job";	4097	trace "perl_reload: leaving sync_job";
3941		4098
3942	1	4099	1
3943	} or do {	4100	} or do {
3944	error $@;	4101	error $@;
3945	cf::cleanup "error while reloading, exiting.";	4102	cf::cleanup "perl_reload: error, exiting.";
3946	};	4103	};
3947		4104
3948	info "reloaded";
3949	--$RELOAD;	4105	--$RELOAD;
3950	}	4106	}
3951		4107
3952	$t1 = AE::time - $t1;	4108	$t1 = AE::time - $t1;
3953	info "reload completed in ${t1}s\n";	4109	info "perl_reload: completed in ${t1}s\n";
3954	};	4110	};
3955		4111
3956	our $RELOAD_WATCHER; # used only during reload	4112	our $RELOAD_WATCHER; # used only during reload
3957		4113
3958	sub reload_perl() {	4114	sub reload_perl() {
…		…
3979	reload_perl;	4135	reload_perl;
3980	};	4136	};
3981	}	4137	}
3982	};	4138	};
3983		4139
3984	unshift @INC, $LIBDIR;	4140	#############################################################################
3985		4141
3986	my $bug_warning = 0;	4142	my $bug_warning = 0;
3987		4143
3988	our @WAIT_FOR_TICK;
3989	our @WAIT_FOR_TICK_BEGIN;
3990
3991	sub wait_for_tick {	4144	sub wait_for_tick() {
3992	return Coro::cede if tick_inhibit || $Coro::current == $Coro::main;	4145	return Coro::AnyEvent::poll if tick_inhibit || $Coro::current == $Coro::main;
3993		4146
3994	my $signal = new Coro::Signal;	4147	$WAIT_FOR_TICK->wait;
3995	push @WAIT_FOR_TICK, $signal;
3996	$signal->wait;
3997	}	4148	}
3998		4149
3999	sub wait_for_tick_begin {	4150	sub wait_for_tick_begin() {
4000	return Coro::cede if tick_inhibit || $Coro::current == $Coro::main;	4151	return Coro::AnyEvent::poll if tick_inhibit || $Coro::current == $Coro::main;
4001		4152
4002	my $signal = new Coro::Signal;	4153	my $signal = new Coro::Signal;
4003	push @WAIT_FOR_TICK_BEGIN, $signal;	4154	push @WAIT_FOR_TICK_BEGIN, $signal;
4004	$signal->wait;	4155	$signal->wait;
4005	}	4156	}
…		…
4009	Carp::cluck "major BUG: server tick called outside of main coro, skipping it"	4160	Carp::cluck "major BUG: server tick called outside of main coro, skipping it"
4010	unless ++$bug_warning > 10;	4161	unless ++$bug_warning > 10;
4011	return;	4162	return;
4012	}	4163	}
4013		4164
4014	cf::server_tick; # one server iteration	4165	cf::one_tick; # one server iteration
4015		4166
4016	#for(1..3e6){} AE::now_update; $NOW=AE::now; # generate load #d#	4167	#for(1..3e6){} AE::now_update; $NOW=AE::now; # generate load #d#
4017		4168
4018	if ($NOW >= $NEXT_RUNTIME_WRITE) {	4169	if ($NOW >= $NEXT_RUNTIME_WRITE) {
4019	$NEXT_RUNTIME_WRITE = List::Util::max $NEXT_RUNTIME_WRITE + 10, $NOW + 5.;	4170	$NEXT_RUNTIME_WRITE = List::Util::max $NEXT_RUNTIME_WRITE + 10, $NOW + 5.;
…		…
4025	}	4176	}
4026		4177
4027	if (my $sig = shift @WAIT_FOR_TICK_BEGIN) {	4178	if (my $sig = shift @WAIT_FOR_TICK_BEGIN) {
4028	$sig->send;	4179	$sig->send;
4029	}	4180	}
4030	while (my $sig = shift @WAIT_FOR_TICK) {	4181	$WAIT_FOR_TICK->broadcast;
4031	$sig->send;
4032	}
4033		4182
4034	$LOAD = ($NOW - $TICK_START) / $TICK;	4183	$LOAD = ($NOW - $TICK_START) / $TICK;
4035	$LOADAVG = $LOADAVG * 0.75 + $LOAD * 0.25;	4184	$LOADAVG = $LOADAVG * 0.75 + $LOAD * 0.25;
4036		4185
4037	if (0) {	4186	if (0) {
…		…
4046	{	4195	{
4047	# configure BDB	4196	# configure BDB
4048		4197
4049	BDB::min_parallel 16;	4198	BDB::min_parallel 16;
4050	BDB::max_poll_reqs $TICK * 0.1;	4199	BDB::max_poll_reqs $TICK * 0.1;
4051	$AnyEvent::BDB::WATCHER->priority (1);	4200	#$AnyEvent::BDB::WATCHER->priority (1);
4052		4201
4053	unless ($DB_ENV) {	4202	unless ($DB_ENV) {
4054	$DB_ENV = BDB::db_env_create;	4203	$DB_ENV = BDB::db_env_create;
4055	$DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT);	4204	$DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT);
4056	$DB_ENV->set_flags (&BDB::LOG_AUTOREMOVE ) if BDB::VERSION v0, v4.7;	4205	$DB_ENV->set_flags (&BDB::LOG_AUTOREMOVE ) if BDB::VERSION v0, v4.7;
4057	$DB_ENV->log_set_config (&BDB::LOG_AUTO_REMOVE) if BDB::VERSION v4.7;	4206	$DB_ENV->log_set_config (&BDB::LOG_AUTO_REMOVE) if BDB::VERSION v4.7;
4058	$DB_ENV->set_timeout (30, BDB::SET_TXN_TIMEOUT);	4207	$DB_ENV->set_timeout (30, BDB::SET_TXN_TIMEOUT);
4059	$DB_ENV->set_timeout (30, BDB::SET_LOCK_TIMEOUT);	4208	$DB_ENV->set_timeout (30, BDB::SET_LOCK_TIMEOUT);
4060		4209
4061	(Coro::async { # async to keep sync_job from complaining
4062	cf::sync_job {	4210	cf::sync_job {
4063	eval {	4211	eval {
4064	BDB::db_env_open	4212	BDB::db_env_open
4065	$DB_ENV,	4213	$DB_ENV,
4066	$BDBDIR,	4214	$BDBDIR,
4067	BDB::INIT_LOCK | BDB::INIT_LOG | BDB::INIT_MPOOL | BDB::INIT_TXN	4215	BDB::INIT_LOCK | BDB::INIT_LOG | BDB::INIT_MPOOL | BDB::INIT_TXN
4068	| BDB::RECOVER | BDB::REGISTER | BDB::USE_ENVIRON | BDB::CREATE,	4216	| BDB::RECOVER | BDB::REGISTER | BDB::USE_ENVIRON | BDB::CREATE,
4069	0666;	4217	0666;
4070		4218
4071	cf::cleanup "db_env_open($BDBDIR): $!" if $!;	4219	cf::cleanup "db_env_open($BDBDIR): $!" if $!;
4072	};
4073
4074	cf::cleanup "db_env_open(db): $@" if $@;
4075	};	4220	};
4076	})->join;	4221
		4222	cf::cleanup "db_env_open(db): $@" if $@;
		4223	};
4077	}	4224	}
4078		4225
4079	$BDB_DEADLOCK_WATCHER = EV::periodic 0, 3, 0, sub {	4226	$BDB_DEADLOCK_WATCHER = EV::periodic 0, 3, 0, sub {
4080	BDB::db_env_lock_detect $DB_ENV, 0, BDB::LOCK_DEFAULT, 0, sub { };	4227	BDB::db_env_lock_detect $DB_ENV, 0, BDB::LOCK_DEFAULT, 0, sub { };
4081	};	4228	};
…		…
4093	IO::AIO::min_parallel 8;	4240	IO::AIO::min_parallel 8;
4094	IO::AIO::max_poll_time $TICK * 0.1;	4241	IO::AIO::max_poll_time $TICK * 0.1;
4095	undef $AnyEvent::AIO::WATCHER;	4242	undef $AnyEvent::AIO::WATCHER;
4096	}	4243	}
4097		4244
4098	my $_log_backtrace;	4245	our $_log_backtrace;
		4246	our $_log_backtrace_last;
4099		4247
4100	sub _log_backtrace {	4248	sub _log_backtrace {
4101	my ($msg, @addr) = @_;	4249	my ($msg, @addr) = @_;
4102		4250
4103	$msg =~ s/\n//;	4251	$msg =~ s/\n$//;
4104		4252
		4253	if ($_log_backtrace_last eq $msg) {
		4254	LOG llevInfo, "[ABT] $msg\n";
		4255	LOG llevInfo, "[ABT] [duplicate, suppressed]\n";
4105	# limit the # of concurrent backtraces	4256	# limit the # of concurrent backtraces
4106	if ($_log_backtrace < 2) {	4257	} elsif ($_log_backtrace < 2) {
		4258	$_log_backtrace_last = $msg;
4107	++$_log_backtrace;	4259	++$_log_backtrace;
4108	my $perl_bt = Carp::longmess $msg;	4260	my $perl_bt = Carp::longmess $msg;
4109	async {	4261	async {
4110	$Coro::current->{desc} = "abt $msg";	4262	$Coro::current->{desc} = "abt $msg";
4111		4263
…		…
4131	LOG llevInfo, "[ABT] $_\n" for @bt;	4283	LOG llevInfo, "[ABT] $_\n" for @bt;
4132	--$_log_backtrace;	4284	--$_log_backtrace;
4133	};	4285	};
4134	} else {	4286	} else {
4135	LOG llevInfo, "[ABT] $msg\n";	4287	LOG llevInfo, "[ABT] $msg\n";
4136	LOG llevInfo, "[ABT] [suppressed]\n";	4288	LOG llevInfo, "[ABT] [overload, suppressed]\n";
4137	}	4289	}
4138	}	4290	}
4139		4291
4140	# load additional modules	4292	# load additional modules
4141	require "cf/$_.pm" for @EXTRA_MODULES;	4293	require "cf/$_.pm" for @EXTRA_MODULES;

Diff Legend

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