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

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.130 by root, Thu Jan 4 00:08:08 2007 UTC vs.
Revision 1.134 by root, Thu Jan 4 17:28:49 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";
…		…
1203	my $guard = cf::lock_acquire "map_find:$key";	1209	my $guard = cf::lock_acquire "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
		1214	Coro::cede;
		1215
1208	if ($map) {	1216	if ($map) {
		1217	$map->last_access ((delete $map->{last_access})
		1218	\|\| $cf::RUNTIME); #d#
1209	# safety	1219	# safety
1210	$map->{instantiate_time} = $cf::RUNTIME	1220	$map->{instantiate_time} = $cf::RUNTIME
1211	if $map->{instantiate_time} > $cf::RUNTIME;	1221	if $map->{instantiate_time} > $cf::RUNTIME;
1212	} else {	1222	} else {
1213	if (my $rmp = $path->random_map_params) {	1223	if (my $rmp = $path->random_map_params) {
…		…
1218		1228
1219	$map or return;	1229	$map or return;
1220		1230
1221	$map->{load_original} = 1;	1231	$map->{load_original} = 1;
1222	$map->{instantiate_time} = $cf::RUNTIME;	1232	$map->{instantiate_time} = $cf::RUNTIME;
		1233	$map->last_access ($cf::RUNTIME);
1223	$map->instantiate;	1234	$map->instantiate;
1224		1235
1225	# per-player maps become, after loading, normal maps	1236	# per-player maps become, after loading, normal maps
1226	$map->per_player (0) if $path->{user_rel};	1237	$map->per_player (0) if $path->{user_rel};
1227	}	1238	}
1228		1239
1229	$map->path ($key);	1240	$map->path ($key);
1230	$map->{path} = $path;	1241	$map->{path} = $path;
1231	$map->{last_save} = $cf::RUNTIME;	1242	$map->{last_save} = $cf::RUNTIME;
1232	$map->last_access ($cf::RUNTIME);	1243
		1244	Coro::cede;
1233		1245
1234	if ($map->should_reset) {	1246	if ($map->should_reset) {
1235	$map->reset;	1247	$map->reset;
1236	undef $guard;	1248	undef $guard;
1237	$map = find_map $path	1249	$map = find $path
1238	or return;	1250	or return;
1239	}	1251	}
1240		1252
1241	$cf::MAP{$key} = $map	1253	$cf::MAP{$key} = $map
1242	}	1254	}
…		…
1264	if (aio_open $uniq, O_RDONLY, 0) {	1276	if (aio_open $uniq, O_RDONLY, 0) {
1265	$self->clear_unique_items;	1277	$self->clear_unique_items;
1266	$self->load_objects ($uniq, 0);	1278	$self->load_objects ($uniq, 0);
1267	}	1279	}
1268	}	1280	}
		1281
		1282	Coro::cede;
1269		1283
1270	# now do the right thing for maps	1284	# now do the right thing for maps
1271	$self->link_multipart_objects;	1285	$self->link_multipart_objects;
1272		1286
1273	if ($self->{path}->is_style_map) {	1287	if ($self->{path}->is_style_map) {
…		…
1281	$self->difficulty ($self->estimate_difficulty)	1295	$self->difficulty ($self->estimate_difficulty)
1282	unless $self->difficulty;	1296	unless $self->difficulty;
1283	$self->activate;	1297	$self->activate;
1284	}	1298	}
1285		1299
		1300	Coro::cede;
		1301
1286	$self->in_memory (cf::MAP_IN_MEMORY);	1302	$self->in_memory (cf::MAP_IN_MEMORY);
1287	}	1303	}
1288		1304
1289	sub load_map_sync {	1305	sub find_sync {
1290	my ($path, $origin) = @_;	1306	my ($path, $origin) = @_;
1291		1307
1292	#warn "load_map_sync<$path, $origin>\n";#d#	1308	cf::sync_job { cf::map::find $path, $origin }
		1309	}
1293		1310
1294	cf::sync_job {	1311	sub do_load_sync {
1295	my $map = cf::map::find_map $path, $origin	1312	my ($map) = @_;
1296	or return;	1313
1297	$map->load;	1314	cf::sync_job { $map->load };
1298	$map
1299	}
1300	}	1315	}
1301		1316
1302	sub save {	1317	sub save {
1303	my ($self) = @_;	1318	my ($self) = @_;
1304		1319
…		…
1310	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;	1325	my $uniq = $self->{path}->uniq_path; utf8::encode $uniq;
1311		1326
1312	$self->{load_path} = $save;	1327	$self->{load_path} = $save;
1313		1328
1314	return if $self->{deny_save};	1329	return if $self->{deny_save};
		1330
		1331	local $self->{last_access} = $self->last_access;#d#
1315		1332
1316	if ($uniq) {	1333	if ($uniq) {
1317	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);	1334	$self->save_objects ($save, cf::IO_HEADER \| cf::IO_OBJECTS);
1318	$self->save_objects ($uniq, cf::IO_UNIQUES);	1335	$self->save_objects ($uniq, cf::IO_UNIQUES);
1319	} else {	1336	} else {
…		…
1404		1421
1405	sub customise_for {	1422	sub customise_for {
1406	my ($map, $ob) = @_;	1423	my ($map, $ob) = @_;
1407		1424
1408	if ($map->per_player) {	1425	if ($map->per_player) {
1409	return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path};	1426	return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
1410	}	1427	}
1411		1428
1412	$map	1429	$map
1413	}	1430	}
1414		1431
1415	sub emergency_save {	1432	sub emergency_save {
1416	local $cf::FREEZE = 1;	1433	my $freeze_guard = cf::freeze_mainloop;
1417		1434
1418	warn "enter emergency map save\n";	1435	warn "enter emergency map save\n";
1419		1436
1420	cf::sync_job {	1437	cf::sync_job {
1421	warn "begin emergency map save\n";	1438	warn "begin emergency map save\n";
…		…
1511	my $link_pos = delete $self->{_link_pos};	1528	my $link_pos = delete $self->{_link_pos};
1512		1529
1513	unless ($map) {	1530	unless ($map) {
1514	# restore original map position	1531	# restore original map position
1515	($map, $x, $y) = @{ $link_pos \|\| [] };	1532	($map, $x, $y) = @{ $link_pos \|\| [] };
1516	$map = cf::map::find_map $map;	1533	$map = cf::map::find $map;
1517		1534
1518	unless ($map) {	1535	unless ($map) {
1519	($map, $x, $y) = @$EMERGENCY_POSITION;	1536	($map, $x, $y) = @$EMERGENCY_POSITION;
1520	$map = cf::map::find_map $map	1537	$map = cf::map::find $map
1521	or die "FATAL: cannot load emergency map\n";	1538	or die "FATAL: cannot load emergency map\n";
1522	}	1539	}
1523	}	1540	}
1524		1541
1525	($x, $y) = (-1, -1)	1542	($x, $y) = (-1, -1)
…		…
1573	$self->enter_link;	1590	$self->enter_link;
1574		1591
1575	(cf::async {	1592	(cf::async {
1576	$path = new cf::path $path;	1593	$path = new cf::path $path;
1577		1594
1578	my $map = cf::map::find_map $path->as_string;	1595	my $map = cf::map::find $path->as_string;
1579	$map = $map->customise_for ($self) if $map;	1596	$map = $map->customise_for ($self) if $map;
1580		1597
1581	# warn "entering ", $map->path, " at ($x, $y)\n"	1598	# warn "entering ", $map->path, " at ($x, $y)\n"
1582	# if $map;	1599	# if $map;
1583		1600
…		…
1643	return unless $self->type == cf::PLAYER;	1660	return unless $self->type == cf::PLAYER;
1644		1661
1645	$self->enter_link;	1662	$self->enter_link;
1646		1663
1647	(cf::async {	1664	(cf::async {
		1665	$self->deactivate_recursive; # just to be sure
1648	unless (eval {	1666	unless (eval {
1649	prepare_random_map $exit	1667	prepare_random_map $exit
1650	if $exit->slaying eq "/!";	1668	if $exit->slaying eq "/!";
1651		1669
1652	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;	1670	my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
…		…
1988	open my $fh, "<:utf8", cf::confdir . "/config"	2006	open my $fh, "<:utf8", cf::confdir . "/config"
1989	or return;	2007	or return;
1990		2008
1991	local $/;	2009	local $/;
1992	*CFG = YAML::Syck::Load <$fh>;	2010	*CFG = YAML::Syck::Load <$fh>;
		2011
		2012	$EMERGENCY_POSITION = $CFG{emergency_position} \|\| ["/world/world_105_115", 5, 37];
		2013
		2014	if (exists $CFG{mlockall}) {
		2015	eval {
		2016	$CFG{mlockall} ? &mlockall : &munlockall
		2017	and die "WARNING: m(un)lockall failed: $!\n";
		2018	};
		2019	warn $@ if $@;
		2020	}
1993	}	2021	}
1994		2022
1995	sub main {	2023	sub main {
1996	# we must not ever block the main coroutine	2024	# we must not ever block the main coroutine
1997	local $Coro::idle = sub {	2025	local $Coro::idle = sub {
…		…
2017	return;	2045	return;
2018	}	2046	}
2019		2047
2020	warn "reloading...";	2048	warn "reloading...";
2021		2049
2022	local $FREEZE = 1;	2050	my $guard = freeze_mainloop;
2023	cf::emergency_save;	2051	cf::emergency_save;
2024		2052
2025	eval {	2053	eval {
2026	# if anything goes wrong in here, we should simply crash as we already saved	2054	# if anything goes wrong in here, we should simply crash as we already saved
2027		2055
…		…
2163	reentrant => 0,	2191	reentrant => 0,
2164	prio => 0,	2192	prio => 0,
2165	at => $NEXT_TICK \|\| $TICK,	2193	at => $NEXT_TICK \|\| $TICK,
2166	data => WF_AUTOCANCEL,	2194	data => WF_AUTOCANCEL,
2167	cb => sub {	2195	cb => sub {
2168	unless ($FREEZE) {
2169	cf::server_tick; # one server iteration	2196	cf::server_tick; # one server iteration
2170	$RUNTIME += $TICK;	2197	$RUNTIME += $TICK;
2171	}
2172
2173	$NEXT_TICK += $TICK;	2198	$NEXT_TICK += $TICK;
2174		2199
2175	# if we are delayed by four ticks or more, skip them all	2200	# if we are delayed by four ticks or more, skip them all
2176	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;	2201	$NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
2177		2202

Diff Legend

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

Comparing deliantra/server/lib/cf.pm (file contents): Revision 1.130 by root, Thu Jan 4 00:08:08 2007 UTC vs. Revision 1.134 by root, Thu Jan 4 17:28:49 2007 UTC

Diff Legend

Comparing deliantra/server/lib/cf.pm (file contents):
Revision 1.130 by root, Thu Jan 4 00:08:08 2007 UTC vs.
Revision 1.134 by root, Thu Jan 4 17:28:49 2007 UTC