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.120 by root, Tue Jan 2 11:08:36 2007 UTC vs.
Revision 1.132 by root, Thu Jan 4 01:35:56 2007 UTC

… …
8use Storable; 8use Storable;
9use Opcode; 9use Opcode;
10use Safe; 10use Safe;
11use Safe::Hole; 11use Safe::Hole;
12 12
13use Coro 3.3; 13use Coro 3.3 ();
14use Coro::Event; 14use Coro::Event;
15use Coro::Timer; 15use Coro::Timer;
16use Coro::Signal; 16use Coro::Signal;
17use Coro::Semaphore; 17use Coro::Semaphore;
18use Coro::AIO; 18use Coro::AIO;
… …
71mkdir cf::localdir . "/" . cf::uniquedir; 71mkdir cf::localdir . "/" . cf::uniquedir;
72mkdir $RANDOM_MAPS; 72mkdir $RANDOM_MAPS;
73 73
74# a special map that is always available 74# a special map that is always available
75our $LINK_MAP; 75our $LINK_MAP;
76 76our $EMERGENCY_POSITION;
77our $EMERGENCY_POSITION = $cf::CFG{emergency_position} || ["/world/world_105_115", 5, 37];
78 77
79############################################################################# 78#############################################################################
80 79
81=head2 GLOBAL VARIABLES 80=head2 GLOBAL VARIABLES
82 81
… …
245 # wake up all waiters, to be on the safe side 244 # wake up all waiters, to be on the safe side
246 $_->ready for @{ delete $LOCK{$key} }; 245 $_->ready for @{ delete $LOCK{$key} };
247 } 246 }
248} 247}
249 248
249=item cf::async { BLOCK }
250
251Like C<Coro::async>, but runs the given BLOCK in an eval and only logs the
252error instead of exiting the server in case of a problem.
253
254=cut
255
256sub async(&) {
257 my ($cb) = @_;
258
259 Coro::async {
260 eval { $cb->() };
261 warn $@ if $@;
262 }
263}
264
250=item cf::sync_job { BLOCK } 265=item cf::sync_job { BLOCK }
251 266
252The design of crossfire+ requires that the main coro ($Coro::main) is 267The design of crossfire+ requires that the main coro ($Coro::main) is
253always able to handle events or runnable, as crossfire+ is only partly 268always able to handle events or runnable, as crossfire+ is only partly
254reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable. 269reentrant. Thus "blocking" it by e.g. waiting for I/O is not acceptable.
… …
301=cut 316=cut
302 317
303sub coro(&) { 318sub coro(&) {
304 my $cb = shift; 319 my $cb = shift;
305 320
306 my $coro; $coro = async { 321 my $coro = &cf::async ($cb);
307 eval {
308 $cb->();
309 };
310 warn $@ if $@;
311 };
312 322
313 $coro->on_destroy (sub { 323 $coro->on_destroy (sub {
314 delete $EXT_CORO{$coro+0}; 324 delete $EXT_CORO{$coro+0};
315 }); 325 });
316 $EXT_CORO{$coro+0} = $coro; 326 $EXT_CORO{$coro+0} = $coro;
… …
1153# and all this just because we cannot iterate over 1163# and all this just because we cannot iterate over
1154# all maps in C++... 1164# all maps in C++...
1155sub change_all_map_light { 1165sub change_all_map_light {
1156 my ($change) = @_; 1166 my ($change) = @_;
1157 1167
1158 $_->change_map_light ($change) for values %cf::MAP; 1168 $_->change_map_light ($change)
1169 for grep $_->outdoor, values %cf::MAP;
1159} 1170}
1160 1171
1161sub try_load_header($) { 1172sub try_load_header($) {
1162 my ($path) = @_; 1173 my ($path) = @_;
1163 1174
… …
1174 $map->{load_path} = $path; 1185 $map->{load_path} = $path;
1175 1186
1176 $map 1187 $map
1177} 1188}
1178 1189
1190sub find_map;
1179sub find_map { 1191sub find_map {
1180 my ($path, $origin) = @_; 1192 my ($path, $origin) = @_;
1181 1193
1182 #warn "find_map<$path,$origin>\n";#d# 1194 #warn "find_map<$path,$origin>\n";#d#
1183 1195
… …
1191 1203
1192 # do it the slow way 1204 # do it the slow way
1193 my $map = try_load_header $path->save_path; 1205 my $map = try_load_header $path->save_path;
1194 1206
1195 if ($map) { 1207 if ($map) {
1208 $map->last_access ((delete $map->{last_access})
1209 || $cf::RUNTIME); #d#
1196 # safety 1210 # safety
1197 $map->{instantiate_time} = $cf::RUNTIME 1211 $map->{instantiate_time} = $cf::RUNTIME
1198 if $map->{instantiate_time} > $cf::RUNTIME; 1212 if $map->{instantiate_time} > $cf::RUNTIME;
1199 } else { 1213 } else {
1200 if (my $rmp = $path->random_map_params) { 1214 if (my $rmp = $path->random_map_params) {
… …
1205 1219
1206 $map or return; 1220 $map or return;
1207 1221
1208 $map->{load_original} = 1; 1222 $map->{load_original} = 1;
1209 $map->{instantiate_time} = $cf::RUNTIME; 1223 $map->{instantiate_time} = $cf::RUNTIME;
1224 $map->last_access ($cf::RUNTIME);
1210 $map->instantiate; 1225 $map->instantiate;
1211 1226
1212 # per-player maps become, after loading, normal maps 1227 # per-player maps become, after loading, normal maps
1213 $map->per_player (0) if $path->{user_rel}; 1228 $map->per_player (0) if $path->{user_rel};
1214 } 1229 }
1215 #Coro::Timer::sleep 1;#d#
1216 1230
1217 $map->path ($key); 1231 $map->path ($key);
1218 $map->{path} = $path; 1232 $map->{path} = $path;
1219 $map->{last_save} = $cf::RUNTIME; 1233 $map->{last_save} = $cf::RUNTIME;
1220 $map->last_access ($cf::RUNTIME);
1221 1234
1222 if ($map->should_reset) { 1235 if ($map->should_reset) {
1223 $map->reset; 1236 $map->reset;
1237 undef $guard;
1224 $map = find_map $path; 1238 $map = find_map $path
1239 or return;
1225 } 1240 }
1226 1241
1227 $cf::MAP{$key} = $map 1242 $cf::MAP{$key} = $map
1228 } 1243 }
1229} 1244}
… …
1297 1312
1298 $self->{load_path} = $save; 1313 $self->{load_path} = $save;
1299 1314
1300 return if $self->{deny_save}; 1315 return if $self->{deny_save};
1301 1316
1317 local $self->{last_access} = $self->last_access;#d#
1318
1302 if ($uniq) { 1319 if ($uniq) {
1303 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS); 1320 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS);
1304 $self->save_objects ($uniq, cf::IO_UNIQUES); 1321 $self->save_objects ($uniq, cf::IO_UNIQUES);
1305 } else { 1322 } else {
1306 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES); 1323 $self->save_objects ($save, cf::IO_HEADER | cf::IO_OBJECTS | cf::IO_UNIQUES);
… …
1308} 1325}
1309 1326
1310sub swap_out { 1327sub swap_out {
1311 my ($self) = @_; 1328 my ($self) = @_;
1312 1329
1330 # save first because save cedes
1331 $self->save;
1332
1313 return if $self->players; 1333 return if $self->players;
1314 return if $self->in_memory != cf::MAP_IN_MEMORY; 1334 return if $self->in_memory != cf::MAP_IN_MEMORY;
1315 return if $self->{deny_save}; 1335 return if $self->{deny_save};
1316 1336
1317 $self->save;
1318 $self->clear; 1337 $self->clear;
1319 $self->in_memory (cf::MAP_SWAPPED); 1338 $self->in_memory (cf::MAP_SWAPPED);
1320} 1339}
1321 1340
1322sub reset_at { 1341sub reset_at {
… …
1535 1554
1536 # try to abort aborted map switching on player login :) 1555 # try to abort aborted map switching on player login :)
1537 # should happen only on crashes 1556 # should happen only on crashes
1538 if ($pl->ob->{_link_pos}) { 1557 if ($pl->ob->{_link_pos}) {
1539 $pl->ob->enter_link; 1558 $pl->ob->enter_link;
1540 Coro::async { 1559 cf::async {
1541 # we need this sleep as the login has a concurrent enter_exit running 1560 # we need this sleep as the login has a concurrent enter_exit running
1542 # and this sleep increases chances of the player not ending up in scorn 1561 # and this sleep increases chances of the player not ending up in scorn
1543 Coro::Timer::sleep 1; 1562 Coro::Timer::sleep 1;
1544 $pl->ob->leave_link; 1563 $pl->ob->leave_link;
1545 }; 1564 };
… …
1554sub cf::object::player::goto_map { 1573sub cf::object::player::goto_map {
1555 my ($self, $path, $x, $y) = @_; 1574 my ($self, $path, $x, $y) = @_;
1556 1575
1557 $self->enter_link; 1576 $self->enter_link;
1558 1577
1559 (Coro::async { 1578 (cf::async {
1560 $path = new cf::path $path; 1579 $path = new cf::path $path;
1561 1580
1562 my $map = cf::map::find_map $path->as_string; 1581 my $map = cf::map::find_map $path->as_string;
1563 $map = $map->customise_for ($self) if $map; 1582 $map = $map->customise_for ($self) if $map;
1564 1583
… …
1626 1645
1627 return unless $self->type == cf::PLAYER; 1646 return unless $self->type == cf::PLAYER;
1628 1647
1629 $self->enter_link; 1648 $self->enter_link;
1630 1649
1631 (Coro::async { 1650 (cf::async {
1632 unless (eval { 1651 unless (eval {
1633
1634 prepare_random_map $exit 1652 prepare_random_map $exit
1635 if $exit->slaying eq "/!"; 1653 if $exit->slaying eq "/!";
1636 1654
1637 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path; 1655 my $path = new cf::path $exit->slaying, $exit->map && $exit->map->path;
1638 $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp); 1656 $self->goto_map ($path, $exit->stats->hp, $exit->stats->sp);
… …
1700 on_reply => sub { 1718 on_reply => sub {
1701 my ($ns, $msg) = @_; 1719 my ($ns, $msg) = @_;
1702 1720
1703 # this weird shuffling is so that direct followup queries 1721 # this weird shuffling is so that direct followup queries
1704 # get handled first 1722 # get handled first
1705 my $queue = delete $ns->{query_queue}; 1723 my $queue = delete $ns->{query_queue}
1724 or return; # be conservative, not sure how that can happen, but we saw a crash here
1706 1725
1707 (shift @$queue)->[1]->($msg); 1726 (shift @$queue)->[1]->($msg);
1708 1727
1709 push @{ $ns->{query_queue} }, @$queue; 1728 push @{ $ns->{query_queue} }, @$queue;
1710 1729
… …
1727=cut 1746=cut
1728 1747
1729sub cf::client::coro { 1748sub cf::client::coro {
1730 my ($self, $cb) = @_; 1749 my ($self, $cb) = @_;
1731 1750
1732 my $coro; $coro = async { 1751 my $coro = &cf::async ($cb);
1733 eval {
1734 $cb->();
1735 };
1736 warn $@ if $@;
1737 };
1738 1752
1739 $coro->on_destroy (sub { 1753 $coro->on_destroy (sub {
1740 delete $self->{_coro}{$coro+0}; 1754 delete $self->{_coro}{$coro+0};
1741 }); 1755 });
1742 1756
… …
1914 1928
1915{ 1929{
1916 my $path = cf::localdir . "/database.pst"; 1930 my $path = cf::localdir . "/database.pst";
1917 1931
1918 sub db_load() { 1932 sub db_load() {
1919 warn "loading database $path\n";#d# remove later
1920 $DB = stat $path ? Storable::retrieve $path : { }; 1933 $DB = stat $path ? Storable::retrieve $path : { };
1921 } 1934 }
1922 1935
1923 my $pid; 1936 my $pid;
1924 1937
1925 sub db_save() { 1938 sub db_save() {
1926 warn "saving database $path\n";#d# remove later
1927 waitpid $pid, 0 if $pid; 1939 waitpid $pid, 0 if $pid;
1928 if (0 == ($pid = fork)) { 1940 if (0 == ($pid = fork)) {
1929 $DB->{_meta}{version} = 1; 1941 $DB->{_meta}{version} = 1;
1930 Storable::nstore $DB, "$path~"; 1942 Storable::nstore $DB, "$path~";
1931 rename "$path~", $path; 1943 rename "$path~", $path;
… …
1979 open my $fh, "<:utf8", cf::confdir . "/config" 1991 open my $fh, "<:utf8", cf::confdir . "/config"
1980 or return; 1992 or return;
1981 1993
1982 local $/; 1994 local $/;
1983 *CFG = YAML::Syck::Load <$fh>; 1995 *CFG = YAML::Syck::Load <$fh>;
1996
1997 $EMERGENCY_POSITION = $CFG{emergency_position} || ["/world/world_105_115", 5, 37];
1998
1999 if (exists $CFG{mlockall}) {
2000 eval {
2001 $CFG{mlockall} ? &mlockall : &munlockall
2002 and die "WARNING: m(un)lockall failed: $!\n";
2003 };
2004 warn $@ if $@;
2005 }
1984} 2006}
1985 2007
1986sub main { 2008sub main {
1987 # we must not ever block the main coroutine 2009 # we must not ever block the main coroutine
1988 local $Coro::idle = sub { 2010 local $Coro::idle = sub {
… …
2191 or warn "ERROR: unable to write runtime file: $!"; 2213 or warn "ERROR: unable to write runtime file: $!";
2192 })->(); 2214 })->();
2193 }, 2215 },
2194); 2216);
2195 2217
2218END { cf::emergency_save }
2219
21961 22201
2197 2221

Diff Legend

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