[ViewVC] Diff of: cvs/deliantra/server/lib/cf.pm

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.128 by root, Wed Jan 3 00:28:47 2007 UTC vs.
Revision 1.133 by root, Thu Jan 4 16:19:32 2007 UTC

…		…
49	our $UPTIME; $UPTIME \|\|= time;	49	our $UPTIME; $UPTIME \|\|= time;
50	our $RUNTIME;	50	our $RUNTIME;
51		51
52	our %MAP; # all maps	52	our %MAP; # all maps
53	our $LINK_MAP; # the special {link} map	53	our $LINK_MAP; # the special {link} map
54	our $FREEZE;
55	our $RANDOM_MAPS = cf::localdir . "/random";	54	our $RANDOM_MAPS = cf::localdir . "/random";
56	our %EXT_CORO;	55	our %EXT_CORO;
57		56
58	binmode STDOUT;	57	binmode STDOUT;
59	binmode STDERR;	58	binmode STDERR;
…		…
71	mkdir cf::localdir . "/" . cf::uniquedir;	70	mkdir cf::localdir . "/" . cf::uniquedir;
72	mkdir $RANDOM_MAPS;	71	mkdir $RANDOM_MAPS;
73		72
74	# a special map that is always available	73	# a special map that is always available
75	our $LINK_MAP;	74	our $LINK_MAP;
76		75	our $EMERGENCY_POSITION;
77	our $EMERGENCY_POSITION = $cf::CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
78		76
79	#############################################################################	77	#############################################################################
80		78
81	=head2 GLOBAL VARIABLES	79	=head2 GLOBAL VARIABLES
82		80
…		…
214	Wait until the given lock is available and then acquires it and returns	212	Wait until the given lock is available and then acquires it and returns
215	a guard object. If the guard object gets destroyed (goes out of scope,	213	a guard object. If the guard object gets destroyed (goes out of scope,
216	for example when the coroutine gets canceled), the lock is automatically	214	for example when the coroutine gets canceled), the lock is automatically
217	returned.	215	returned.
218		216
219	Lock names should begin with a unique identifier (for example, find_map	217	Lock names should begin with a unique identifier (for example, cf::map::find
220	uses map_find and load_map uses map_load).	218	uses map_find and cf::map::load uses map_load).
221		219
222	=cut	220	=cut
223		221
224	our %LOCK;	222	our %LOCK;
225		223
…		…
259		257
260	Coro::async {	258	Coro::async {
261	eval { $cb->() };	259	eval { $cb->() };
262	warn $@ if $@;	260	warn $@ if $@;
263	}	261	}
		262	}
		263
		264	sub freeze_mainloop {
		265	return unless $TICK_WATCHER->is_active;
		266
		267	my $guard = guard { $TICK_WATCHER->start };
		268	$TICK_WATCHER->stop;
		269	$guard
264	}	270	}
265		271
266	=item cf::sync_job { BLOCK }	272	=item cf::sync_job { BLOCK }
267		273
268	The design of crossfire+ requires that the main coro ($Coro::main) is	274	The design of crossfire+ requires that the main coro ($Coro::main) is
…		…
283	# this is the main coro, too bad, we have to block	289	# this is the main coro, too bad, we have to block
284	# till the operation succeeds, freezing the server :/	290	# till the operation succeeds, freezing the server :/
285		291
286	# TODO: use suspend/resume instead	292	# TODO: use suspend/resume instead
287	# (but this is cancel-safe)	293	# (but this is cancel-safe)
288	local $FREEZE = 1;	294	my $freeze_guard = freeze_mainloop;
289		295
290	my $busy = 1;	296	my $busy = 1;
291	my @res;	297	my @res;
292		298
293	(Coro::async {	299	(Coro::async {
…		…
1137	package cf::map;	1143	package cf::map;
1138		1144
1139	use Fcntl;	1145	use Fcntl;
1140	use Coro::AIO;	1146	use Coro::AIO;
1141		1147
1142	our $MAX_RESET = 7200;	1148	our $MAX_RESET = 3600;
1143	our $DEFAULT_RESET = 3600;	1149	our $DEFAULT_RESET = 3000;
1144		1150
1145	sub generate_random_map {	1151	sub generate_random_map {
1146	my ($path, $rmp) = @_;	1152	my ($path, $rmp) = @_;
1147		1153
1148	# mit "rum" bekleckern, nicht	1154	# mit "rum" bekleckern, nicht
…		…
1186	$map->{load_path} = $path;	1192	$map->{load_path} = $path;
1187		1193
1188	$map	1194	$map
1189	}	1195	}
1190		1196
1191	sub find_map;	1197	sub find;
1192	sub find_map {	1198	sub find {
1193	my ($path, $origin) = @_;	1199	my ($path, $origin) = @_;
1194		1200
1195	#warn "find_map<$path,$origin>\n";#d#	1201	#warn "find<$path,$origin>\n";#d#
1196		1202
1197	$path = new cf::path $path, $origin && $origin->path;	1203	$path = new cf::path $path, $origin && $origin->path;
1198	my $key = $path->as_string;	1204	my $key = $path->as_string;
1199		1205
1200	cf::lock_wait "map_find:$key";	1206	cf::lock_wait "map_find:$key";
…		…
1204		1210
1205	# do it the slow way	1211	# do it the slow way
1206	my $map = try_load_header $path->save_path;	1212	my $map = try_load_header $path->save_path;
1207		1213
1208	if ($map) {	1214	if ($map) {
		1215	$map->last_access ((delete $map->{last_access})
		1216	\|\| $cf::RUNTIME); #d#
1209	# safety	1217	# safety
1210	$map->{instantiate_time} = $cf::RUNTIME	1218	$map->{instantiate_time} = $cf::RUNTIME
1211	if $map->{instantiate_time} > $cf::RUNTIME;	1219	if $map->{instantiate_time} > $cf::RUNTIME;
1212	} else {	1220	} else {
1213	if (my $rmp = $path->random_map_params) {	1221	if (my $rmp = $path->random_map_params) {
…		…
1218		1226
1219	$map or return;	1227	$map or return;
1220		1228
1221	$map->{load_original} = 1;	1229	$map->{load_original} = 1;
1222	$map->{instantiate_time} = $cf::RUNTIME;	1230	$map->{instantiate_time} = $cf::RUNTIME;
		1231	$map->last_access ($cf::RUNTIME);
1223	$map->instantiate;	1232	$map->instantiate;
1224		1233
1225	# per-player maps become, after loading, normal maps	1234	# per-player maps become, after loading, normal maps
1226	$map->per_player (0) if $path->{user_rel};	1235	$map->per_player (0) if $path->{user_rel};
1227	}	1236	}
1228		1237
1229	$map->path ($key);	1238	$map->path ($key);
1230	$map->{path} = $path;	1239	$map->{path} = $path;
1231	$map->{last_save} = $cf::RUNTIME;	1240	$map->{last_save} = $cf::RUNTIME;
1232	$map->last_access ($cf::RUNTIME);
1233		1241
1234	if ($map->should_reset) {	1242	if ($map->should_reset) {
1235	$map->reset;	1243	$map->reset;
1236	undef $guard;	1244	undef $guard;
1237	$map = find_map $path	1245	$map = find $path
1238	or return;	1246	or return;
1239	}	1247	}
1240		1248
1241	$cf::MAP{$key} = $map	1249	$cf::MAP{$key} = $map
1242	}	1250	}
…		…
1284	}	1292	}
1285		1293
1286	$self->in_memory (cf::MAP_IN_MEMORY);	1294	$self->in_memory (cf::MAP_IN_MEMORY);
1287	}	1295	}
1288		1296
1289	sub load_map_sync {	1297	sub find_sync {
1290	my ($path, $origin) = @_;	1298	my ($path, $origin) = @_;
1291		1299
1292	#warn "load_map_sync<$path, $origin>\n";#d#	1300	cf::sync_job { cf::map::find $path, $origin }
		1301	}
1293		1302
1294	cf::sync_job {	1303	sub do_load_sync {
1295	my $map = cf::map::find_map $path, $origin	1304	my ($map) = @_;
1296	or return;	1305
1297	$map->load;	1306	cf::sync_job { $map->load };
1298	$map
1299	}
1300	}	1307	}
1301		1308
1302	sub save {	1309	sub save {
1303	my ($self) = @_;	1310	my ($self) = @_;
1304		1311
…		…
1310	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;	1317	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
1311		1318
1312	$self->{load_path} = $save;	1319	$self->{load_path} = $save;
1313		1320
1314	return if $self->{deny_save};	1321	return if $self->{deny_save};
		1322
		1323	local $self->{last_access} = $self->last_access;#d#
1315		1324
1316	if ($uniq) {	1325	if ($uniq) {
1317	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);	1326	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
1318	$self->save_objects ($uniq, cf::IO_UNIQUES);	1327	$self->save_objects ($uniq, cf::IO_UNIQUES);
1319	} else {	1328	} else {
…		…
1322	}	1331	}
1323		1332
1324	sub swap_out {	1333	sub swap_out {
1325	my ($self) = @_;	1334	my ($self) = @_;
1326		1335
		1336	# save first because save cedes
		1337	$self->save;
		1338
1327	return if $self->players;	1339	return if $self->players;
1328	return if $self->in_memory != cf::MAP_IN_MEMORY;	1340	return if $self->in_memory != cf::MAP_IN_MEMORY;
1329	return if $self->{deny_save};	1341	return if $self->{deny_save};
1330		1342
1331	$self->save;
1332	$self->clear;	1343	$self->clear;
1333	$self->in_memory (cf::MAP_SWAPPED);	1344	$self->in_memory (cf::MAP_SWAPPED);
1334	}	1345	}
1335		1346
1336	sub reset_at {	1347	sub reset_at {
…		…
1402		1413
1403	sub customise_for {	1414	sub customise_for {
1404	my ($map, $ob) = @_;	1415	my ($map, $ob) = @_;
1405		1416
1406	if ($map->per_player) {	1417	if ($map->per_player) {
1407	return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};	1418	return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
1408	}	1419	}
1409		1420
1410	$map	1421	$map
1411	}	1422	}
1412		1423
1413	sub emergency_save {	1424	sub emergency_save {
1414	local $cf::FREEZE = 1;	1425	my $freeze_guard = cf::freeze_mainloop;
1415		1426
1416	warn "enter emergency map save\n";	1427	warn "enter emergency map save\n";
1417		1428
1418	cf::sync_job {	1429	cf::sync_job {
1419	warn "begin emergency map save\n";	1430	warn "begin emergency map save\n";
…		…
1509	my $link_pos = delete $self->{_link_pos};	1520	my $link_pos = delete $self->{_link_pos};
1510		1521
1511	unless ($map) {	1522	unless ($map) {
1512	# restore original map position	1523	# restore original map position
1513	($map, $x, $y) = @{ $link_pos \|\| [] };	1524	($map, $x, $y) = @{ $link_pos \|\| [] };
1514	$map = cf::map::find_map $map;	1525	$map = cf::map::find $map;
1515		1526
1516	unless ($map) {	1527	unless ($map) {
1517	($map, $x, $y) = @$EMERGENCY_POSITION;	1528	($map, $x, $y) = @$EMERGENCY_POSITION;
1518	$map = cf::map::find_map $map	1529	$map = cf::map::find $map
1519	or die "FATAL: cannot load emergency map\n";	1530	or die "FATAL: cannot load emergency map\n";
1520	}	1531	}
1521	}	1532	}
1522		1533
1523	($x, $y) = (-1, -1)	1534	($x, $y) = (-1, -1)
…		…
1571	$self->enter_link;	1582	$self->enter_link;
1572		1583
1573	(cf::async {	1584	(cf::async {
1574	$path = new cf::path $path;	1585	$path = new cf::path $path;
1575		1586
1576	my $map = cf::map::find_map $path->as_string;	1587	my $map = cf::map::find $path->as_string;
1577	$map = $map->customise_for ($self) if $map;	1588	$map = $map->customise_for ($self) if $map;
1578		1589
1579	# warn "entering ", $map->path, " at ($x, $y)\n"	1590	# warn "entering ", $map->path, " at ($x, $y)\n"
1580	# if $map;	1591	# if $map;
1581		1592
…		…
1641	return unless $self->type == cf::PLAYER;	1652	return unless $self->type == cf::PLAYER;
1642		1653
1643	$self->enter_link;	1654	$self->enter_link;
1644		1655
1645	(cf::async {	1656	(cf::async {
		1657	$self->deactivate_recursive; # just to be sure
1646	unless (eval {	1658	unless (eval {
1647	prepare_random_map $exit	1659	prepare_random_map $exit
1648	if $exit->slaying eq "/!";	1660	if $exit->slaying eq "/!";
1649		1661
1650	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;	1662	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
…		…
1714	my ($ns, $msg) = @_;	1726	my ($ns, $msg) = @_;
1715		1727
1716	# this weird shuffling is so that direct followup queries	1728	# this weird shuffling is so that direct followup queries
1717	# get handled first	1729	# get handled first
1718	my $queue = delete $ns->{query_queue}	1730	my $queue = delete $ns->{query_queue}
1719	or return; # be conservative, not sure how that cna happen, but we saw a crash here	1731	or return; # be conservative, not sure how that can happen, but we saw a crash here
1720		1732
1721	(shift @$queue)->[1]->($msg);	1733	(shift @$queue)->[1]->($msg);
1722		1734
1723	push @{ $ns->{query_queue} }, @$queue;	1735	push @{ $ns->{query_queue} }, @$queue;
1724		1736
…		…
1986	open my $fh, "<:utf8", cf::confdir . "/config"	1998	open my $fh, "<:utf8", cf::confdir . "/config"
1987	or return;	1999	or return;
1988		2000
1989	local $/;	2001	local $/;
1990	*CFG = YAML::Syck::Load <$fh>;	2002	*CFG = YAML::Syck::Load <$fh>;
		2003
		2004	$EMERGENCY_POSITION = $CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
		2005
		2006	if (exists $CFG{mlockall}) {
		2007	eval {
		2008	$CFG{mlockall} ? &mlockall : &munlockall
		2009	and die "WARNING: m(un)lockall failed: $!\n";
		2010	};
		2011	warn $@ if $@;
		2012	}
1991	}	2013	}
1992		2014
1993	sub main {	2015	sub main {
1994	# we must not ever block the main coroutine	2016	# we must not ever block the main coroutine
1995	local $Coro::idle = sub {	2017	local $Coro::idle = sub {
…		…
2015	return;	2037	return;
2016	}	2038	}
2017		2039
2018	warn "reloading...";	2040	warn "reloading...";
2019		2041
2020	local $FREEZE = 1;	2042	my $guard = freeze_mainloop;
2021	cf::emergency_save;	2043	cf::emergency_save;
2022		2044
2023	eval {	2045	eval {
2024	# if anything goes wrong in here, we should simply crash as we already saved	2046	# if anything goes wrong in here, we should simply crash as we already saved
2025		2047
…		…
2161	reentrant => 0,	2183	reentrant => 0,
2162	prio => 0,	2184	prio => 0,
2163	at => $NEXT_TICK \|\| $TICK,	2185	at => $NEXT_TICK \|\| $TICK,
2164	data => WF_AUTOCANCEL,	2186	data => WF_AUTOCANCEL,
2165	cb => sub {	2187	cb => sub {
2166	unless ($FREEZE) {
2167	cf::server_tick; # one server iteration	2188	cf::server_tick; # one server iteration
2168	$RUNTIME += $TICK;	2189	$RUNTIME += $TICK;
2169	}
2170
2171	$NEXT_TICK += $TICK;	2190	$NEXT_TICK += $TICK;
2172		2191
2173	# if we are delayed by four ticks or more, skip them all	2192	# if we are delayed by four ticks or more, skip them all
2174	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;	2193	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
2175		2194

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.128 by root, Wed Jan 3 00:28:47 2007 UTC vs. Revision 1.133 by root, Thu Jan 4 16:19:32 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.128 by root, Wed Jan 3 00:28:47 2007 UTC vs.
Revision 1.133 by root, Thu Jan 4 16:19:32 2007 UTC