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.130 by root, Thu Jan 4 00:08:08 2007 UTC vs.
Revision 1.133 by root, Thu Jan 4 16:19:32 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";
… …
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
1289sub load_map_sync { 1297sub 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 { 1303sub 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
1302sub save { 1309sub 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 {
… …
1404 1413
1405sub customise_for { 1414sub customise_for {
1406 my ($map, $ob) = @_; 1415 my ($map, $ob) = @_;
1407 1416
1408 if ($map->per_player) { 1417 if ($map->per_player) {
1409 return cf::map::find_map "~" . $ob->name . "/" . $map->{path}{path}; 1418 return cf::map::find "~" . $ob->name . "/" . $map->{path}{path};
1410 } 1419 }
1411 1420
1412 $map 1421 $map
1413} 1422}
1414 1423
1415sub emergency_save { 1424sub emergency_save {
1416 local $cf::FREEZE = 1; 1425 my $freeze_guard = cf::freeze_mainloop;
1417 1426
1418 warn "enter emergency map save\n"; 1427 warn "enter emergency map save\n";
1419 1428
1420 cf::sync_job { 1429 cf::sync_job {
1421 warn "begin emergency map save\n"; 1430 warn "begin emergency map save\n";
… …
1511 my $link_pos = delete $self->{_link_pos}; 1520 my $link_pos = delete $self->{_link_pos};
1512 1521
1513 unless ($map) { 1522 unless ($map) {
1514 # restore original map position 1523 # restore original map position
1515 ($map, $x, $y) = @{ $link_pos || [] }; 1524 ($map, $x, $y) = @{ $link_pos || [] };
1516 $map = cf::map::find_map $map; 1525 $map = cf::map::find $map;
1517 1526
1518 unless ($map) { 1527 unless ($map) {
1519 ($map, $x, $y) = @$EMERGENCY_POSITION; 1528 ($map, $x, $y) = @$EMERGENCY_POSITION;
1520 $map = cf::map::find_map $map 1529 $map = cf::map::find $map
1521 or die "FATAL: cannot load emergency map\n"; 1530 or die "FATAL: cannot load emergency map\n";
1522 } 1531 }
1523 } 1532 }
1524 1533
1525 ($x, $y) = (-1, -1) 1534 ($x, $y) = (-1, -1)
… …
1573 $self->enter_link; 1582 $self->enter_link;
1574 1583
1575 (cf::async { 1584 (cf::async {
1576 $path = new cf::path $path; 1585 $path = new cf::path $path;
1577 1586
1578 my $map = cf::map::find_map $path->as_string; 1587 my $map = cf::map::find $path->as_string;
1579 $map = $map->customise_for ($self) if $map; 1588 $map = $map->customise_for ($self) if $map;
1580 1589
1581# warn "entering ", $map->path, " at ($x, $y)\n" 1590# warn "entering ", $map->path, " at ($x, $y)\n"
1582# if $map; 1591# if $map;
1583 1592
… …
1643 return unless $self->type == cf::PLAYER; 1652 return unless $self->type == cf::PLAYER;
1644 1653
1645 $self->enter_link; 1654 $self->enter_link;
1646 1655
1647 (cf::async { 1656 (cf::async {
1657 $self->deactivate_recursive; # just to be sure
1648 unless (eval { 1658 unless (eval {
1649 prepare_random_map $exit 1659 prepare_random_map $exit
1650 if $exit->slaying eq "/!"; 1660 if $exit->slaying eq "/!";
1651 1661
1652 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;
… …
1988 open my $fh, "<:utf8", cf::confdir . "/config" 1998 open my $fh, "<:utf8", cf::confdir . "/config"
1989 or return; 1999 or return;
1990 2000
1991 local $/; 2001 local $/;
1992 *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 }
1993} 2013}
1994 2014
1995sub main { 2015sub main {
1996 # we must not ever block the main coroutine 2016 # we must not ever block the main coroutine
1997 local $Coro::idle = sub { 2017 local $Coro::idle = sub {
… …
2017 return; 2037 return;
2018 } 2038 }
2019 2039
2020 warn "reloading..."; 2040 warn "reloading...";
2021 2041
2022 local $FREEZE = 1; 2042 my $guard = freeze_mainloop;
2023 cf::emergency_save; 2043 cf::emergency_save;
2024 2044
2025 eval { 2045 eval {
2026 # 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
2027 2047
… …
2163 reentrant => 0, 2183 reentrant => 0,
2164 prio => 0, 2184 prio => 0,
2165 at => $NEXT_TICK || $TICK, 2185 at => $NEXT_TICK || $TICK,
2166 data => WF_AUTOCANCEL, 2186 data => WF_AUTOCANCEL,
2167 cb => sub { 2187 cb => sub {
2168 unless ($FREEZE) {
2169 cf::server_tick; # one server iteration 2188 cf::server_tick; # one server iteration
2170 $RUNTIME += $TICK; 2189 $RUNTIME += $TICK;
2171 }
2172
2173 $NEXT_TICK += $TICK; 2190 $NEXT_TICK += $TICK;
2174 2191
2175 # 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
2176 $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4; 2193 $NEXT_TICK = Event::time if Event::time >= $NEXT_TICK + $TICK * 4;
2177 2194

Diff Legend

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