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.109 by root, Sun Dec 31 22:23:12 2006 UTC vs.
Revision 1.208 by root, Mon Feb 12 00:27:20 2007 UTC

…		…
8	use Storable;	8	use Storable;
9	use Opcode;	9	use Opcode;
10	use Safe;	10	use Safe;
11	use Safe::Hole;	11	use Safe::Hole;
12		12
13	use Coro 3.3;	13	use Coro 3.5 ();
14	use Coro::Event;	14	use Coro::Event;
15	use Coro::Timer;	15	use Coro::Timer;
16	use Coro::Signal;	16	use Coro::Signal;
17	use Coro::Semaphore;	17	use Coro::Semaphore;
18	use Coro::AIO;	18	use Coro::AIO;
19		19
		20	use BDB ();
		21	use Data::Dumper;
20	use Digest::MD5;	22	use Digest::MD5;
21	use Fcntl;	23	use Fcntl;
22	use IO::AIO 2.31 ();	24	use IO::AIO 2.32 ();
23	use YAML::Syck ();	25	use YAML::Syck ();
24	use Time::HiRes;	26	use Time::HiRes;
		27	use Compress::LZF;
		28
		29	Compress::LZF::sfreeze_cr { }; # prime Compress::LZF so it does not use require later
25		30
26	use Event; $Event::Eval = 1; # no idea why this is required, but it is	31	use Event; $Event::Eval = 1; # no idea why this is required, but it is
		32
		33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
27		34
28	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?	35	# work around bug in YAML::Syck - bad news for perl6, will it be as broken wrt. unicode?
29	$YAML::Syck::ImplicitUnicode = 1;	36	$YAML::Syck::ImplicitUnicode = 1;
30		37
31	$Coro::main->prio (2); # run main coroutine ("the server") with very high priority	38	$Coro::main->prio (Coro::PRIO_MAX); # run main coroutine ("the server") with very high priority
32
33	sub WF_AUTOCANCEL () { 1 } # automatically cancel this watcher on reload
34		39
35	our %COMMAND = ();	40	our %COMMAND = ();
36	our %COMMAND_TIME = ();	41	our %COMMAND_TIME = ();
		42
		43	our @EXTS = (); # list of extension package names
37	our %EXTCMD = ();	44	our %EXTCMD = ();
		45	our %EXT_CORO = (); # coroutines bound to extensions
		46	our %EXT_MAP = (); # pluggable maps
38		47
39	our @EVENT;	48	our @EVENT;
40	our $LIBDIR = datadir . "/ext";	49	our $LIBDIR = datadir . "/ext";
41		50
42	our $TICK = MAX_TIME * 1e-6;	51	our $TICK = MAX_TIME * 1e-6;
43	our $TICK_WATCHER;	52	our $TICK_WATCHER;
		53	our $AIO_POLL_WATCHER;
		54	our $WRITE_RUNTIME_WATCHER;
44	our $NEXT_TICK;	55	our $NEXT_TICK;
45	our $NOW;	56	our $NOW;
		57	our $USE_FSYNC = 1; # use fsync to write maps - default off
		58
		59	our $BDB_POLL_WATCHER;
		60	our $DB_ENV;
46		61
47	our %CFG;	62	our %CFG;
48		63
49	our $UPTIME; $UPTIME ||= time;	64	our $UPTIME; $UPTIME ||= time;
50	our $RUNTIME;	65	our $RUNTIME;
51		66
		67	our %PLAYER; # all users
52	our %MAP; # all maps	68	our %MAP; # all maps
53	our $LINK_MAP; # the special {link} map	69	our $LINK_MAP; # the special {link} map, which is always available
54	our $FREEZE;
55	our $RANDOM_MAPS = cf::localdir . "/random";	70	our $RANDOM_MAPS = cf::localdir . "/random";
56	our %EXT_CORO;	71	our $BDB_ENV_DIR = cf::localdir . "/db";
		72
		73	our $WAIT_FOR_TICK; $WAIT_FOR_TICK ||= new Coro::Signal;
		74	our $WAIT_FOR_TICK_ONE; $WAIT_FOR_TICK_ONE ||= new Coro::Signal;
		75
		76	# used to convert map paths into valid unix filenames by replacing / by ∕
		77	our $PATH_SEP = "∕"; # U+2215, chosen purely for visual reasons
57		78
58	binmode STDOUT;	79	binmode STDOUT;
59	binmode STDERR;	80	binmode STDERR;
60		81
61	# read virtual server time, if available	82	# read virtual server time, if available
…		…
68	mkdir cf::localdir;	89	mkdir cf::localdir;
69	mkdir cf::localdir . "/" . cf::playerdir;	90	mkdir cf::localdir . "/" . cf::playerdir;
70	mkdir cf::localdir . "/" . cf::tmpdir;	91	mkdir cf::localdir . "/" . cf::tmpdir;
71	mkdir cf::localdir . "/" . cf::uniquedir;	92	mkdir cf::localdir . "/" . cf::uniquedir;
72	mkdir $RANDOM_MAPS;	93	mkdir $RANDOM_MAPS;
		94	mkdir $BDB_ENV_DIR;
73		95
74	# a special map that is always available	96	our $EMERGENCY_POSITION;
75	our $LINK_MAP;	97
		98	sub cf::map::normalise;
76		99
77	#############################################################################	100	#############################################################################
78		101
79	=head2 GLOBAL VARIABLES	102	=head2 GLOBAL VARIABLES
80		103
…		…
104		127
105	=item %cf::CFG	128	=item %cf::CFG
106		129
107	Configuration for the server, loaded from C</etc/crossfire/config>, or	130	Configuration for the server, loaded from C</etc/crossfire/config>, or
108	from wherever your confdir points to.	131	from wherever your confdir points to.
		132
		133	=item $cf::WAIT_FOR_TICK, $cf::WAIT_FOR_TICK_ONE
		134
		135	These are Coro::Signal objects that are C<< ->broadcast >> (WAIT_FOR_TICK)
		136	or C<< ->send >> (WAIT_FOR_TICK_ONE) on after normal server tick
		137	processing has been done. Call C<< ->wait >> on them to maximise the
		138	window of cpu time available, or simply to synchronise to the server tick.
109		139
110	=back	140	=back
111		141
112	=cut	142	=cut
113		143
…		…
117	utf8::encode $msg;	147	utf8::encode $msg;
118		148
119	$msg .= "\n"	149	$msg .= "\n"
120	unless $msg =~ /\n$/;	150	unless $msg =~ /\n$/;
121		151
122	LOG llevError, "cfperl: $msg";	152	LOG llevError, $msg;
123	};	153	};
124	}	154	}
125		155
126	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';	156	@safe::cf::global::ISA = @cf::global::ISA = 'cf::attachable';
127	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';	157	@safe::cf::object::ISA = @cf::object::ISA = 'cf::attachable';
…		…
145		175
146	$Event::DIED = sub {	176	$Event::DIED = sub {
147	warn "error in event callback: @_";	177	warn "error in event callback: @_";
148	};	178	};
149		179
150	my %ext_pkg;
151	my @exts;
152	my @hook;
153
154	=head2 UTILITY FUNCTIONS	180	=head2 UTILITY FUNCTIONS
155		181
156	=over 4	182	=over 4
157		183
		184	=item dumpval $ref
		185
158	=cut	186	=cut
		187
		188	sub dumpval {
		189	eval {
		190	local $SIG{__DIE__};
		191	my $d;
		192	if (1) {
		193	$d = new Data::Dumper([$_[0]], ["*var"]);
		194	$d->Terse(1);
		195	$d->Indent(2);
		196	$d->Quotekeys(0);
		197	$d->Useqq(1);
		198	#$d->Bless(...);
		199	$d->Seen($_[1]) if @_ > 1;
		200	$d = $d->Dump();
		201	}
		202	$d =~ s/([\x00-\x07\x09\x0b\x0c\x0e-\x1f])/sprintf "\\x%02x", ord($1)/ge;
		203	$d
		204	} || "[unable to dump $_[0]: '$@']";
		205	}
159		206
160	use JSON::Syck (); # TODO# replace by JSON::PC once working	207	use JSON::Syck (); # TODO# replace by JSON::PC once working
161		208
162	=item $ref = cf::from_json $json	209	=item $ref = cf::from_json $json
163		210
…		…
178		225
179	sub to_json($) {	226	sub to_json($) {
180	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs	227	$JSON::Syck::ImplicitUnicode = 0; # work around JSON::Syck bugs
181	JSON::Syck::Dump $_[0]	228	JSON::Syck::Dump $_[0]
182	}	229	}
		230
		231	=item cf::lock_wait $string
		232
		233	Wait until the given lock is available. See cf::lock_acquire.
		234
		235	=item my $lock = cf::lock_acquire $string
		236
		237	Wait until the given lock is available and then acquires it and returns
		238	a Coro::guard object. If the guard object gets destroyed (goes out of scope,
		239	for example when the coroutine gets canceled), the lock is automatically
		240	returned.
		241
		242	Lock names should begin with a unique identifier (for example, cf::map::find
		243	uses map_find and cf::map::load uses map_load).
		244
		245	=cut
		246
		247	our %LOCK;
		248
		249	sub lock_wait($) {
		250	my ($key) = @_;
		251
		252	# wait for lock, if any
		253	while ($LOCK{$key}) {
		254	push @{ $LOCK{$key} }, $Coro::current;
		255	Coro::schedule;
		256	}
		257	}
		258
		259	sub lock_acquire($) {
		260	my ($key) = @_;
		261
		262	# wait, to be sure we are not locked
		263	lock_wait $key;
		264
		265	$LOCK{$key} = [];
		266
		267	Coro::guard {
		268	# wake up all waiters, to be on the safe side
		269	$_->ready for @{ delete $LOCK{$key} };
		270	}
		271	}
		272
		273	sub freeze_mainloop {
		274	return unless $TICK_WATCHER->is_active;
		275
		276	my $guard = Coro::guard {
		277	$TICK_WATCHER->start;
		278	$WRITE_RUNTIME_WATCHER->start;
		279	};
		280	$WRITE_RUNTIME_WATCHER->stop;
		281	$TICK_WATCHER->stop;
		282	$guard
		283	}
		284
		285	=item cf::async { BLOCK }
		286
		287	Currently the same as Coro::async_pool, meaning you cannot use
		288	C<on_destroy>, C<join> or other gimmicks on these coroutines. The only
		289	thing you are allowed to do is call C<prio> on it.
		290
		291	=cut
		292
		293	BEGIN { *async = \&Coro::async_pool }
183		294
184	=item cf::sync_job { BLOCK }	295	=item cf::sync_job { BLOCK }
185		296
186	The design of crossfire+ requires that the main coro ($Coro::main) is	297	The design of crossfire+ requires that the main coro ($Coro::main) is
187	always able to handle events or runnable, as crossfire+ is only partly	298	always able to handle events or runnable, as crossfire+ is only partly
…		…
195	=cut	306	=cut
196		307
197	sub sync_job(&) {	308	sub sync_job(&) {
198	my ($job) = @_;	309	my ($job) = @_;
199		310
200	my $busy = 1;
201	my @res;
202
203	# TODO: use suspend/resume instead
204	local $FREEZE = 1;
205
206	my $coro = Coro::async {
207	@res = eval { $job->() };
208	warn $@ if $@;
209	undef $busy;
210	};
211
212	if ($Coro::current == $Coro::main) {	311	if ($Coro::current == $Coro::main) {
		312	# this is the main coro, too bad, we have to block
		313	# till the operation succeeds, freezing the server :/
		314
		315	# TODO: use suspend/resume instead
		316	# (but this is cancel-safe)
		317	my $freeze_guard = freeze_mainloop;
		318
		319	my $busy = 1;
		320	my @res;
		321
		322	(async {
		323	@res = eval { $job->() };
		324	warn $@ if $@;
		325	undef $busy;
213	$coro->prio (Coro::PRIO_MAX);	326	})->prio (Coro::PRIO_MAX);
		327
214	while ($busy) {	328	while ($busy) {
215	Coro::cede_notself;	329	Coro::cede or Event::one_event;
216	Event::one_event unless Coro::nready;
217	}	330	}
		331
		332	wantarray ? @res : $res[0]
218	} else {	333	} else {
219	$coro->join;	334	# we are in another coroutine, how wonderful, everything just works
		335
		336	$job->()
220	}	337	}
221
222	wantarray ? @res : $res[0]
223	}	338	}
224		339
225	=item $coro = cf::coro { BLOCK }	340	=item $coro = cf::async_ext { BLOCK }
226		341
227	Creates and returns a new coro. This coro is automcatially being canceled	342	Like async, but this coro is automatically being canceled when the
228	when the extension calling this is being unloaded.	343	extension calling this is being unloaded.
229		344
230	=cut	345	=cut
231		346
232	sub coro(&) {	347	sub async_ext(&) {
233	my $cb = shift;	348	my $cb = shift;
234		349
235	my $coro; $coro = async {	350	my $coro = &Coro::async ($cb);
236	eval {
237	$cb->();
238	};
239	warn $@ if $@;
240	};
241		351
242	$coro->on_destroy (sub {	352	$coro->on_destroy (sub {
243	delete $EXT_CORO{$coro+0};	353	delete $EXT_CORO{$coro+0};
244	});	354	});
245	$EXT_CORO{$coro+0} = $coro;	355	$EXT_CORO{$coro+0} = $coro;
…		…
251	my $runtime = cf::localdir . "/runtime";	361	my $runtime = cf::localdir . "/runtime";
252		362
253	my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644	363	my $fh = aio_open "$runtime~", O_WRONLY | O_CREAT, 0644
254	or return;	364	or return;
255		365
256	my $value = $cf::RUNTIME;	366	my $value = $cf::RUNTIME + 90 + 10;
		367	# 10 is the runtime save interval, for a monotonic clock
		368	# 60 allows for the watchdog to kill the server.
		369
257	(aio_write $fh, 0, (length $value), $value, 0) <= 0	370	(aio_write $fh, 0, (length $value), $value, 0) <= 0
258	and return;	371	and return;
259		372
		373	# always fsync - this file is important
260	aio_fsync $fh	374	aio_fsync $fh
261	and return;	375	and return;
262		376
263	close $fh	377	close $fh
264	or return;	378	or return;
…		…
270	}	384	}
271		385
272	=back	386	=back
273		387
274	=cut	388	=cut
275
276	#############################################################################
277
278	package cf::path;
279
280	sub new {
281	my ($class, $path, $base) = @_;
282
283	my $self = bless { }, $class;
284
285	if ($path =~ s{^\?random/}{}) {
286	Coro::AIO::aio_load "$cf::RANDOM_MAPS/$path.meta", my $data;
287	$self->{random} = cf::from_json $data;
288	} else {
289	if ($path =~ s{^~([^/]+)?}{}) {
290	$self->{user_rel} = 1;
291
292	if (defined $1) {
293	$self->{user} = $1;
294	} elsif ($base =~ m{^~([^/]+)/}) {
295	$self->{user} = $1;
296	} else {
297	warn "cannot resolve user-relative path without user <$path,$base>\n";
298	}
299	} elsif ($path =~ /^\//) {
300	# already absolute
301	} else {
302	$base =~ s{[^/]+/?$}{};
303	return $class->new ("$base/$path");
304	}
305
306	for ($path) {
307	redo if s{/\.?/}{/};
308	redo if s{/[^/]+/\.\./}{/};
309	}
310	}
311
312	$self->{path} = $path;
313
314	$self
315	}
316
317	# the name / primary key / in-game path
318	sub as_string {
319	my ($self) = @_;
320
321	$self->{user_rel} ? "~$self->{user}$self->{path}"
322	: $self->{random} ? "?random/$self->{path}"
323	: $self->{path}
324	}
325
326	# the displayed name, this is a one way mapping
327	sub visible_name {
328	my ($self) = @_;
329
330	# if (my $rmp = $self->{random}) {
331	# # todo: be more intelligent about this
332	# "?random/$rmp->{origin_map}+$rmp->{origin_x}+$rmp->{origin_y}/$rmp->{dungeon_level}"
333	# } else {
334	$self->as_string
335	# }
336	}
337
338	# escape the /'s in the path
339	sub _escaped_path {
340	# ∕ is U+2215
341	(my $path = $_[0]{path}) =~ s/\//∕/g;
342	$path
343	}
344
345	# the original (read-only) location
346	sub load_path {
347	my ($self) = @_;
348
349	sprintf "%s/%s/%s", cf::datadir, cf::mapdir, $self->{path}
350	}
351
352	# the temporary/swap location
353	sub save_path {
354	my ($self) = @_;
355
356	$self->{user_rel} ? sprintf "%s/%s/%s/%s", cf::localdir, cf::playerdir, $self->{user}, $self->_escaped_path
357	: $self->{random} ? sprintf "%s/%s", $RANDOM_MAPS, $self->{path}
358	: sprintf "%s/%s/%s", cf::localdir, cf::tmpdir, $self->_escaped_path
359	}
360
361	# the unique path, might be eq to save_path
362	sub uniq_path {
363	my ($self) = @_;
364
365	$self->{user_rel} || $self->{random}
366	? undef
367	: sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $self->_escaped_path
368	}
369
370	# return random map parameters, or undef
371	sub random_map_params {
372	my ($self) = @_;
373
374	$self->{random}
375	}
376
377	# this is somewhat ugly, but style maps do need special treatment
378	sub is_style_map {
379	$_[0]{path} =~ m{^/styles/}
380	}
381
382	package cf;
383		389
384	#############################################################################	390	#############################################################################
385		391
386	=head2 ATTACHABLE OBJECTS	392	=head2 ATTACHABLE OBJECTS
387		393
…		…
513	our @CB_TYPE = (); # registry for type (cf-object class) based events	519	our @CB_TYPE = (); # registry for type (cf-object class) based events
514	our @CB_MAP = ();	520	our @CB_MAP = ();
515		521
516	my %attachment;	522	my %attachment;
517		523
		524	sub cf::attachable::thawer_merge {
		525	# simply override everything except _meta
		526	local $_[0]{_meta};
		527	%{$_[0]} = %{$_[1]};
		528	}
		529
518	sub _attach_cb($$$$) {	530	sub _attach_cb($$$$) {
519	my ($registry, $event, $prio, $cb) = @_;	531	my ($registry, $event, $prio, $cb) = @_;
520		532
521	use sort 'stable';	533	use sort 'stable';
522		534
…		…
693	# object support	705	# object support
694		706
695	sub reattach {	707	sub reattach {
696	# basically do the same as instantiate, without calling instantiate	708	# basically do the same as instantiate, without calling instantiate
697	my ($obj) = @_;	709	my ($obj) = @_;
		710
		711	bless $obj, ref $obj; # re-bless in case extensions have been reloaded
698		712
699	my $registry = $obj->registry;	713	my $registry = $obj->registry;
700		714
701	@$registry = ();	715	@$registry = ();
702		716
…		…
749	$filename, length $$rdata, scalar @$objs;	763	$filename, length $$rdata, scalar @$objs;
750		764
751	if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {	765	if (my $fh = aio_open "$filename~", O_WRONLY | O_CREAT, 0600) {
752	chmod SAVE_MODE, $fh;	766	chmod SAVE_MODE, $fh;
753	aio_write $fh, 0, (length $$rdata), $$rdata, 0;	767	aio_write $fh, 0, (length $$rdata), $$rdata, 0;
754	aio_fsync $fh;	768	aio_fsync $fh if $cf::USE_FSYNC;
755	close $fh;	769	close $fh;
756		770
757	if (@$objs) {	771	if (@$objs) {
758	if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {	772	if (my $fh = aio_open "$filename.pst~", O_WRONLY | O_CREAT, 0600) {
759	chmod SAVE_MODE, $fh;	773	chmod SAVE_MODE, $fh;
760	my $data = Storable::nfreeze { version => 1, objs => $objs };	774	my $data = Storable::nfreeze { version => 1, objs => $objs };
761	aio_write $fh, 0, (length $data), $data, 0;	775	aio_write $fh, 0, (length $data), $data, 0;
762	aio_fsync $fh;	776	aio_fsync $fh if $cf::USE_FSYNC;
763	close $fh;	777	close $fh;
764	aio_rename "$filename.pst~", "$filename.pst";	778	aio_rename "$filename.pst~", "$filename.pst";
765	}	779	}
766	} else {	780	} else {
767	aio_unlink "$filename.pst";	781	aio_unlink "$filename.pst";
…		…
773	}	787	}
774	} else {	788	} else {
775	aio_unlink $filename;	789	aio_unlink $filename;
776	aio_unlink "$filename.pst";	790	aio_unlink "$filename.pst";
777	}	791	}
		792
		793	#d##TODO# nuke non .map-files if exist
		794	if ($filename =~ s/\.map$//) {
		795	aio_unlink $filename;
		796	aio_unlink "$filename.pst";
		797	}
778	}	798	}
779	}	799	}
780		800
781	sub object_freezer_as_string {	801	sub object_freezer_as_string {
782	my ($rdata, $objs) = @_;	802	my ($rdata, $objs) = @_;
…		…
788		808
789	sub object_thawer_load {	809	sub object_thawer_load {
790	my ($filename) = @_;	810	my ($filename) = @_;
791		811
792	my ($data, $av);	812	my ($data, $av);
		813
		814	#d#TODO remove .map if file does not exist
		815	aio_stat $filename and $filename =~ s/\.map$//;
793		816
794	(aio_load $filename, $data) >= 0	817	(aio_load $filename, $data) >= 0
795	or return;	818	or return;
796		819
797	unless (aio_stat "$filename.pst") {	820	unless (aio_stat "$filename.pst") {
798	(aio_load "$filename.pst", $av) >= 0	821	(aio_load "$filename.pst", $av) >= 0
799	or return;	822	or return;
800	$av = eval { (Storable::thaw <$av>)->{objs} };	823	$av = eval { (Storable::thaw $av)->{objs} };
801	}	824	}
802		825
		826	warn sprintf "loading %s (%d)\n",
		827	$filename, length $data, scalar @{$av || []};#d#
803	return ($data, $av);	828	return ($data, $av);
804	}	829	}
805		830
806	#############################################################################	831	#############################################################################
807	# command handling &c	832	# command handling &c
…		…
832	=cut	857	=cut
833		858
834	sub register_extcmd {	859	sub register_extcmd {
835	my ($name, $cb) = @_;	860	my ($name, $cb) = @_;
836		861
837	my $caller = caller;
838	#warn "registering extcmd '$name' to '$caller'";
839
840	$EXTCMD{$name} = [$cb, $caller];	862	$EXTCMD{$name} = $cb;
841	}	863	}
842		864
843	cf::player->attach (	865	cf::player->attach (
844	on_command => sub {	866	on_command => sub {
845	my ($pl, $name, $params) = @_;	867	my ($pl, $name, $params) = @_;
…		…
858		880
859	my $msg = eval { from_json $buf };	881	my $msg = eval { from_json $buf };
860		882
861	if (ref $msg) {	883	if (ref $msg) {
862	if (my $cb = $EXTCMD{$msg->{msgtype}}) {	884	if (my $cb = $EXTCMD{$msg->{msgtype}}) {
863	if (my %reply = $cb->[0]->($pl, $msg)) {	885	if (my %reply = $cb->($pl, $msg)) {
864	$pl->ext_reply ($msg->{msgid}, %reply);	886	$pl->ext_reply ($msg->{msgid}, %reply);
865	}	887	}
866	}	888	}
867	} else {	889	} else {
868	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";	890	warn "player " . ($pl->ob->name) . " sent unparseable ext message: <$buf>\n";
…		…
870		892
871	cf::override;	893	cf::override;
872	},	894	},
873	);	895	);
874		896
875	sub register {
876	my ($base, $pkg) = @_;
877
878	#TODO
879	}
880
881	sub load_extension {	897	sub load_extension {
882	my ($path) = @_;	898	my ($path) = @_;
883		899
884	$path =~ /([^\/\\]+)\.ext$/ or die "$path";	900	$path =~ /([^\/\\]+)\.ext$/ or die "$path";
885	my $base = $1;	901	my $base = $1;
886	my $pkg = $1;	902	my $pkg = $1;
887	$pkg =~ s/[^[:word:]]/_/g;	903	$pkg =~ s/[^[:word:]]/_/g;
888	$pkg = "ext::$pkg";	904	$pkg = "ext::$pkg";
889		905
890	warn "loading '$path' into '$pkg'\n";	906	warn "... loading '$path' into '$pkg'\n";
891		907
892	open my $fh, "<:utf8", $path	908	open my $fh, "<:utf8", $path
893	or die "$path: $!";	909	or die "$path: $!";
894		910
895	my $source =	911	my $source =
896	"package $pkg; use strict; use utf8;\n"	912	"package $pkg; use strict; use utf8;\n"
897	. "#line 1 \"$path\"\n{\n"	913	. "#line 1 \"$path\"\n{\n"
898	. (do { local $/; <$fh> })	914	. (do { local $/; <$fh> })
899	. "\n};\n1";	915	. "\n};\n1";
900		916
901	eval $source	917	unless (eval $source) {
902	or die $@ ? "$path: $@\n"	918	my $msg = $@ ? "$path: $@\n"
903	: "extension disabled.\n";	919	: "extension disabled.\n";
904		920	if ($source =~ /^#!.*perl.*#.*MANDATORY/m) { # ugly match
905	push @exts, $pkg;	921	warn $@;
906	$ext_pkg{$base} = $pkg;	922	warn "mandatory extension failed to load, exiting.\n";
907		923	exit 1;
908	# no strict 'refs';	924	}
909	# @{"$pkg\::ISA"} = ext::;	925	die $@;
910
911	register $base, $pkg;
912	}
913
914	sub unload_extension {
915	my ($pkg) = @_;
916
917	warn "removing extension $pkg\n";
918
919	# remove hooks
920	#TODO
921	# for my $idx (0 .. $#PLUGIN_EVENT) {
922	# delete $hook[$idx]{$pkg};
923	# }	926	}
924		927
925	# remove commands	928	push @EXTS, $pkg;
926	for my $name (keys %COMMAND) {
927	my @cb = grep $_->[0] ne $pkg, @{ $COMMAND{$name} };
928
929	if (@cb) {
930	$COMMAND{$name} = \@cb;
931	} else {
932	delete $COMMAND{$name};
933	}
934	}
935
936	# remove extcmds
937	for my $name (grep $EXTCMD{$_}[1] eq $pkg, keys %EXTCMD) {
938	delete $EXTCMD{$name};
939	}
940
941	if (my $cb = $pkg->can ("unload")) {
942	eval {
943	$cb->($pkg);
944	1
945	} or warn "$pkg unloaded, but with errors: $@";
946	}
947
948	Symbol::delete_package $pkg;
949	}	929	}
950		930
951	sub load_extensions {	931	sub load_extensions {
952	for my $ext (<$LIBDIR/*.ext>) {	932	for my $ext (<$LIBDIR/*.ext>) {
953	next unless -r $ext;	933	next unless -r $ext;
…		…
957	} or warn "$ext not loaded: $@";	937	} or warn "$ext not loaded: $@";
958	}	938	}
959	}	939	}
960		940
961	#############################################################################	941	#############################################################################
962	# load/save/clean perl data associated with a map
963		942
964	*cf::mapsupport::on_clean = sub {	943	=head2 CORE EXTENSIONS
		944
		945	Functions and methods that extend core crossfire objects.
		946
		947	=cut
		948
		949	package cf::player;
		950
		951	use Coro::AIO;
		952
		953	=head3 cf::player
		954
		955	=over 4
		956
		957	=item cf::player::find $login
		958
		959	Returns the given player object, loading it if necessary (might block).
		960
		961	=cut
		962
		963	sub playerdir($) {
		964	cf::localdir
		965	. "/"
		966	. cf::playerdir
		967	. "/"
		968	. (ref $_[0] ? $_[0]->ob->name : $_[0])
		969	}
		970
		971	sub path($) {
		972	my $login = ref $_[0] ? $_[0]->ob->name : $_[0];
		973
		974	(playerdir $login) . "/$login.pl"
		975	}
		976
		977	sub find_active($) {
		978	$cf::PLAYER{$_[0]}
		979	and $cf::PLAYER{$_[0]}->active
		980	and $cf::PLAYER{$_[0]}
		981	}
		982
		983	sub exists($) {
		984	my ($login) = @_;
		985
		986	$cf::PLAYER{$login}
		987	or cf::sync_job { !aio_stat path $login }
		988	}
		989
		990	sub find($) {
		991	return $cf::PLAYER{$_[0]} || do {
		992	my $login = $_[0];
		993
		994	my $guard = cf::lock_acquire "user_find:$login";
		995
		996	$cf::PLAYER{$_[0]} || do {
		997	my $pl = load_pl path $login
		998	or return;
		999	$cf::PLAYER{$login} = $pl
		1000	}
		1001	}
		1002	}
		1003
		1004	sub save($) {
		1005	my ($pl) = @_;
		1006
		1007	return if $pl->{deny_save};
		1008
		1009	my $path = path $pl;
		1010	my $guard = cf::lock_acquire "user_save:$path";
		1011
		1012	return if $pl->{deny_save};
		1013
		1014	aio_mkdir playerdir $pl, 0770;
		1015	$pl->{last_save} = $cf::RUNTIME;
		1016
		1017	$pl->save_pl ($path);
		1018	Coro::cede;
		1019	}
		1020
		1021	sub new($) {
		1022	my ($login) = @_;
		1023
		1024	my $self = create;
		1025
		1026	$self->ob->name ($login);
		1027	$self->{deny_save} = 1;
		1028
		1029	$cf::PLAYER{$login} = $self;
		1030
		1031	$self
		1032	}
		1033
		1034	=item $pl->quit_character
		1035
		1036	Nukes the player without looking back. If logged in, the connection will
		1037	be destroyed. May block for a long time.
		1038
		1039	=cut
		1040
		1041	sub quit_character {
		1042	my ($pl) = @_;
		1043
		1044	$pl->{deny_save} = 1;
		1045	$pl->password ("*"); # this should lock out the player until we nuked the dir
		1046
		1047	$pl->invoke (cf::EVENT_PLAYER_LOGOUT, 1) if $pl->active;
		1048	$pl->deactivate;
		1049	$pl->invoke (cf::EVENT_PLAYER_QUIT);
		1050	$pl->ns->destroy if $pl->ns;
		1051
		1052	my $path = playerdir $pl;
		1053	my $temp = "$path~$cf::RUNTIME~deleting~";
		1054	aio_rename $path, $temp;
		1055	delete $cf::PLAYER{$pl->ob->name};
		1056	$pl->destroy;
		1057	IO::AIO::aio_rmtree $temp;
		1058	}
		1059
		1060	=item cf::player::list_logins
		1061
		1062	Returns am arrayref of all valid playernames in the system, can take a
		1063	while and may block, so not sync_job-capable, ever.
		1064
		1065	=cut
		1066
		1067	sub list_logins {
		1068	my $dirs = aio_readdir cf::localdir . "/" . cf::playerdir
		1069	or return [];
		1070
		1071	my @logins;
		1072
		1073	for my $login (@$dirs) {
		1074	my $fh = aio_open path $login, Fcntl::O_RDONLY, 0 or next;
		1075	aio_read $fh, 0, 512, my $buf, 0 or next;
		1076	$buf !~ /^password -------------$/m or next; # official not-valid tag
		1077
		1078	utf8::decode $login;
		1079	push @logins, $login;
		1080	}
		1081
		1082	\@logins
		1083	}
		1084
		1085	=item $player->maps
		1086
		1087	Returns an arrayref of map paths that are private for this
		1088	player. May block.
		1089
		1090	=cut
		1091
		1092	sub maps($) {
		1093	my ($pl) = @_;
		1094
		1095	$pl = ref $pl ? $pl->ob->name : $pl;
		1096
		1097	my $files = aio_readdir playerdir $pl
		1098	or return;
		1099
		1100	my @paths;
		1101
		1102	for (@$files) {
		1103	utf8::decode $_;
		1104	next if /\.(?:pl|pst)$/;
		1105	next unless /^$PATH_SEP/o;
		1106
		1107	push @paths, cf::map::normalise "~$pl/$_";
		1108	}
		1109
		1110	\@paths
		1111	}
		1112
		1113	=item $player->ext_reply ($msgid, $msgtype, %msg)
		1114
		1115	Sends an ext reply to the player.
		1116
		1117	=cut
		1118
		1119	sub ext_reply($$$%) {
		1120	my ($self, $id, %msg) = @_;
		1121
		1122	$msg{msgid} = $id;
		1123
		1124	$self->send ("ext " . cf::to_json \%msg);
		1125	}
		1126
		1127	package cf;
		1128
		1129	=back
		1130
		1131
		1132	=head3 cf::map
		1133
		1134	=over 4
		1135
		1136	=cut
		1137
		1138	package cf::map;
		1139
		1140	use Fcntl;
		1141	use Coro::AIO;
		1142
		1143	use overload
		1144	'""' => \&as_string,
		1145	fallback => 1;
		1146
		1147	our $MAX_RESET = 3600;
		1148	our $DEFAULT_RESET = 3000;
		1149
		1150	sub generate_random_map {
		1151	my ($self, $rmp) = @_;
		1152	# mit "rum" bekleckern, nicht
		1153	$self->_create_random_map (
		1154	$rmp->{wallstyle}, $rmp->{wall_name}, $rmp->{floorstyle}, $rmp->{monsterstyle},
		1155	$rmp->{treasurestyle}, $rmp->{layoutstyle}, $rmp->{doorstyle}, $rmp->{decorstyle},
		1156	$rmp->{origin_map}, $rmp->{final_map}, $rmp->{exitstyle}, $rmp->{this_map},
		1157	$rmp->{exit_on_final_map},
		1158	$rmp->{xsize}, $rmp->{ysize},
		1159	$rmp->{expand2x}, $rmp->{layoutoptions1}, $rmp->{layoutoptions2}, $rmp->{layoutoptions3},
		1160	$rmp->{symmetry}, $rmp->{difficulty}, $rmp->{difficulty_given}, $rmp->{difficulty_increase},
		1161	$rmp->{dungeon_level}, $rmp->{dungeon_depth}, $rmp->{decoroptions}, $rmp->{orientation},
		1162	$rmp->{origin_y}, $rmp->{origin_x}, $rmp->{random_seed}, $rmp->{total_map_hp},
		1163	$rmp->{map_layout_style}, $rmp->{treasureoptions}, $rmp->{symmetry_used},
		1164	(cf::region::find $rmp->{region}), $rmp->{custom}
		1165	)
		1166	}
		1167
		1168	=item cf::map->register ($regex, $prio)
		1169
		1170	Register a handler for the map path matching the given regex at the
		1171	givne priority (higher is better, built-in handlers have priority 0, the
		1172	default).
		1173
		1174	=cut
		1175
		1176	sub register {
		1177	my (undef, $regex, $prio) = @_;
		1178	my $pkg = caller;
		1179
		1180	no strict;
		1181	push @{"$pkg\::ISA"}, __PACKAGE__;
		1182
		1183	$EXT_MAP{$pkg} = [$prio, qr<$regex>];
		1184	}
		1185
		1186	# also paths starting with '/'
		1187	$EXT_MAP{"cf::map"} = [0, qr{^(?=/)}];
		1188
		1189	sub thawer_merge {
		1190	my ($self, $merge) = @_;
		1191
		1192	# we have to keep some variables in memory intact
		1193	local $self->{path};
		1194	local $self->{load_path};
		1195	local $self->{deny_save};
		1196	local $self->{deny_reset};
		1197
		1198	$self->SUPER::thawer_merge ($merge);
		1199	}
		1200
		1201	sub normalise {
		1202	my ($path, $base) = @_;
		1203
		1204	$path = "$path"; # make sure its a string
		1205
		1206	$path =~ s/\.map$//;
		1207
		1208	# map plan:
		1209	#
		1210	# /! non-realised random map exit (special hack!)
		1211	# {... are special paths that are not being touched
		1212	# ?xxx/... are special absolute paths
		1213	# ?random/... random maps
		1214	# /... normal maps
		1215	# ~user/... per-player map of a specific user
		1216
		1217	$path =~ s/$PATH_SEP/\//go;
		1218
		1219	# treat it as relative path if it starts with
		1220	# something that looks reasonable
		1221	if ($path =~ m{^(?:\./|\.\./|\w)}) {
		1222	$base or Carp::carp "normalise called with relative path and no base: '$path'";
		1223
		1224	$base =~ s{[^/]+/?$}{};
		1225	$path = "$base/$path";
		1226	}
		1227
		1228	for ($path) {
		1229	redo if s{//}{/};
		1230	redo if s{/\.?/}{/};
		1231	redo if s{/[^/]+/\.\./}{/};
		1232	}
		1233
		1234	$path
		1235	}
		1236
		1237	sub new_from_path {
		1238	my (undef, $path, $base) = @_;
		1239
		1240	return $path if UNIVERSAL::isa $path, "cf::map"; # already a map object
		1241
		1242	$path = normalise $path, $base;
		1243
		1244	for my $pkg (sort { $EXT_MAP{$b}[0] <=> $EXT_MAP{$a}[0] } keys %EXT_MAP) {
		1245	if ($path =~ $EXT_MAP{$pkg}[1]) {
		1246	my $self = bless cf::map::new, $pkg;
		1247	$self->{path} = $path; $self->path ($path);
		1248	$self->init; # pass $1 etc.
		1249	return $self;
		1250	}
		1251	}
		1252
		1253	Carp::carp "unable to resolve path '$path' (base '$base').";
		1254	()
		1255	}
		1256
		1257	sub init {
		1258	my ($self) = @_;
		1259
		1260	$self
		1261	}
		1262
		1263	sub as_string {
		1264	my ($self) = @_;
		1265
		1266	"$self->{path}"
		1267	}
		1268
		1269	# the displayed name, this is a one way mapping
		1270	sub visible_name {
		1271	&as_string
		1272	}
		1273
		1274	# the original (read-only) location
		1275	sub load_path {
		1276	my ($self) = @_;
		1277
		1278	sprintf "%s/%s/%s.map", cf::datadir, cf::mapdir, $self->{path}
		1279	}
		1280
		1281	# the temporary/swap location
		1282	sub save_path {
		1283	my ($self) = @_;
		1284
		1285	(my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
		1286	sprintf "%s/%s/%s.map", cf::localdir, cf::tmpdir, $path
		1287	}
		1288
		1289	# the unique path, undef == no special unique path
		1290	sub uniq_path {
		1291	my ($self) = @_;
		1292
		1293	(my $path = $_[0]{path}) =~ s/\//$PATH_SEP/g;
		1294	sprintf "%s/%s/%s", cf::localdir, cf::uniquedir, $path
		1295	}
		1296
		1297	# and all this just because we cannot iterate over
		1298	# all maps in C++...
		1299	sub change_all_map_light {
		1300	my ($change) = @_;
		1301
		1302	$_->change_map_light ($change)
		1303	for grep $_->outdoor, values %cf::MAP;
		1304	}
		1305
		1306	sub unlink_save {
		1307	my ($self) = @_;
		1308
		1309	utf8::encode (my $save = $self->save_path);
		1310	IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink $save;
		1311	IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink "$save.pst";
		1312
		1313	#d#TODO remove .map and also nuke
		1314	$save =~ s/\.map// or return;#d#
		1315	IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink $save;#d#
		1316	IO::AIO::aioreq_pri 4; Coro::AIO::aio_unlink "$save.pst";#d#
		1317	}
		1318
		1319	sub load_header_from($) {
		1320	my ($self, $path) = @_;
		1321
		1322	utf8::encode $path;
		1323	#aio_open $path, O_RDONLY, 0
		1324	# or return;
		1325
		1326	$self->_load_header ($path)
		1327	or return;
		1328
		1329	$self->{load_path} = $path;
		1330
		1331	1
		1332	}
		1333
		1334	sub load_header_orig {
		1335	my ($self) = @_;
		1336
		1337	$self->load_header_from ($self->load_path)
		1338	}
		1339
		1340	sub load_header_temp {
		1341	my ($self) = @_;
		1342
		1343	$self->load_header_from ($self->save_path)
		1344	}
		1345
		1346	sub prepare_temp {
		1347	my ($self) = @_;
		1348
		1349	$self->last_access ((delete $self->{last_access})
		1350	|| $cf::RUNTIME); #d#
		1351	# safety
		1352	$self->{instantiate_time} = $cf::RUNTIME
		1353	if $self->{instantiate_time} > $cf::RUNTIME;
		1354	}
		1355
		1356	sub prepare_orig {
		1357	my ($self) = @_;
		1358
		1359	$self->{load_original} = 1;
		1360	$self->{instantiate_time} = $cf::RUNTIME;
		1361	$self->last_access ($cf::RUNTIME);
		1362	$self->instantiate;
		1363	}
		1364
		1365	sub load_header {
		1366	my ($self) = @_;
		1367
		1368	if ($self->load_header_temp) {
		1369	$self->prepare_temp;
		1370	} else {
		1371	$self->load_header_orig
		1372	or return;
		1373	$self->prepare_orig;
		1374	}
		1375
		1376	1
		1377	}
		1378
		1379	sub find;
		1380	sub find {
		1381	my ($path, $origin) = @_;
		1382
		1383	$path = normalise $path, $origin && $origin->path;
		1384
		1385	cf::lock_wait "map_find:$path";
		1386
		1387	$cf::MAP{$path} || do {
		1388	my $guard = cf::lock_acquire "map_find:$path";
		1389	my $map = new_from_path cf::map $path
		1390	or return;
		1391
		1392	$map->{last_save} = $cf::RUNTIME;
		1393
		1394	$map->load_header
		1395	or return;
		1396
		1397	if ($map->should_reset && 0) {#d#TODO# disabled, crashy (locking issue?)
		1398	# doing this can freeze the server in a sync job, obviously
		1399	#$cf::WAIT_FOR_TICK->wait;
		1400	$map->reset;
		1401	undef $guard;
		1402	return find $path;
		1403	}
		1404
		1405	$cf::MAP{$path} = $map
		1406	}
		1407	}
		1408
		1409	sub pre_load { }
		1410	sub post_load { }
		1411
		1412	sub load {
		1413	my ($self) = @_;
		1414
		1415	local $self->{deny_reset} = 1; # loading can take a long time
		1416
		1417	my $path = $self->{path};
		1418	my $guard = cf::lock_acquire "map_load:$path";
		1419
		1420	return if $self->in_memory != cf::MAP_SWAPPED;
		1421
		1422	$self->in_memory (cf::MAP_LOADING);
		1423
		1424	$self->alloc;
		1425
		1426	$self->pre_load;
		1427
		1428	$self->_load_objects ($self->{load_path}, 1)
		1429	or return;
		1430
		1431	$self->set_object_flag (cf::FLAG_OBJ_ORIGINAL, 1)
		1432	if delete $self->{load_original};
		1433
		1434	if (my $uniq = $self->uniq_path) {
		1435	utf8::encode $uniq;
		1436	if (aio_open $uniq, O_RDONLY, 0) {
		1437	$self->clear_unique_items;
		1438	$self->_load_objects ($uniq, 0);
		1439	}
		1440	}
		1441
		1442	Coro::cede;
		1443
		1444	# now do the right thing for maps
		1445	$self->link_multipart_objects;
		1446
		1447	unless ($self->{deny_activate}) {
		1448	$self->decay_objects;
		1449	$self->fix_auto_apply;
		1450	$self->update_buttons;
		1451	Coro::cede;
		1452	$self->set_darkness_map;
		1453	$self->difficulty ($self->estimate_difficulty)
		1454	unless $self->difficulty;
		1455	Coro::cede;
		1456	$self->activate;
		1457	}
		1458
		1459	$self->post_load;
		1460
		1461	$self->in_memory (cf::MAP_IN_MEMORY);
		1462	}
		1463
		1464	sub customise_for {
		1465	my ($self, $ob) = @_;
		1466
		1467	return find "~" . $ob->name . "/" . $self->{path}
		1468	if $self->per_player;
		1469
		1470	$self
		1471	}
		1472
		1473	# find and load all maps in the 3x3 area around a map
		1474	sub load_diag {
965	my ($map) = @_;	1475	my ($map) = @_;
966		1476
967	my $path = $map->tmpname;	1477	my @diag; # diagonal neighbours
968	defined $path or return;
969		1478
970	unlink "$path.pst";	1479	for (0 .. 3) {
971	};	1480	my $neigh = $map->tile_path ($_)
		1481	or next;
		1482	$neigh = find $neigh, $map
		1483	or next;
		1484	$neigh->load;
972		1485
973	cf::map->attach (prio => -10000, package => cf::mapsupport::);	1486	push @diag, [$neigh->tile_path (($_ + 3) % 4), $neigh],
		1487	[$neigh->tile_path (($_ + 1) % 4), $neigh];
		1488	}
974		1489
975	#############################################################################	1490	for (@diag) {
976	# load/save perl data associated with player->ob objects	1491	my $neigh = find @$_
977		1492	or next;
978	sub all_objects(@) {	1493	$neigh->load;
979	@_, map all_objects ($_->inv), @_	1494	}
980	}	1495	}
981		1496
982	# TODO: compatibility cruft, remove when no longer needed	1497	sub find_sync {
983	cf::player->attach (	1498	my ($path, $origin) = @_;
984	on_load => sub {
985	my ($pl, $path) = @_;
986		1499
987	for my $o (all_objects $pl->ob) {	1500	cf::sync_job { find $path, $origin }
988	if (my $value = $o->get_ob_key_value ("_perl_data")) {	1501	}
989	$o->set_ob_key_value ("_perl_data");
990		1502
991	%$o = %{ Storable::thaw pack "H*", $value };	1503	sub do_load_sync {
		1504	my ($map) = @_;
		1505
		1506	cf::sync_job { $map->load };
		1507	}
		1508
		1509	our %MAP_PREFETCH;
		1510	our $MAP_PREFETCHER = undef;
		1511
		1512	sub find_async {
		1513	my ($path, $origin) = @_;
		1514
		1515	$path = normalise $path, $origin && $origin->{path};
		1516
		1517	if (my $map = $cf::MAP{$path}) {
		1518	return $map if $map->in_memory == cf::MAP_IN_MEMORY;
		1519	}
		1520
		1521	undef $MAP_PREFETCH{$path};
		1522	$MAP_PREFETCHER ||= cf::async {
		1523	while (%MAP_PREFETCH) {
		1524	for my $path (keys %MAP_PREFETCH) {
		1525	my $map = find $path
		1526	or next;
		1527	$map->load;
		1528
		1529	delete $MAP_PREFETCH{$path};
992	}	1530	}
993	}	1531	}
		1532	undef $MAP_PREFETCHER;
		1533	};
		1534	$MAP_PREFETCHER->prio (6);
		1535
		1536	()
		1537	}
		1538
		1539	sub save {
		1540	my ($self) = @_;
		1541
		1542	my $lock = cf::lock_acquire "map_data:" . $self->path;
		1543
		1544	$self->{last_save} = $cf::RUNTIME;
		1545
		1546	return unless $self->dirty;
		1547
		1548	my $save = $self->save_path; utf8::encode $save;
		1549	my $uniq = $self->uniq_path; utf8::encode $uniq;
		1550
		1551	$self->{load_path} = $save;
		1552
		1553	return if $self->{deny_save};
		1554
		1555	local $self->{last_access} = $self->last_access;#d#
		1556
		1557	cf::async {
		1558	$_->contr->save for $self->players;
		1559	};
		1560
		1561	if ($uniq) {
		1562	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
		1563	$self->_save_objects ($uniq, cf::IO_UNIQUES);
		1564	} else {
		1565	$self->_save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
994	},	1566	}
995	);	1567	}
996		1568
997	#############################################################################	1569	sub swap_out {
		1570	my ($self) = @_;
998		1571
999	=head2 CORE EXTENSIONS	1572	# save first because save cedes
		1573	$self->save;
1000		1574
1001	Functions and methods that extend core crossfire objects.	1575	my $lock = cf::lock_acquire "map_data:" . $self->path;
1002		1576
1003	=head3 cf::player	1577	return if $self->players;
		1578	return if $self->in_memory != cf::MAP_IN_MEMORY;
		1579	return if $self->{deny_save};
		1580
		1581	$self->clear;
		1582	$self->in_memory (cf::MAP_SWAPPED);
		1583	}
		1584
		1585	sub reset_at {
		1586	my ($self) = @_;
		1587
		1588	# TODO: safety, remove and allow resettable per-player maps
		1589	return 1e99 if $self->isa ("ext::map_per_player");#d#
		1590	return 1e99 if $self->{deny_reset};
		1591
		1592	my $time = $self->fixed_resettime ? $self->{instantiate_time} : $self->last_access;
		1593	my $to = List::Util::min $MAX_RESET, $self->reset_timeout || $DEFAULT_RESET;
		1594
		1595	$time + $to
		1596	}
		1597
		1598	sub should_reset {
		1599	my ($self) = @_;
		1600
		1601	$self->reset_at <= $cf::RUNTIME
		1602	}
		1603
		1604	sub reset {
		1605	my ($self) = @_;
		1606
		1607	my $lock = cf::lock_acquire "map_data:$self->{path}";
		1608
		1609	return if $self->players;
		1610	return if $self->isa ("ext::map_per_player");#d#
		1611
		1612	warn "resetting map ", $self->path;#d#
		1613
		1614	delete $cf::MAP{$self->path};
		1615
		1616	$self->in_memory (cf::MAP_SWAPPED);
		1617	$self->clear;
		1618
		1619	$_->clear_links_to ($self) for values %cf::MAP;
		1620
		1621	$self->unlink_save;
		1622	$self->destroy;
		1623	}
		1624
		1625	my $nuke_counter = "aaaa";
		1626
		1627	sub nuke {
		1628	my ($self) = @_;
		1629
		1630	delete $cf::MAP{$self->path};
		1631
		1632	$self->unlink_save;
		1633
		1634	bless $self, "cf::map";
		1635	delete $self->{deny_reset};
		1636	$self->{deny_save} = 1;
		1637	$self->reset_timeout (1);
		1638	$self->path ($self->{path} = "{nuke}/" . ($nuke_counter++));
		1639
		1640	$cf::MAP{$self->path} = $self;
		1641
		1642	$self->reset; # polite request, might not happen
		1643	}
		1644
		1645	=item cf::map::unique_maps
		1646
		1647	Returns an arrayref of paths of all shared maps that have
		1648	instantiated unique items. May block.
		1649
		1650	=cut
		1651
		1652	sub unique_maps() {
		1653	my $files = aio_readdir cf::localdir . "/" . cf::uniquedir
		1654	or return;
		1655
		1656	my @paths;
		1657
		1658	for (@$files) {
		1659	utf8::decode $_;
		1660	next if /\.pst$/;
		1661	next unless /^$PATH_SEP/o;
		1662
		1663	push @paths, cf::map::normalise $_;
		1664	}
		1665
		1666	\@paths
		1667	}
		1668
		1669	package cf;
		1670
		1671	=back
		1672
		1673	=head3 cf::object
		1674
		1675	=cut
		1676
		1677	package cf::object;
1004		1678
1005	=over 4	1679	=over 4
1006		1680
1007	=item cf::player::exists $login	1681	=item $ob->inv_recursive
1008		1682
1009	Returns true when the given account exists.	1683	Returns the inventory of the object _and_ their inventories, recursively.
1010		1684
1011	=cut	1685	=cut
1012		1686
1013	sub cf::player::exists($) {	1687	sub inv_recursive_;
1014	cf::player::find $_[0]	1688	sub inv_recursive_ {
1015	or -f sprintf "%s/%s/%s/%s.pl", cf::localdir, cf::playerdir, ($_[0]) x 2;	1689	map { $_, inv_recursive_ $_->inv } @_
1016	}	1690	}
1017		1691
1018	=item $player->ext_reply ($msgid, $msgtype, %msg)	1692	sub inv_recursive {
1019		1693	inv_recursive_ inv $_[0]
1020	Sends an ext reply to the player.
1021
1022	=cut
1023
1024	sub cf::player::ext_reply($$$%) {
1025	my ($self, $id, %msg) = @_;
1026
1027	$msg{msgid} = $id;
1028
1029	$self->send ("ext " . to_json \%msg);
1030	}	1694	}
		1695
		1696	package cf;
1031		1697
1032	=back	1698	=back
1033		1699
1034	=head3 cf::object::player	1700	=head3 cf::object::player
1035		1701
…		…
1073	(ref $cf::CFG{"may_$access"}	1739	(ref $cf::CFG{"may_$access"}
1074	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}	1740	? scalar grep $self->name eq $_, @{$cf::CFG{"may_$access"}}
1075	: $cf::CFG{"may_$access"})	1741	: $cf::CFG{"may_$access"})
1076	}	1742	}
1077		1743
		1744	=item $player_object->enter_link
		1745
		1746	Freezes the player and moves him/her to a special map (C<{link}>).
		1747
		1748	The player should be reasonably safe there for short amounts of time. You
		1749	I<MUST> call C<leave_link> as soon as possible, though.
		1750
		1751	Will never block.
		1752
		1753	=item $player_object->leave_link ($map, $x, $y)
		1754
		1755	Moves the player out of the special C<{link}> map onto the specified
		1756	map. If the map is not valid (or omitted), the player will be moved back
		1757	to the location he/she was before the call to C<enter_link>, or, if that
		1758	fails, to the emergency map position.
		1759
		1760	Might block.
		1761
		1762	=cut
		1763
		1764	sub link_map {
		1765	unless ($LINK_MAP) {
		1766	$LINK_MAP = cf::map::find "{link}"
		1767	or cf::cleanup "FATAL: unable to provide {link} map, exiting.";
		1768	$LINK_MAP->load;
		1769	}
		1770
		1771	$LINK_MAP
		1772	}
		1773
		1774	sub cf::object::player::enter_link {
		1775	my ($self) = @_;
		1776
		1777	$self->deactivate_recursive;
		1778
		1779	return if UNIVERSAL::isa $self->map, "ext::map_link";
		1780
		1781	$self->{_link_pos} ||= [$self->map->{path}, $self->x, $self->y]
		1782	if $self->map;
		1783
		1784	$self->enter_map ($LINK_MAP || link_map, 10, 10);
		1785	}
		1786
		1787	sub cf::object::player::leave_link {
		1788	my ($self, $map, $x, $y) = @_;
		1789
		1790	my $link_pos = delete $self->{_link_pos};
		1791
		1792	unless ($map) {
		1793	# restore original map position
		1794	($map, $x, $y) = @{ $link_pos || [] };
		1795	$map = cf::map::find $map;
		1796
		1797	unless ($map) {
		1798	($map, $x, $y) = @$EMERGENCY_POSITION;
		1799	$map = cf::map::find $map
		1800	or die "FATAL: cannot load emergency map\n";
		1801	}
		1802	}
		1803
		1804	($x, $y) = (-1, -1)
		1805	unless (defined $x) && (defined $y);
		1806
		1807	# use -1 or undef as default coordinates, not 0, 0
		1808	($x, $y) = ($map->enter_x, $map->enter_y)
		1809	if $x <=0 && $y <= 0;
		1810
		1811	$map->load;
		1812	$map->load_diag;
		1813
		1814	return unless $self->contr->active;
		1815	$self->activate_recursive;
		1816	$self->enter_map ($map, $x, $y);
		1817	}
		1818
		1819	cf::player->attach (
		1820	on_logout => sub {
		1821	my ($pl) = @_;
		1822
		1823	# abort map switching before logout
		1824	if ($pl->ob->{_link_pos}) {
		1825	cf::sync_job {
		1826	$pl->ob->leave_link
		1827	};
		1828	}
		1829	},
		1830	on_login => sub {
		1831	my ($pl) = @_;
		1832
		1833	# try to abort aborted map switching on player login :)
		1834	# should happen only on crashes
		1835	if ($pl->ob->{_link_pos}) {
		1836	$pl->ob->enter_link;
		1837	(async {
		1838	# we need this sleep as the login has a concurrent enter_exit running
		1839	# and this sleep increases chances of the player not ending up in scorn
		1840	$pl->ob->reply (undef,
		1841	"There was an internal problem at your last logout, "
		1842	. "the server will try to bring you to your intended destination in a second.",
		1843	cf::NDI_RED);
		1844	Coro::Timer::sleep 1;
		1845	$pl->ob->leave_link;
		1846	})->prio (2);
		1847	}
		1848	},
		1849	);
		1850
		1851	=item $player_object->goto ($path, $x, $y)
		1852
		1853	=cut
		1854
		1855	sub cf::object::player::goto {
		1856	my ($self, $path, $x, $y) = @_;
		1857
		1858	$self->enter_link;
		1859
		1860	(async {
		1861	my $map = eval {
		1862	my $map = cf::map::find $path;
		1863	$map = $map->customise_for ($self) if $map;
		1864	$map
		1865	} or
		1866	$self->message ("The exit to '$path' is closed", cf::NDI_UNIQUE | cf::NDI_RED);
		1867
		1868	$self->leave_link ($map, $x, $y);
		1869	})->prio (1);
		1870	}
		1871
		1872	=item $player_object->enter_exit ($exit_object)
		1873
		1874	=cut
		1875
		1876	sub parse_random_map_params {
		1877	my ($spec) = @_;
		1878
		1879	my $rmp = { # defaults
		1880	xsize => (cf::rndm 15, 40),
		1881	ysize => (cf::rndm 15, 40),
		1882	symmetry => (cf::rndm 1, cf::SYMMETRY_XY),
		1883	#layout => string,
		1884	};
		1885
		1886	for (split /\n/, $spec) {
		1887	my ($k, $v) = split /\s+/, $_, 2;
		1888
		1889	$rmp->{lc $k} = $v if (length $k) && (length $v);
		1890	}
		1891
		1892	$rmp
		1893	}
		1894
		1895	sub prepare_random_map {
		1896	my ($exit) = @_;
		1897
		1898	my $guard = cf::lock_acquire "exit_prepare:$exit";
		1899
		1900	# all this does is basically replace the /! path by
		1901	# a new random map path (?random/...) with a seed
		1902	# that depends on the exit object
		1903
		1904	my $rmp = parse_random_map_params $exit->msg;
		1905
		1906	if ($exit->map) {
		1907	$rmp->{region} = $exit->region->name;
		1908	$rmp->{origin_map} = $exit->map->path;
		1909	$rmp->{origin_x} = $exit->x;
		1910	$rmp->{origin_y} = $exit->y;
		1911	}
		1912
		1913	$rmp->{random_seed} ||= $exit->random_seed;
		1914
		1915	my $data = cf::to_json $rmp;
		1916	my $md5 = Digest::MD5::md5_hex $data;
		1917	my $meta = "$cf::RANDOM_MAPS/$md5.meta";
		1918
		1919	if (my $fh = aio_open "$meta~", O_WRONLY | O_CREAT, 0666) {
		1920	aio_write $fh, 0, (length $data), $data, 0;
		1921	undef $fh;
		1922	aio_rename "$meta~", $meta;
		1923
		1924	$exit->slaying ("?random/$md5");
		1925	$exit->msg (undef);
		1926	}
		1927	}
		1928
		1929	sub cf::object::player::enter_exit {
		1930	my ($self, $exit) = @_;
		1931
		1932	return unless $self->type == cf::PLAYER;
		1933
		1934	if ($exit->slaying eq "/!") {
		1935	#TODO: this should de-fi-ni-te-ly not be a sync-job
		1936	cf::sync_job { prepare_random_map $exit };
		1937	}
		1938
		1939	my $slaying = cf::map::normalise $exit->slaying, $exit->map && $exit->map->path;
		1940	my $hp = $exit->stats->hp;
		1941	my $sp = $exit->stats->sp;
		1942
		1943	$self->enter_link;
		1944
		1945	(async {
		1946	$self->deactivate_recursive; # just to be sure
		1947	unless (eval {
		1948	$self->goto ($slaying, $hp, $sp);
		1949
		1950	1;
		1951	}) {
		1952	$self->message ("Something went wrong deep within the crossfire server. "
		1953	. "I'll try to bring you back to the map you were before. "
		1954	. "Please report this to the dungeon master!",
		1955	cf::NDI_UNIQUE | cf::NDI_RED);
		1956
		1957	warn "ERROR in enter_exit: $@";
		1958	$self->leave_link;
		1959	}
		1960	})->prio (1);
		1961	}
		1962
1078	=head3 cf::client	1963	=head3 cf::client
1079		1964
1080	=over 4	1965	=over 4
1081		1966
1082	=item $client->send_drawinfo ($text, $flags)	1967	=item $client->send_drawinfo ($text, $flags)
…		…
1125	on_reply => sub {	2010	on_reply => sub {
1126	my ($ns, $msg) = @_;	2011	my ($ns, $msg) = @_;
1127		2012
1128	# this weird shuffling is so that direct followup queries	2013	# this weird shuffling is so that direct followup queries
1129	# get handled first	2014	# get handled first
1130	my $queue = delete $ns->{query_queue};	2015	my $queue = delete $ns->{query_queue}
		2016	or return; # be conservative, not sure how that can happen, but we saw a crash here
1131		2017
1132	(shift @$queue)->[1]->($msg);	2018	(shift @$queue)->[1]->($msg);
		2019	return unless $ns->valid; # temporary(?) workaround for callback destroying socket
1133		2020
1134	push @{ $ns->{query_queue} }, @$queue;	2021	push @{ $ns->{query_queue} }, @$queue;
1135		2022
1136	if (@{ $ns->{query_queue} } == @$queue) {	2023	if (@{ $ns->{query_queue} } == @$queue) {
1137	if (@$queue) {	2024	if (@$queue) {
…		…
1141	}	2028	}
1142	}	2029	}
1143	},	2030	},
1144	);	2031	);
1145		2032
1146	=item $client->coro (\&cb)	2033	=item $client->async (\&cb)
1147		2034
1148	Create a new coroutine, running the specified callback. The coroutine will	2035	Create a new coroutine, running the specified callback. The coroutine will
1149	be automatically cancelled when the client gets destroyed (e.g. on logout,	2036	be automatically cancelled when the client gets destroyed (e.g. on logout,
1150	or loss of connection).	2037	or loss of connection).
1151		2038
1152	=cut	2039	=cut
1153		2040
1154	sub cf::client::coro {	2041	sub cf::client::async {
1155	my ($self, $cb) = @_;	2042	my ($self, $cb) = @_;
1156		2043
1157	my $coro; $coro = async {	2044	my $coro = &Coro::async ($cb);
1158	eval {
1159	$cb->();
1160	};
1161	warn $@ if $@;
1162	};
1163		2045
1164	$coro->on_destroy (sub {	2046	$coro->on_destroy (sub {
1165	delete $self->{_coro}{$coro+0};	2047	delete $self->{_coro}{$coro+0};
1166	});	2048	});
1167		2049
…		…
1303	The parameter C<$family> should best start with the name of the extension	2185	The parameter C<$family> should best start with the name of the extension
1304	using it, it should be unique.	2186	using it, it should be unique.
1305		2187
1306	=over 4	2188	=over 4
1307		2189
1308	=item $hashref = cf::db_get $family
1309
1310	Return a hashref for use by the extension C<$family>, which can be
1311	modified. After modifications, you have to call C<cf::db_dirty> or
1312	C<cf::db_sync>.
1313
1314	=item $value = cf::db_get $family => $key	2190	=item $value = cf::db_get $family => $key
1315		2191
1316	Returns a single value from the database	2192	Returns a single value from the database.
1317
1318	=item cf::db_put $family => $hashref
1319
1320	Stores the given family hashref into the database. Updates are delayed, if
1321	you want the data to be synced to disk immediately, use C<cf::db_sync>.
1322		2193
1323	=item cf::db_put $family => $key => $value	2194	=item cf::db_put $family => $key => $value
1324		2195
1325	Stores the given C<$value> in the family hash. Updates are delayed, if you	2196	Stores the given C<$value> in the family.
1326	want the data to be synced to disk immediately, use C<cf::db_sync>.
1327
1328	=item cf::db_dirty
1329
1330	Marks the database as dirty, to be updated at a later time.
1331
1332	=item cf::db_sync
1333
1334	Immediately write the database to disk I<if it is dirty>.
1335		2197
1336	=cut	2198	=cut
1337		2199
1338	our $DB;	2200	our $DB;
1339		2201
1340	{	2202	sub db_load() {
		2203	unless ($DB) {
		2204	$DB = BDB::db_create $DB_ENV;
		2205
		2206	cf::sync_job {
		2207	eval {
		2208	$DB->set_flags (BDB::CHKSUM);
		2209
		2210	BDB::db_open $DB, undef, "db", undef, BDB::BTREE,
		2211	BDB::CREATE | BDB::AUTO_COMMIT, 0666;
		2212	cf::cleanup "db_open(db): $!" if $!;
		2213	};
		2214	cf::cleanup "db_open(db): $@" if $@;
		2215	};
		2216
1341	my $path = cf::localdir . "/database.pst";	2217	my $path = cf::localdir . "/database.pst";
		2218	if (stat $path) {
		2219	cf::sync_job {
		2220	my $pst = Storable::retrieve $path;
1342		2221
1343	sub db_load() {	2222	cf::db_put (board => data => $pst->{board});
1344	warn "loading database $path\n";#d# remove later	2223	cf::db_put (guildrules => data => $pst->{guildrules});
1345	$DB = stat $path ? Storable::retrieve $path : { };	2224	cf::db_put (rent => balance => $pst->{rent}{balance});
1346	}	2225	BDB::db_env_txn_checkpoint $DB_ENV;
1347		2226
1348	my $pid;	2227	unlink $path;
1349
1350	sub db_save() {
1351	warn "saving database $path\n";#d# remove later
1352	waitpid $pid, 0 if $pid;
1353	if (0 == ($pid = fork)) {
1354	$DB->{_meta}{version} = 1;
1355	Storable::nstore $DB, "$path~";
1356	rename "$path~", $path;
1357	cf::_exit 0 if defined $pid;
1358	}	2228	};
1359	}
1360
1361	my $dirty;
1362
1363	sub db_sync() {
1364	db_save if $dirty;
1365	undef $dirty;
1366	}
1367
1368	my $idle = Event->idle (min => $TICK * 2.8, max => 10, repeat => 0, data => WF_AUTOCANCEL, cb => sub {
1369	db_sync;
1370	});
1371
1372	sub db_dirty() {
1373	$dirty = 1;
1374	$idle->start;
1375	}
1376
1377	sub db_get($;$) {
1378	@_ >= 2
1379	? $DB->{$_[0]}{$_[1]}
1380	: ($DB->{$_[0]} ||= { })
1381	}
1382
1383	sub db_put($$;$) {
1384	if (@_ >= 3) {
1385	$DB->{$_[0]}{$_[1]} = $_[2];
1386	} else {
1387	$DB->{$_[0]} = $_[1];
1388	}
1389	db_dirty;
1390	}
1391
1392	cf::global->attach (
1393	prio => 10000,
1394	on_cleanup => sub {
1395	db_sync;
1396	},	2229	}
1397	);	2230	}
		2231	}
		2232
		2233	sub db_get($$) {
		2234	my $key = "$_[0]/$_[1]";
		2235
		2236	cf::sync_job {
		2237	BDB::db_get $DB, undef, $key, my $data;
		2238
		2239	$! ? ()
		2240	: Compress::LZF::sthaw $data
		2241	}
		2242	}
		2243
		2244	sub db_put($$$) {
		2245	BDB::dbreq_pri 4;
		2246	BDB::db_put $DB, undef, "$_[0]/$_[1]", Compress::LZF::sfreeze_cr $_[2], 0, sub { };
1398	}	2247	}
1399		2248
1400	#############################################################################	2249	#############################################################################
1401	# the server's main()	2250	# the server's init and main functions
		2251
		2252	sub load_resources {
		2253	load_regions sprintf "%s/%s/regions", cf::datadir, cf::mapdir
		2254	or die "unable to load regions file\n";#d#
		2255	}
1402		2256
1403	sub cfg_load {	2257	sub cfg_load {
1404	open my $fh, "<:utf8", cf::confdir . "/config"	2258	open my $fh, "<:utf8", cf::confdir . "/config"
1405	or return;	2259	or return;
1406		2260
1407	local $/;	2261	local $/;
1408	*CFG = YAML::Syck::Load <$fh>;	2262	*CFG = YAML::Syck::Load <$fh>;
		2263
		2264	$EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
		2265
		2266	$cf::map::MAX_RESET = $CFG{map_max_reset} if exists $CFG{map_max_reset};
		2267	$cf::map::DEFAULT_RESET = $CFG{map_default_reset} if exists $CFG{map_default_reset};
		2268
		2269	if (exists $CFG{mlockall}) {
		2270	eval {
		2271	$CFG{mlockall} ? eval "mlockall()" : eval "munlockall()"
		2272	and die "WARNING: m(un)lockall failed: $!\n";
		2273	};
		2274	warn $@ if $@;
		2275	}
		2276	}
		2277
		2278	sub init {
		2279	load_resources;
1409	}	2280	}
1410		2281
1411	sub main {	2282	sub main {
1412	# we must not ever block the main coroutine	2283	# we must not ever block the main coroutine
1413	local $Coro::idle = sub {	2284	local $Coro::idle = sub {
1414	Carp::cluck "FATAL: Coro::idle was called, major BUG\n";#d#	2285	Carp::cluck "FATAL: Coro::idle was called, major BUG, use cf::sync_job!\n";#d#
1415	(Coro::unblock_sub {	2286	(async {
1416	Event::one_event;	2287	Event::one_event;
1417	})->();	2288	})->prio (Coro::PRIO_MAX);
1418	};	2289	};
1419		2290
1420	cfg_load;	2291	cfg_load;
1421	db_load;	2292	db_load;
1422	load_extensions;	2293	load_extensions;
		2294
		2295	$TICK_WATCHER->start;
1423	Event::loop;	2296	Event::loop;
1424	}	2297	}
1425		2298
1426	#############################################################################	2299	#############################################################################
1427	# initialisation	2300	# initialisation and cleanup
1428		2301
		2302	# install some emergency cleanup handlers
		2303	BEGIN {
		2304	for my $signal (qw(INT HUP TERM)) {
		2305	Event->signal (
		2306	reentrant => 0,
		2307	data => WF_AUTOCANCEL,
		2308	signal => $signal,
		2309	prio => 0,
		2310	cb => sub {
		2311	cf::cleanup "SIG$signal";
		2312	},
		2313	);
		2314	}
		2315	}
		2316
		2317	sub emergency_save() {
		2318	my $freeze_guard = cf::freeze_mainloop;
		2319
		2320	warn "enter emergency perl save\n";
		2321
		2322	cf::sync_job {
		2323	# use a peculiar iteration method to avoid tripping on perl
		2324	# refcount bugs in for. also avoids problems with players
		2325	# and maps saved/destroyed asynchronously.
		2326	warn "begin emergency player save\n";
		2327	for my $login (keys %cf::PLAYER) {
		2328	my $pl = $cf::PLAYER{$login} or next;
		2329	$pl->valid or next;
		2330	$pl->save;
		2331	}
		2332	warn "end emergency player save\n";
		2333
		2334	warn "begin emergency map save\n";
		2335	for my $path (keys %cf::MAP) {
		2336	my $map = $cf::MAP{$path} or next;
		2337	$map->valid or next;
		2338	$map->save;
		2339	}
		2340	warn "end emergency map save\n";
		2341
		2342	warn "begin emergency database checkpoint\n";
		2343	BDB::db_env_txn_checkpoint $DB_ENV;
		2344	warn "end emergency database checkpoint\n";
		2345	};
		2346
		2347	warn "leave emergency perl save\n";
		2348	}
		2349
1429	sub perl_reload() {	2350	sub reload() {
1430	# can/must only be called in main	2351	# can/must only be called in main
1431	if ($Coro::current != $Coro::main) {	2352	if ($Coro::current != $Coro::main) {
1432	warn "can only reload from main coroutine\n";	2353	warn "can only reload from main coroutine";
1433	return;	2354	return;
1434	}	2355	}
1435		2356
1436	warn "reloading...";	2357	warn "reloading...";
1437		2358
1438	local $FREEZE = 1;	2359	warn "cancelling server ticker";
		2360	$TICK_WATCHER->cancel;
		2361
1439	cf::emergency_save;	2362	cf::emergency_save;
1440		2363
1441	eval {	2364	eval {
1442	# if anything goes wrong in here, we should simply crash as we already saved	2365	# if anything goes wrong in here, we should simply crash as we already saved
1443		2366
1444	# cancel all watchers	2367	warn "cancelling all WF_AUTOCANCEL watchers";
1445	for (Event::all_watchers) {	2368	for (Event::all_watchers) {
1446	$_->cancel if $_->data & WF_AUTOCANCEL;	2369	$_->cancel if $_->data & WF_AUTOCANCEL;
1447	}	2370	}
1448		2371
		2372	warn "syncing database to disk";
		2373	BDB::db_env_txn_checkpoint $DB_ENV, 0, 0, 0, sub { };
		2374
		2375	warn "flushing outstanding aio requests";
		2376	for (;;) {
		2377	BDB::flush;
		2378	IO::AIO::flush;
		2379	Coro::cede;
		2380	last unless IO::AIO::nreqs || BDB::nreqs;
		2381	warn "iterate...";
		2382	}
		2383
1449	# cancel all extension coros	2384	warn "cancelling all extension coros";
1450	$_->cancel for values %EXT_CORO;	2385	$_->cancel for values %EXT_CORO;
1451	%EXT_CORO = ();	2386	%EXT_CORO = ();
1452		2387
1453	# unload all extensions	2388	warn "removing commands";
1454	for (@exts) {	2389	%COMMAND = ();
		2390
		2391	warn "removing ext commands";
		2392	%EXTCMD = ();
		2393
		2394	warn "unloading/nuking all extensions";
		2395	for my $pkg (@EXTS) {
1455	warn "unloading <$_>";	2396	warn "... unloading $pkg";
1456	unload_extension $_;	2397
		2398	if (my $cb = $pkg->can ("unload")) {
		2399	eval {
		2400	$cb->($pkg);
		2401	1
		2402	} or warn "$pkg unloaded, but with errors: $@";
1457	}	2403	}
1458		2404
		2405	warn "... nuking $pkg";
		2406	Symbol::delete_package $pkg;
		2407	}
		2408
1459	# unload all modules loaded from $LIBDIR	2409	warn "unloading all perl modules loaded from $LIBDIR";
1460	while (my ($k, $v) = each %INC) {	2410	while (my ($k, $v) = each %INC) {
1461	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;	2411	next unless $v =~ /^\Q$LIBDIR\E\/.*\.pm$/;
1462		2412
1463	warn "removing <$k>";	2413	warn "... unloading $k";
1464	delete $INC{$k};	2414	delete $INC{$k};
1465		2415
1466	$k =~ s/\.pm$//;	2416	$k =~ s/\.pm$//;
1467	$k =~ s/\//::/g;	2417	$k =~ s/\//::/g;
1468		2418
…		…
1471	}	2421	}
1472		2422
1473	Symbol::delete_package $k;	2423	Symbol::delete_package $k;
1474	}	2424	}
1475		2425
1476	# sync database to disk
1477	cf::db_sync;
1478	IO::AIO::flush;
1479
1480	# get rid of safe::, as good as possible	2426	warn "getting rid of safe::, as good as possible";
1481	Symbol::delete_package "safe::$_"	2427	Symbol::delete_package "safe::$_"
1482	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);	2428	for qw(cf::attachable cf::object cf::object::player cf::client cf::player cf::map cf::party cf::region);
1483		2429
1484	# remove register_script_function callbacks
1485	# TODO
1486
1487	# unload cf.pm "a bit"	2430	warn "unloading cf.pm \"a bit\"";
1488	delete $INC{"cf.pm"};	2431	delete $INC{"cf.pm"};
1489		2432
1490	# don't, removes xs symbols, too,	2433	# don't, removes xs symbols, too,
1491	# and global variables created in xs	2434	# and global variables created in xs
1492	#Symbol::delete_package __PACKAGE__;	2435	#Symbol::delete_package __PACKAGE__;
1493		2436
1494	# reload cf.pm	2437	warn "unload completed, starting to reload now";
		2438
1495	warn "reloading cf.pm";	2439	warn "reloading cf.pm";
1496	require cf;	2440	require cf;
1497	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt	2441	cf::_connect_to_perl; # nominally unnecessary, but cannot hurt
1498		2442
1499	# load config and database again	2443	warn "loading config and database again";
1500	cf::cfg_load;	2444	cf::cfg_load;
1501	cf::db_load;	2445	cf::db_load;
1502		2446
1503	# load extensions
1504	warn "load extensions";	2447	warn "loading extensions";
1505	cf::load_extensions;	2448	cf::load_extensions;
1506		2449
1507	# reattach attachments to objects	2450	warn "reattaching attachments to objects/players";
1508	warn "reattach";
1509	_global_reattach;	2451	_global_reattach;
		2452	warn "reattaching attachments to maps";
		2453	reattach $_ for values %MAP;
		2454
		2455	warn "loading reloadable resources";
		2456	load_resources;
		2457
		2458	warn "restarting server ticker";
		2459
		2460	$TICK_WATCHER->start;
1510	};	2461	};
1511		2462
1512	if ($@) {	2463	if ($@) {
1513	warn $@;	2464	warn $@;
1514	warn "error while reloading, exiting.";	2465	warn "error while reloading, exiting.";
1515	exit 1;	2466	exit 1;
1516	}	2467	}
1517		2468
1518	warn "reloaded successfully";	2469	warn "reloaded";
1519	};	2470	};
1520		2471
1521	#############################################################################	2472	our $RELOAD_WATCHER; # used only during reload
1522		2473
1523	unless ($LINK_MAP) {
1524	$LINK_MAP = cf::map::new;
1525
1526	$LINK_MAP->width (41);
1527	$LINK_MAP->height (41);
1528	$LINK_MAP->alloc;
1529	$LINK_MAP->path ("{link}");
1530	$LINK_MAP->{path} = bless { path => "{link}" }, "cf::path";
1531	$LINK_MAP->in_memory (MAP_IN_MEMORY);
1532	}
1533
1534	register "<global>", __PACKAGE__;
1535
1536	register_command "perl-reload" => sub {	2474	register_command "reload" => sub {
1537	my ($who, $arg) = @_;	2475	my ($who, $arg) = @_;
1538		2476
1539	if ($who->flag (FLAG_WIZ)) {	2477	if ($who->flag (FLAG_WIZ)) {
1540	$who->message ("start of reload.");
1541	perl_reload;
1542	$who->message ("end of reload.");	2478	$who->message ("reloading server.");
		2479
		2480	# doing reload synchronously and two reloads happen back-to-back,
		2481	# coro crashes during coro_state_free->destroy here.
		2482
		2483	$RELOAD_WATCHER ||= Event->timer (
		2484	reentrant => 0,
		2485	after => 0,
		2486	data => WF_AUTOCANCEL,
		2487	cb => sub {
		2488	reload;
		2489	undef $RELOAD_WATCHER;
		2490	},
		2491	);
1543	}	2492	}
1544	};	2493	};
1545		2494
1546	unshift @INC, $LIBDIR;	2495	unshift @INC, $LIBDIR;
		2496
		2497	my $bug_warning = 0;
1547		2498
1548	$TICK_WATCHER = Event->timer (	2499	$TICK_WATCHER = Event->timer (
1549	reentrant => 0,	2500	reentrant => 0,
		2501	parked => 1,
1550	prio => 0,	2502	prio => 0,
1551	at => $NEXT_TICK || $TICK,	2503	at => $NEXT_TICK || $TICK,
1552	data => WF_AUTOCANCEL,	2504	data => WF_AUTOCANCEL,
1553	cb => sub {	2505	cb => sub {
1554	unless ($FREEZE) {	2506	if ($Coro::current != $Coro::main) {
		2507	Carp::cluck "major BUG: server tick called outside of main coro, skipping it"
		2508	unless ++$bug_warning > 10;
		2509	return;
		2510	}
		2511
		2512	$NOW = Event::time;
		2513
1555	cf::server_tick; # one server iteration	2514	cf::server_tick; # one server iteration
1556	$RUNTIME += $TICK;	2515	$RUNTIME += $TICK;
1557	}
1558
1559	$NEXT_TICK += $TICK;	2516	$NEXT_TICK += $TICK;
		2517
		2518	$WAIT_FOR_TICK->broadcast;
		2519	$WAIT_FOR_TICK_ONE->send if $WAIT_FOR_TICK_ONE->awaited;
		2520
		2521	Event::sweep;
		2522	Coro::cede_notself;
		2523
		2524	# my $AFTER = Event::time;
		2525	# warn $AFTER - $NOW;#d#
1560		2526
1561	# if we are delayed by four ticks or more, skip them all	2527	# if we are delayed by four ticks or more, skip them all
1562	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;	2528	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
1563		2529
1564	$TICK_WATCHER->at ($NEXT_TICK);	2530	$TICK_WATCHER->at ($NEXT_TICK);
1565	$TICK_WATCHER->start;	2531	$TICK_WATCHER->start;
1566	},	2532	},
1567	);	2533	);
1568		2534
		2535	{
		2536	BDB::max_poll_time $TICK * 0.1;
		2537	$BDB_POLL_WATCHER = Event->io (
		2538	reentrant => 0,
		2539	fd => BDB::poll_fileno,
		2540	poll => 'r',
		2541	prio => 0,
		2542	data => WF_AUTOCANCEL,
		2543	cb => \&BDB::poll_cb,
		2544	);
		2545	BDB::min_parallel 8;
		2546
		2547	BDB::set_sync_prepare {
		2548	my $status;
		2549	my $current = $Coro::current;
		2550	(
		2551	sub {
		2552	$status = $!;
		2553	$current->ready; undef $current;
		2554	},
		2555	sub {
		2556	Coro::schedule while defined $current;
		2557	$! = $status;
		2558	},
		2559	)
		2560	};
		2561
		2562	unless ($DB_ENV) {
		2563	$DB_ENV = BDB::db_env_create;
		2564
		2565	cf::sync_job {
		2566	eval {
		2567	BDB::db_env_open
		2568	$DB_ENV,
		2569	$BDB_ENV_DIR,
		2570	BDB::INIT_LOCK | BDB::INIT_LOG | BDB::INIT_MPOOL | BDB::INIT_TXN
		2571	| BDB::RECOVER | BDB::REGISTER | BDB::USE_ENVIRON | BDB::CREATE,
		2572	0666;
		2573
		2574	cf::cleanup "db_env_open($BDB_ENV_DIR): $!" if $!;
		2575
		2576	$DB_ENV->set_flags (BDB::AUTO_COMMIT | BDB::REGION_INIT | BDB::TXN_NOSYNC, 1);
		2577	$DB_ENV->set_lk_detect;
		2578	};
		2579
		2580	cf::cleanup "db_env_open(db): $@" if $@;
		2581	};
		2582	}
		2583	}
		2584
		2585	{
		2586	IO::AIO::min_parallel 8;
		2587
		2588	undef $Coro::AIO::WATCHER;
1569	IO::AIO::max_poll_time $TICK * 0.2;	2589	IO::AIO::max_poll_time $TICK * 0.1;
1570		2590	$AIO_POLL_WATCHER = Event->io (
1571	Event->io (	2591	reentrant => 0,
1572	fd => IO::AIO::poll_fileno,	2592	fd => IO::AIO::poll_fileno,
1573	poll => 'r',	2593	poll => 'r',
1574	prio => 5,	2594	prio => 6,
1575	data => WF_AUTOCANCEL,	2595	data => WF_AUTOCANCEL,
1576	cb => \&IO::AIO::poll_cb,	2596	cb => \&IO::AIO::poll_cb,
1577	);	2597	);
		2598	}
1578		2599
1579	Event->timer (	2600	$WRITE_RUNTIME_WATCHER = Event->timer (
		2601	reentrant => 0,
1580	data => WF_AUTOCANCEL,	2602	data => WF_AUTOCANCEL,
1581	after => 0,	2603	after => 1,
1582	interval => 10,	2604	interval => 10,
1583	cb => sub {	2605	prio => 6, # keep it lowest so it acts like a watchdog
1584	(Coro::unblock_sub {	2606	cb => Coro::unblock_sub {
1585	write_runtime	2607	write_runtime
1586	or warn "ERROR: unable to write runtime file: $!";	2608	or warn "ERROR: unable to write runtime file: $!";
1587	})->();
1588	},	2609	},
1589	);	2610	);
1590		2611
		2612	END { cf::emergency_save }
		2613
1591	1	2614	1
1592		2615

Diff Legend

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