ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/lib/cf.pm
(Generate patch)

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

… …
49our $UPTIME; $UPTIME ||= time; 49our $UPTIME; $UPTIME ||= time;
50our $RUNTIME; 50our $RUNTIME;
51 51
52our %MAP; # all maps 52our %MAP; # all maps
53our $LINK_MAP; # the special {link} map 53our $LINK_MAP; # the special {link} map
54our $FREEZE;
55our $RANDOM_MAPS = cf::localdir . "/random"; 54our $RANDOM_MAPS = cf::localdir . "/random";
56our %EXT_CORO; 55our %EXT_CORO;
57 56
58binmode STDOUT; 57binmode STDOUT;
59binmode STDERR; 58binmode STDERR;
… …
71mkdir cf::localdir . "/" . cf::uniquedir; 70mkdir cf::localdir . "/" . cf::uniquedir;
72mkdir $RANDOM_MAPS; 71mkdir $RANDOM_MAPS;
73 72
74# a special map that is always available 73# a special map that is always available
75our $LINK_MAP; 74our $LINK_MAP;
76 75our $EMERGENCY_POSITION;
77our $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
… …
214Wait until the given lock is available and then acquires it and returns 212Wait until the given lock is available and then acquires it and returns
215a guard object. If the guard object gets destroyed (goes out of scope, 213a guard object. If the guard object gets destroyed (goes out of scope,
216for example when the coroutine gets canceled), the lock is automatically 214for example when the coroutine gets canceled), the lock is automatically
217returned. 215returned.
218 216
219Lock names should begin with a unique identifier (for example, find_map 217Lock names should begin with a unique identifier (for example, cf::map::find
220uses map_find and load_map uses map_load). 218uses map_find and cf::map::load uses map_load).
221 219
222=cut 220=cut
223 221
224our %LOCK; 222our %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
264sub 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
268The design of crossfire+ requires that the main coro ($Coro::main) is 274The 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 {
… …
1137package cf::map; 1143package cf::map;
1138 1144
1139use Fcntl; 1145use Fcntl;
1140use Coro::AIO; 1146use Coro::AIO;
1141 1147
1142our $MAX_RESET = 7200; 1148our $MAX_RESET = 3600;
1143our $DEFAULT_RESET = 3600; 1149our $DEFAULT_RESET = 3000;
1144 1150
1145sub generate_random_map { 1151sub 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
1191sub find_map; 1197sub find;
1192sub find_map { 1198sub 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
1289sub load_map_sync { 1305sub 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 { 1311sub 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
1302sub save { 1317sub 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 {
… …
1322} 1339}
1323 1340
1324sub swap_out { 1341sub swap_out {
1325 my ($self) = @_; 1342 my ($self) = @_;
1326 1343
1344 # save first because save cedes
1345 $self->save;
1346
1327 return if $self->players; 1347 return if $self->players;
1328 return if $self->in_memory != cf::MAP_IN_MEMORY; 1348 return if $self->in_memory != cf::MAP_IN_MEMORY;
1329 return if $self->{deny_save}; 1349 return if $self->{deny_save};
1330 1350
1331 $self->save;
1332 $self->clear; 1351 $self->clear;
1333 $self->in_memory (cf::MAP_SWAPPED); 1352 $self->in_memory (cf::MAP_SWAPPED);
1334} 1353}
1335 1354
1336sub reset_at { 1355sub reset_at {
… …
1402 1421
1403sub customise_for { 1422sub customise_for {
1404 my ($map, $ob) = @_; 1423 my ($map, $ob) = @_;
1405 1424
1406 if ($map->per_player) { 1425 if ($map->per_player) {
1407 return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path}; 1426 return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
1408 } 1427 }
1409 1428
1410 $map 1429 $map
1411} 1430}
1412 1431
1413sub emergency_save { 1432sub emergency_save {
1414 local $cf::FREEZE = 1; 1433 my $freeze_guard = cf::freeze_mainloop;
1415 1434
1416 warn "enter emergency map save\n"; 1435 warn "enter emergency map save\n";
1417 1436
1418 cf::sync_job { 1437 cf::sync_job {
1419 warn "begin emergency map save\n"; 1438 warn "begin emergency map save\n";
… …
1509 my $link_pos = delete $self->{_link_pos}; 1528 my $link_pos = delete $self->{_link_pos};
1510 1529
1511 unless ($map) { 1530 unless ($map) {
1512 # restore original map position 1531 # restore original map position
1513 ($map, $x, $y) = @{ $link_pos || [] }; 1532 ($map, $x, $y) = @{ $link_pos || [] };
1514 $map = cf::map::find_map $map; 1533 $map = cf::map::find $map;
1515 1534
1516 unless ($map) { 1535 unless ($map) {
1517 ($map, $x, $y) = @$EMERGENCY_POSITION; 1536 ($map, $x, $y) = @$EMERGENCY_POSITION;
1518 $map = cf::map::find_map $map 1537 $map = cf::map::find $map
1519 or die "FATAL: cannot load emergency map\n"; 1538 or die "FATAL: cannot load emergency map\n";
1520 } 1539 }
1521 } 1540 }
1522 1541
1523 ($x, $y) = (-1, -1) 1542 ($x, $y) = (-1, -1)
… …
1571 $self->enter_link; 1590 $self->enter_link;
1572 1591
1573 (cf::async { 1592 (cf::async {
1574 $path = new cf::path $path; 1593 $path = new cf::path $path;
1575 1594
1576 my $map = cf::map::find_map $path->as_string; 1595 my $map = cf::map::find $path->as_string;
1577 $map = $map->customise_for ($self) if $map; 1596 $map = $map->customise_for ($self) if $map;
1578 1597
1579# warn "entering ", $map->path, " at ($x, $y)\n" 1598# warn "entering ", $map->path, " at ($x, $y)\n"
1580# if $map; 1599# if $map;
1581 1600
… …
1641 return unless $self->type == cf::PLAYER; 1660 return unless $self->type == cf::PLAYER;
1642 1661
1643 $self->enter_link; 1662 $self->enter_link;
1644 1663
1645 (cf::async { 1664 (cf::async {
1665 $self->deactivate_recursive; # just to be sure
1646 unless (eval { 1666 unless (eval {
1647 prepare_random_map $exit 1667 prepare_random_map $exit
1648 if $exit->slaying eq "/!"; 1668 if $exit->slaying eq "/!";
1649 1669
1650 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;
… …
1713 on_reply => sub { 1733 on_reply => sub {
1714 my ($ns, $msg) = @_; 1734 my ($ns, $msg) = @_;
1715 1735
1716 # this weird shuffling is so that direct followup queries 1736 # this weird shuffling is so that direct followup queries
1717 # get handled first 1737 # get handled first
1718 my $queue = delete $ns->{query_queue}; 1738 my $queue = delete $ns->{query_queue}
1739 or return; # be conservative, not sure how that can happen, but we saw a crash here
1719 1740
1720 (shift @$queue)->[1]->($msg); 1741 (shift @$queue)->[1]->($msg);
1721 1742
1722 push @{ $ns->{query_queue} }, @$queue; 1743 push @{ $ns->{query_queue} }, @$queue;
1723 1744
… …
1985 open my $fh, "<:utf8", cf::confdir . "/config" 2006 open my $fh, "<:utf8", cf::confdir . "/config"
1986 or return; 2007 or return;
1987 2008
1988 local $/; 2009 local $/;
1989 *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 }
1990} 2021}
1991 2022
1992sub main { 2023sub main {
1993 # we must not ever block the main coroutine 2024 # we must not ever block the main coroutine
1994 local $Coro::idle = sub { 2025 local $Coro::idle = sub {
… …
2014 return; 2045 return;
2015 } 2046 }
2016 2047
2017 warn "reloading..."; 2048 warn "reloading...";
2018 2049
2019 local $FREEZE = 1; 2050 my $guard = freeze_mainloop;
2020 cf::emergency_save; 2051 cf::emergency_save;
2021 2052
2022 eval { 2053 eval {
2023 # 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
2024 2055
… …
2160 reentrant => 0, 2191 reentrant => 0,
2161 prio => 0, 2192 prio => 0,
2162 at => $NEXT_TICK || $TICK, 2193 at => $NEXT_TICK || $TICK,
2163 data => WF_AUTOCANCEL, 2194 data => WF_AUTOCANCEL,
2164 cb => sub { 2195 cb => sub {
2165 unless ($FREEZE) {
2166 cf::server_tick; # one server iteration 2196 cf::server_tick; # one server iteration
2167 $RUNTIME += $TICK; 2197 $RUNTIME += $TICK;
2168 }
2169
2170 $NEXT_TICK += $TICK; 2198 $NEXT_TICK += $TICK;
2171 2199
2172 # 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
2173 $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4; 2201 $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
2174 2202

Diff Legend

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