1#![deny(unsafe_code)]
2#![expect(
3 clippy::option_map_unit_fn,
4 clippy::needless_pass_by_ref_mut )]
6#![deny(clippy::clone_on_ref_ptr)]
7#![feature(box_patterns, let_chains, option_zip, const_type_name)]
8
9pub mod automod;
10mod character_creator;
11pub mod chat;
12pub mod chunk_generator;
13mod chunk_serialize;
14pub mod client;
15pub mod cmd;
16pub mod connection_handler;
17mod data_dir;
18pub mod error;
19pub mod events;
20pub mod input;
21pub mod location;
22pub mod lod;
23pub mod login_provider;
24pub mod metrics;
25pub mod persistence;
26mod pet;
27pub mod presence;
28pub mod rtsim;
29pub mod settings;
30pub mod state_ext;
31pub mod sys;
32#[cfg(feature = "persistent_world")]
33pub mod terrain_persistence;
34#[cfg(not(feature = "worldgen"))] mod test_world;
35
36#[cfg(feature = "worldgen")] mod weather;
37
38pub mod wiring;
39
40pub use crate::{
42 data_dir::DEFAULT_DATA_DIR_NAME,
43 error::Error,
44 events::Event,
45 input::Input,
46 settings::{CalendarMode, EditableSettings, Settings},
47};
48
49#[cfg(feature = "persistent_world")]
50use crate::terrain_persistence::TerrainPersistence;
51use crate::{
52 automod::AutoMod,
53 chunk_generator::ChunkGenerator,
54 client::Client,
55 cmd::ChatCommandExt,
56 connection_handler::ConnectionHandler,
57 data_dir::DataDir,
58 location::Locations,
59 login_provider::LoginProvider,
60 persistence::PersistedComponents,
61 presence::{RegionSubscription, RepositionOnChunkLoad},
62 state_ext::StateExt,
63 sys::sentinel::DeletedEntities,
64};
65use censor::Censor;
66#[cfg(not(feature = "worldgen"))]
67use common::grid::Grid;
68#[cfg(feature = "worldgen")]
69use common::terrain::TerrainChunkSize;
70use common::{
71 assets::AssetExt,
72 calendar::Calendar,
73 character::{CharacterId, CharacterItem},
74 cmd::ServerChatCommand,
75 comp,
76 event::{
77 ClientDisconnectEvent, ClientDisconnectWithoutPersistenceEvent, EventBus, ExitIngameEvent,
78 UpdateCharacterDataEvent,
79 },
80 link::Is,
81 mounting::{Volume, VolumeRider},
82 region::RegionMap,
83 resources::{BattleMode, GameMode, Time, TimeOfDay},
84 rtsim::RtSimEntity,
85 shared_server_config::ServerConstants,
86 slowjob::SlowJobPool,
87 terrain::TerrainChunk,
88 util::GIT_DATE_TIMESTAMP,
89 vol::RectRasterableVol,
90};
91use common_base::prof_span;
92use common_ecs::run_now;
93use common_net::{
94 msg::{ClientType, DisconnectReason, ServerGeneral, ServerInfo, ServerMsg},
95 sync::WorldSyncExt,
96};
97use common_state::{AreasContainer, BlockDiff, BuildArea, State};
98use common_systems::add_local_systems;
99use metrics::{EcsSystemMetrics, PhysicsMetrics, TickMetrics};
100use network::{ListenAddr, Network, Pid};
101use persistence::{
102 character_loader::{CharacterLoader, CharacterUpdaterMessage},
103 character_updater::CharacterUpdater,
104};
105use prometheus::Registry;
106use rustls::pki_types::{CertificateDer, PrivateKeyDer};
107use specs::{
108 Builder, Entity as EcsEntity, Entity, Join, LendJoin, WorldExt, shred::SendDispatcher,
109};
110use std::{
111 ops::{Deref, DerefMut},
112 sync::{Arc, Mutex},
113 time::{Duration, Instant},
114};
115#[cfg(not(feature = "worldgen"))]
116use test_world::{IndexOwned, World};
117use tokio::runtime::Runtime;
118use tracing::{debug, error, info, trace, warn};
119use vek::*;
120use veloren_query_server::server::QueryServer;
121pub use world::{WorldGenerateStage, civ::WorldCivStage, sim::WorldSimStage};
122
123use crate::{
124 persistence::{DatabaseSettings, SqlLogMode},
125 sys::terrain,
126};
127use hashbrown::HashMap;
128use std::sync::RwLock;
129
130use crate::settings::Protocol;
131
132#[cfg(feature = "plugins")]
133use {
134 common::uid::IdMaps,
135 common_state::plugin::{PluginMgr, memory_manager::EcsWorld},
136};
137
138use crate::{chat::ChatCache, persistence::character_loader::CharacterScreenResponseKind};
139use common::comp::Anchor;
140#[cfg(feature = "worldgen")]
141pub use world::{
142 IndexOwned, World,
143 sim::{DEFAULT_WORLD_MAP, DEFAULT_WORLD_SEED, FileOpts, GenOpts, WorldOpts},
144};
145
146#[derive(Copy, Clone)]
150pub struct SpawnPoint(pub Vec3<f32>);
151
152impl Default for SpawnPoint {
153 fn default() -> Self { Self(Vec3::new(0.0, 0.0, 256.0)) }
154}
155
156pub const MIN_VD: u32 = 6;
161
162#[derive(Copy, Clone, Default)]
165pub struct Tick(u64);
166
167#[derive(Clone)]
168pub struct HwStats {
169 hardware_threads: u32,
170 rayon_threads: u32,
171}
172
173#[derive(Clone, Copy, PartialEq)]
174enum DisconnectType {
175 WithPersistence,
176 WithoutPersistence,
177}
178
179#[derive(Copy, Clone)]
181pub struct TickStart(Instant);
182
183#[derive(Clone, Default, Debug)]
185pub struct BattleModeBuffer {
186 map: HashMap<CharacterId, (BattleMode, Time)>,
187}
188
189impl BattleModeBuffer {
190 pub fn push(&mut self, char_id: CharacterId, save: (BattleMode, Time)) {
191 self.map.insert(char_id, save);
192 }
193
194 pub fn get(&self, char_id: &CharacterId) -> Option<&(BattleMode, Time)> {
195 self.map.get(char_id)
196 }
197
198 pub fn pop(&mut self, char_id: &CharacterId) -> Option<(BattleMode, Time)> {
199 self.map.remove(char_id)
200 }
201}
202
203pub struct ChunkRequest {
204 entity: EcsEntity,
205 key: Vec2<i32>,
206}
207
208#[derive(Debug)]
209pub enum ServerInitStage {
210 DbMigrations,
211 DbVacuum,
212 WorldGen(WorldGenerateStage),
213 StartingSystems,
214}
215
216pub struct Server {
217 state: State,
218 world: Arc<World>,
219 index: IndexOwned,
220
221 connection_handler: ConnectionHandler,
222
223 runtime: Arc<Runtime>,
224
225 metrics_registry: Arc<Registry>,
226 chat_cache: ChatCache,
227 database_settings: Arc<RwLock<DatabaseSettings>>,
228 disconnect_all_clients_requested: bool,
229
230 event_dispatcher: SendDispatcher<'static>,
231}
232
233impl Server {
234 pub fn new(
236 settings: Settings,
237 editable_settings: EditableSettings,
238 database_settings: DatabaseSettings,
239 data_dir: &std::path::Path,
240 report_stage: &(dyn Fn(ServerInitStage) + Send + Sync),
241 runtime: Arc<Runtime>,
242 ) -> Result<Self, Error> {
243 prof_span!("Server::new");
244 info!("Server data dir is: {}", data_dir.display());
245 if settings.auth_server_address.is_none() {
246 info!("Authentication is disabled");
247 }
248
249 report_stage(ServerInitStage::DbMigrations);
250 debug!("Running DB migrations...");
252 persistence::run_migrations(&database_settings);
253
254 report_stage(ServerInitStage::DbVacuum);
255 debug!("Vacuuming database...");
257 persistence::vacuum_database(&database_settings);
258
259 let database_settings = Arc::new(RwLock::new(database_settings));
260
261 let registry = Arc::new(Registry::new());
262 let chunk_gen_metrics = metrics::ChunkGenMetrics::new(®istry).unwrap();
263 let job_metrics = metrics::JobMetrics::new(®istry).unwrap();
264 let network_request_metrics = metrics::NetworkRequestMetrics::new(®istry).unwrap();
265 let player_metrics = metrics::PlayerMetrics::new(®istry).unwrap();
266 let ecs_system_metrics = EcsSystemMetrics::new(®istry).unwrap();
267 let tick_metrics = TickMetrics::new(®istry).unwrap();
268 let physics_metrics = PhysicsMetrics::new(®istry).unwrap();
269 let server_event_metrics = metrics::ServerEventMetrics::new(®istry).unwrap();
270 let query_server_metrics = metrics::QueryServerMetrics::new(®istry).unwrap();
271
272 let battlemode_buffer = BattleModeBuffer::default();
273
274 let pools = State::pools(GameMode::Server);
275
276 #[cfg(feature = "plugins")]
278 let plugin_mgr = PluginMgr::from_asset_or_default();
279
280 debug!("Generating world, seed: {}", settings.world_seed);
281 #[cfg(feature = "worldgen")]
282 let (world, index) = World::generate(
283 settings.world_seed,
284 WorldOpts {
285 seed_elements: true,
286 world_file: if let Some(ref opts) = settings.map_file {
287 opts.clone()
288 } else {
289 FileOpts::LoadAsset(DEFAULT_WORLD_MAP.into())
291 },
292 calendar: Some(settings.calendar_mode.calendar_now()),
293 },
294 &pools,
295 &|stage| {
296 report_stage(ServerInitStage::WorldGen(stage));
297 },
298 );
299 #[cfg(not(feature = "worldgen"))]
300 let (world, index) = World::generate(settings.world_seed);
301
302 #[cfg(feature = "worldgen")]
303 let map = world.get_map_data(index.as_index_ref(), &pools);
304 #[cfg(not(feature = "worldgen"))]
305 let map = common_net::msg::WorldMapMsg {
306 dimensions_lg: Vec2::zero(),
307 max_height: 1.0,
308 rgba: Grid::new(Vec2::new(1, 1), 1),
309 horizons: [(vec![0], vec![0]), (vec![0], vec![0])],
310 alt: Grid::new(Vec2::new(1, 1), 1),
311 sites: Vec::new(),
312 possible_starting_sites: Vec::new(),
313 pois: Vec::new(),
314 default_chunk: Arc::new(world.generate_oob_chunk()),
315 };
316
317 #[cfg(feature = "worldgen")]
318 let map_size_lg = world.sim().map_size_lg();
319 #[cfg(not(feature = "worldgen"))]
320 let map_size_lg = world.map_size_lg();
321
322 let lod = lod::Lod::from_world(&world, index.as_index_ref(), &pools);
323
324 report_stage(ServerInitStage::StartingSystems);
325
326 let mut state = State::server(
327 Arc::clone(&pools),
328 map_size_lg,
329 Arc::clone(&map.default_chunk),
330 |dispatcher_builder| {
331 add_local_systems(dispatcher_builder);
332 sys::msg::add_server_systems(dispatcher_builder);
333 sys::add_server_systems(dispatcher_builder);
334 #[cfg(feature = "worldgen")]
335 {
336 rtsim::add_server_systems(dispatcher_builder);
337 weather::add_server_systems(dispatcher_builder);
338 }
339 },
340 #[cfg(feature = "plugins")]
341 plugin_mgr,
342 );
343 events::register_event_busses(state.ecs_mut());
344 state.ecs_mut().insert(battlemode_buffer);
345 state.ecs_mut().insert(settings.clone());
346 state.ecs_mut().insert(editable_settings);
347 state.ecs_mut().insert(DataDir {
348 path: data_dir.to_owned(),
349 });
350
351 state.ecs_mut().insert(Vec::<ChunkRequest>::new());
352 state
353 .ecs_mut()
354 .insert(EventBus::<chunk_serialize::ChunkSendEntry>::default());
355 state.ecs_mut().insert(Locations::default());
356 state.ecs_mut().insert(LoginProvider::new(
357 settings.auth_server_address.clone(),
358 Arc::clone(&runtime),
359 ));
360 state.ecs_mut().insert(HwStats {
361 hardware_threads: num_cpus::get() as u32,
362 rayon_threads: num_cpus::get() as u32,
363 });
364 state.ecs_mut().insert(ServerConstants {
365 day_cycle_coefficient: settings.day_cycle_coefficient(),
366 });
367 state.ecs_mut().insert(Tick(0));
368 state.ecs_mut().insert(TickStart(Instant::now()));
369 state.ecs_mut().insert(job_metrics);
370 state.ecs_mut().insert(network_request_metrics);
371 state.ecs_mut().insert(player_metrics);
372 state.ecs_mut().insert(ecs_system_metrics);
373 state.ecs_mut().insert(tick_metrics);
374 state.ecs_mut().insert(physics_metrics);
375 state.ecs_mut().insert(server_event_metrics);
376 state.ecs_mut().insert(query_server_metrics);
377 if settings.experimental_terrain_persistence {
378 #[cfg(feature = "persistent_world")]
379 {
380 warn!(
381 "Experimental terrain persistence support is enabled. This feature may break, \
382 be disabled, or otherwise change under your feet at *any time*. \
383 Additionally, it is expected to be replaced in the future *without* \
384 migration or warning. You have been warned."
385 );
386 state
387 .ecs_mut()
388 .insert(TerrainPersistence::new(data_dir.to_owned()));
389 }
390 #[cfg(not(feature = "persistent_world"))]
391 error!(
392 "Experimental terrain persistence support was requested, but the server was not \
393 compiled with the feature. Terrain modifications will *not* be persisted."
394 );
395 }
396 {
397 let pool = state.ecs_mut().write_resource::<SlowJobPool>();
398 pool.configure("CHUNK_DROP", |_n| 1);
399 pool.configure("CHUNK_GENERATOR", |n| n / 2 + n / 4);
400 pool.configure("CHUNK_SERIALIZER", |n| n / 2);
401 pool.configure("RTSIM_SAVE", |_| 1);
402 pool.configure("WEATHER", |_| 1);
403 }
404 state
405 .ecs_mut()
406 .insert(ChunkGenerator::new(chunk_gen_metrics));
407 {
408 let (sender, receiver) =
409 crossbeam_channel::bounded::<chunk_serialize::SerializedChunk>(10_000);
410 state.ecs_mut().insert(sender);
411 state.ecs_mut().insert(receiver);
412 }
413
414 state.ecs_mut().insert(CharacterUpdater::new(
415 Arc::<RwLock<DatabaseSettings>>::clone(&database_settings),
416 )?);
417
418 let ability_map = comp::item::tool::AbilityMap::<comp::AbilityItem>::load_expect_cloned(
419 "common.abilities.ability_set_manifest",
420 );
421 state.ecs_mut().insert(ability_map);
422
423 let msm = comp::inventory::item::MaterialStatManifest::load().cloned();
424 state.ecs_mut().insert(msm);
425
426 let rbm = common::recipe::RecipeBookManifest::load().cloned();
427 state.ecs_mut().insert(rbm);
428
429 state.ecs_mut().insert(CharacterLoader::new(
430 Arc::<RwLock<DatabaseSettings>>::clone(&database_settings),
431 )?);
432
433 state
435 .ecs_mut()
436 .insert(sys::PersistenceScheduler::every(Duration::from_secs(10)));
437
438 state.ecs_mut().insert(RegionMap::new());
440
441 state.ecs_mut().register::<RegionSubscription>();
443 state.ecs_mut().register::<Client>();
444 state.ecs_mut().register::<comp::Presence>();
445 state.ecs_mut().register::<wiring::WiringElement>();
446 state.ecs_mut().register::<wiring::Circuit>();
447 state.ecs_mut().register::<Anchor>();
448 state.ecs_mut().register::<comp::Pet>();
449 state.ecs_mut().register::<login_provider::PendingLogin>();
450 state.ecs_mut().register::<RepositionOnChunkLoad>();
451 state.ecs_mut().register::<RtSimEntity>();
452
453 let banned_words = settings.moderation.load_banned_words(data_dir);
455 let censor = Arc::new(Censor::Custom(banned_words.into_iter().collect()));
456 state.ecs_mut().insert(Arc::clone(&censor));
457
458 state
460 .ecs_mut()
461 .insert(AutoMod::new(&settings.moderation, censor));
462
463 state.ecs_mut().insert(map);
464
465 #[cfg(feature = "worldgen")]
466 let spawn_point = SpawnPoint({
467 use world::civ::SiteKind;
468
469 let index = index.as_index_ref();
470 let center_chunk = world.sim().map_size_lg().chunks().map(i32::from) / 2;
477 let spawn_chunk = world
478 .civs()
479 .sites()
480 .filter(|site| matches!(site.kind, SiteKind::Settlement | SiteKind::Refactor))
481 .map(|site| site.center)
482 .min_by_key(|site_pos| site_pos.distance_squared(center_chunk))
483 .unwrap_or(center_chunk);
484
485 world.find_accessible_pos(index, TerrainChunkSize::center_wpos(spawn_chunk), false)
486 });
487 #[cfg(not(feature = "worldgen"))]
488 let spawn_point = SpawnPoint::default();
489
490 state.ecs_mut().insert(spawn_point);
492
493 {
496 #[cfg(feature = "worldgen")]
497 let size = world.sim().get_size();
498 #[cfg(not(feature = "worldgen"))]
499 let size = world.map_size_lg().chunks().map(u32::from);
500
501 let world_size = size.map(|e| e as i32) * TerrainChunk::RECT_SIZE.map(|e| e as i32);
502 let world_aabb = Aabb {
503 min: Vec3::new(0, 0, -32768),
504 max: Vec3::new(world_size.x, world_size.y, 32767),
505 }
506 .made_valid();
507
508 state
509 .ecs()
510 .write_resource::<AreasContainer<BuildArea>>()
511 .insert("world".to_string(), world_aabb)
512 .expect("The initial insert should always work.");
513 }
514
515 let world = Arc::new(world);
517 state.ecs_mut().insert(Arc::clone(&world));
518 state.ecs_mut().insert(lod);
519 state.ecs_mut().insert(index.clone());
520
521 state.ecs_mut().write_resource::<TimeOfDay>().0 = settings.world.start_time;
523
524 sys::sentinel::UpdateTrackers::register(state.ecs_mut());
526
527 state.ecs_mut().insert(DeletedEntities::default());
528
529 let network = Network::new_with_registry(Pid::new(), &runtime, ®istry);
530 let (chat_cache, chat_tracker) = ChatCache::new(Duration::from_secs(60), &runtime);
531 state.ecs_mut().insert(chat_tracker);
532
533 let mut printed_quic_warning = false;
534 for protocol in &settings.gameserver_protocols {
535 match protocol {
536 Protocol::Tcp { address } => {
537 runtime.block_on(network.listen(ListenAddr::Tcp(*address)))?;
538 },
539 Protocol::Quic {
540 address,
541 cert_file_path,
542 key_file_path,
543 } => {
544 use rustls_pemfile::Item;
545 use std::fs;
546
547 match || -> Result<_, Box<dyn std::error::Error>> {
548 let key = fs::read(key_file_path)?;
549 let key = if key_file_path.extension().is_some_and(|x| x == "der") {
550 PrivateKeyDer::try_from(key).map_err(|_| "No valid pem key in file")?
551 } else {
552 debug!("convert pem key to der");
553 rustls_pemfile::read_all(&mut key.as_slice())
554 .find_map(|item| match item {
555 Ok(Item::Pkcs1Key(v)) => Some(PrivateKeyDer::Pkcs1(v)),
556 Ok(Item::Pkcs8Key(v)) => Some(PrivateKeyDer::Pkcs8(v)),
557 Ok(Item::Sec1Key(v)) => Some(PrivateKeyDer::Sec1(v)),
558 Ok(Item::Crl(_)) => None,
559 Ok(Item::Csr(_)) => None,
560 Ok(Item::X509Certificate(_)) => None,
561 Ok(_) => None,
562 Err(e) => {
563 tracing::warn!(?e, "error while reading key_file");
564 None
565 },
566 })
567 .ok_or("No valid pem key in file")?
568 };
569 let cert_chain = fs::read(cert_file_path)?;
570 let cert_chain = if cert_file_path.extension().is_some_and(|x| x == "der") {
571 vec![CertificateDer::from(cert_chain)]
572 } else {
573 debug!("convert pem cert to der");
574 rustls_pemfile::certs(&mut cert_chain.as_slice())
575 .filter_map(|item| match item {
576 Ok(cert) => Some(cert),
577 Err(e) => {
578 tracing::warn!(?e, "error while reading cert_file");
579 None
580 },
581 })
582 .collect()
583 };
584 let server_config = quinn::ServerConfig::with_single_cert(cert_chain, key)?;
585 Ok(server_config)
586 }() {
587 Ok(server_config) => {
588 runtime.block_on(
589 network.listen(ListenAddr::Quic(*address, server_config.clone())),
590 )?;
591
592 if !printed_quic_warning {
593 warn!(
594 "QUIC is enabled. This is experimental and not recommended in \
595 production"
596 );
597 printed_quic_warning = true;
598 }
599 },
600 Err(e) => {
601 error!(
602 ?e,
603 "Failed to load the TLS certificate, running without QUIC {}",
604 *address
605 );
606 },
607 }
608 },
609 }
610 }
611
612 if let Some(addr) = settings.query_address {
613 use veloren_query_server::proto::ServerInfo;
614
615 const QUERY_SERVER_RATELIMIT: u16 = 120;
616
617 let (query_server_info_tx, query_server_info_rx) =
618 tokio::sync::watch::channel(ServerInfo {
619 git_hash: *sys::server_info::GIT_HASH,
620 git_timestamp: *GIT_DATE_TIMESTAMP,
621 players_count: 0,
622 player_cap: settings.max_players,
623 battlemode: settings.gameplay.battle_mode.into(),
624 });
625 let mut query_server =
626 QueryServer::new(addr, query_server_info_rx, QUERY_SERVER_RATELIMIT);
627 let query_server_metrics =
628 Arc::new(Mutex::new(veloren_query_server::server::Metrics::default()));
629 let query_server_metrics2 = Arc::clone(&query_server_metrics);
630 runtime.spawn(async move {
631 let err = query_server.run(query_server_metrics2).await.err();
632 error!(?err, "Query server stopped unexpectedly");
633 });
634 state.ecs_mut().insert(query_server_info_tx);
635 state.ecs_mut().insert(query_server_metrics);
636 }
637
638 runtime.block_on(network.listen(ListenAddr::Mpsc(14004)))?;
639
640 let connection_handler = ConnectionHandler::new(network, &runtime);
641
642 #[cfg(feature = "worldgen")]
644 {
645 match rtsim::RtSim::new(
646 &settings.world,
647 index.as_index_ref(),
648 &world,
649 data_dir.to_owned(),
650 ) {
651 Ok(rtsim) => {
652 state.ecs_mut().insert(rtsim.state().data().time_of_day);
653 state.ecs_mut().insert(rtsim);
654 },
655 Err(err) => {
656 error!("Failed to load rtsim: {}", err);
657 return Err(Error::RtsimError(err));
658 },
659 }
660 weather::init(&mut state);
661 }
662
663 let this = Self {
664 state,
665 world,
666 index,
667 connection_handler,
668 runtime,
669
670 metrics_registry: registry,
671 chat_cache,
672 database_settings,
673 disconnect_all_clients_requested: false,
674
675 event_dispatcher: Self::create_event_dispatcher(pools),
676 };
677
678 debug!(?settings, "created veloren server with");
679
680 let git_hash = *common::util::GIT_HASH;
681 let git_date = common::util::GIT_DATE.clone();
682 let git_time = *common::util::GIT_TIME;
683 let version = common::util::DISPLAY_VERSION_LONG.clone();
684 info!(?version, "Server version");
685 debug!(?git_hash, ?git_date, ?git_time, "detailed Server version");
686
687 Ok(this)
688 }
689
690 pub fn get_server_info(&self) -> ServerInfo {
691 let settings = self.state.ecs().fetch::<Settings>();
692
693 ServerInfo {
694 name: settings.server_name.clone(),
695 git_hash: common::util::GIT_HASH.to_string(),
696 git_date: common::util::GIT_DATE.to_string(),
697 auth_provider: settings.auth_server_address.clone(),
698 }
699 }
700
701 pub fn settings(&self) -> impl Deref<Target = Settings> + '_ {
703 self.state.ecs().fetch::<Settings>()
704 }
705
706 pub fn settings_mut(&self) -> impl DerefMut<Target = Settings> + '_ {
708 self.state.ecs().fetch_mut::<Settings>()
709 }
710
711 pub fn editable_settings_mut(&self) -> impl DerefMut<Target = EditableSettings> + '_ {
713 self.state.ecs().fetch_mut::<EditableSettings>()
714 }
715
716 pub fn editable_settings(&self) -> impl Deref<Target = EditableSettings> + '_ {
718 self.state.ecs().fetch::<EditableSettings>()
719 }
720
721 pub fn data_dir(&self) -> impl Deref<Target = DataDir> + '_ {
723 self.state.ecs().fetch::<DataDir>()
724 }
725
726 pub fn state(&self) -> &State { &self.state }
728
729 pub fn state_mut(&mut self) -> &mut State { &mut self.state }
731
732 pub fn world(&self) -> &World { &self.world }
734
735 pub fn metrics_registry(&self) -> &Arc<Registry> { &self.metrics_registry }
737
738 pub fn chat_cache(&self) -> &ChatCache { &self.chat_cache }
740
741 fn parse_locations(&self, character_list_data: &mut [CharacterItem]) {
742 character_list_data.iter_mut().for_each(|c| {
743 let name = c
744 .location
745 .as_ref()
746 .and_then(|s| {
747 persistence::parse_waypoint(s)
748 .ok()
749 .and_then(|(waypoint, _)| waypoint.map(|w| w.get_pos()))
750 })
751 .and_then(|wpos| {
752 self.world
753 .get_location_name(self.index.as_index_ref(), wpos.xy().as_::<i32>())
754 });
755 c.location = name;
756 });
757 }
758
759 pub fn tick(&mut self, _input: Input, dt: Duration) -> Result<Vec<Event>, Error> {
762 self.state.ecs().write_resource::<Tick>().0 += 1;
763 self.state.ecs().write_resource::<TickStart>().0 = Instant::now();
764
765 let new_calendar = self
769 .state
770 .ecs()
771 .read_resource::<Settings>()
772 .calendar_mode
773 .calendar_now();
774 *self.state.ecs_mut().write_resource::<Calendar>() = new_calendar;
775
776 let mut frontend_events = Vec::new();
799
800 let before_new_connections = Instant::now();
803
804 self.handle_new_connections(&mut frontend_events);
806
807 let before_state_tick = Instant::now();
808
809 fn on_block_update(ecs: &specs::World, changes: Vec<BlockDiff>) {
810 if changes
812 .iter()
813 .any(|c| c.old.get_rtsim_resource() != c.new.get_rtsim_resource())
814 {
815 ecs.write_resource::<rtsim::RtSim>().hook_block_update(
816 &ecs.read_resource::<Arc<world::World>>(),
817 ecs.read_resource::<world::IndexOwned>().as_index_ref(),
818 changes,
819 );
820 }
821 }
822
823 let mut state_tick_metrics = Default::default();
827 let server_constants = (*self.state.ecs().read_resource::<ServerConstants>()).clone();
828 self.state.tick(
829 dt,
830 false,
831 Some(&mut state_tick_metrics),
832 &server_constants,
833 on_block_update,
834 );
835
836 let before_handle_events = Instant::now();
837
838 let disconnect_type = self.disconnect_all_clients_if_requested();
841
842 self.state.maintain_links();
844
845 frontend_events.append(&mut self.handle_events());
847
848 let before_update_terrain_and_regions = Instant::now();
849
850 self.update_region_map();
855 self.state.apply_terrain_changes(on_block_update);
858
859 let before_sync = Instant::now();
860
861 sys::run_sync_systems(self.state.ecs_mut());
863
864 let before_world_tick = Instant::now();
865
866 self.world.tick(dt);
868
869 let before_entity_cleanup = Instant::now();
870
871 if let Some(DisconnectType::WithoutPersistence) = disconnect_type {
876 run_now::<terrain::Sys>(self.state.ecs_mut());
877 }
878
879 #[cfg(feature = "worldgen")]
881 {
882 let mut rtsim = self.state.ecs().write_resource::<rtsim::RtSim>();
883 for chunk in &self.state.terrain_changes().removed_chunks {
884 rtsim.hook_unload_chunk(*chunk);
885 }
886 }
887
888 let anchors = self.state.ecs().read_storage::<Anchor>();
899 let anchored_anchor_entities: Vec<Entity> = (
900 &self.state.ecs().entities(),
901 &self.state.ecs().read_storage::<Anchor>(),
902 )
903 .join()
904 .filter_map(|(_, anchor)| match anchor {
905 Anchor::Entity(anchor_entity) => Some(*anchor_entity),
906 _ => None,
907 })
908 .filter(|anchor_entity| match anchors.get(*anchor_entity) {
912 Some(Anchor::Entity(_)) => true,
913 Some(Anchor::Chunk(_)) | None => false
914 })
915 .collect();
916 drop(anchors);
917
918 for entity in anchored_anchor_entities {
919 if cfg!(debug_assertions) {
920 panic!("Entity anchor chain detected");
921 }
922 error!(
923 "Detected an anchor entity that itself has an anchor entity - anchor chains are \
924 not currently supported. The entity's Anchor component has been deleted"
925 );
926 self.state.delete_component::<Anchor>(entity);
927 }
928
929 let to_delete = {
932 let terrain = self.state.terrain();
933 (
934 &self.state.ecs().entities(),
935 &self.state.ecs().read_storage::<comp::Pos>(),
936 !&self.state.ecs().read_storage::<comp::Presence>(),
937 self.state.ecs().read_storage::<Anchor>().maybe(),
938 self.state.ecs().read_storage::<Is<VolumeRider>>().maybe(),
939 )
940 .join()
941 .filter(|(_, pos, _, anchor, is_volume_rider)| {
942 let pos = is_volume_rider
943 .and_then(|is_volume_rider| match is_volume_rider.pos.kind {
944 Volume::Terrain => None,
945 Volume::Entity(e) => {
946 let e = self.state.ecs().entity_from_uid(e)?;
947 let pos = self
948 .state
949 .ecs()
950 .read_storage::<comp::Pos>()
951 .get(e)
952 .copied()?;
953
954 Some(pos.0)
955 },
956 })
957 .unwrap_or(pos.0);
958 let chunk_key = terrain.pos_key(pos.map(|e| e.floor() as i32));
959 match anchor {
960 Some(Anchor::Chunk(hc)) => {
961 terrain.get_key_real(chunk_key).is_none()
966 && terrain.get_key_real(*hc).is_none()
967 },
968 Some(Anchor::Entity(entity)) => !self.state.ecs().is_alive(*entity),
969 None => terrain.get_key_real(chunk_key).is_none(),
970 }
971 })
972 .map(|(entity, _, _, _, _)| entity)
973 .collect::<Vec<_>>()
974 };
975
976 #[cfg(feature = "worldgen")]
977 {
978 let mut rtsim = self.state.ecs().write_resource::<rtsim::RtSim>();
979 let rtsim_entities = self.state.ecs().read_storage();
980 for entity in &to_delete {
981 if let Some(rtsim_entity) = rtsim_entities.get(*entity) {
982 rtsim.hook_rtsim_entity_unload(*rtsim_entity);
983 }
984 }
985 }
986
987 for entity in to_delete {
989 if let Err(e) = self.state.delete_entity_recorded(entity) {
990 error!(?e, "Failed to delete agent outside the terrain");
991 }
992 }
993
994 if let Some(DisconnectType::WithoutPersistence) = disconnect_type {
995 info!(
996 "Disconnection of all players without persistence complete, signalling to \
997 persistence thread that character updates may continue to be processed"
998 );
999 self.state
1000 .ecs()
1001 .fetch_mut::<CharacterUpdater>()
1002 .disconnected_success();
1003 }
1004
1005 let before_persistence_updates = Instant::now();
1007
1008 let character_loader = self.state.ecs().read_resource::<CharacterLoader>();
1009
1010 let mut character_updater = self.state.ecs().write_resource::<CharacterUpdater>();
1011 let updater_messages: Vec<CharacterUpdaterMessage> = character_updater.messages().collect();
1012
1013 character_loader
1015 .messages()
1016 .chain(updater_messages)
1017 .for_each(|message| match message {
1018 CharacterUpdaterMessage::DatabaseBatchCompletion(batch_id) => {
1019 character_updater.process_batch_completion(batch_id);
1020 },
1021 CharacterUpdaterMessage::CharacterScreenResponse(response) => {
1022 match response.response_kind {
1023 CharacterScreenResponseKind::CharacterList(result) => match result {
1024 Ok(mut character_list_data) => {
1025 self.parse_locations(&mut character_list_data);
1026 self.notify_client(
1027 response.target_entity,
1028 ServerGeneral::CharacterListUpdate(character_list_data),
1029 )
1030 },
1031 Err(error) => self.notify_client(
1032 response.target_entity,
1033 ServerGeneral::CharacterActionError(error.to_string()),
1034 ),
1035 },
1036 CharacterScreenResponseKind::CharacterCreation(result) => match result {
1037 Ok((character_id, mut list)) => {
1038 self.parse_locations(&mut list);
1039 self.notify_client(
1040 response.target_entity,
1041 ServerGeneral::CharacterListUpdate(list),
1042 );
1043 self.notify_client(
1044 response.target_entity,
1045 ServerGeneral::CharacterCreated(character_id),
1046 );
1047 },
1048 Err(error) => self.notify_client(
1049 response.target_entity,
1050 ServerGeneral::CharacterActionError(error.to_string()),
1051 ),
1052 },
1053 CharacterScreenResponseKind::CharacterEdit(result) => match result {
1054 Ok((character_id, mut list)) => {
1055 self.parse_locations(&mut list);
1056 self.notify_client(
1057 response.target_entity,
1058 ServerGeneral::CharacterListUpdate(list),
1059 );
1060 self.notify_client(
1061 response.target_entity,
1062 ServerGeneral::CharacterEdited(character_id),
1063 );
1064 },
1065 Err(error) => self.notify_client(
1066 response.target_entity,
1067 ServerGeneral::CharacterActionError(error.to_string()),
1068 ),
1069 },
1070 CharacterScreenResponseKind::CharacterData(result) => {
1071 match *result {
1072 Ok((character_data, skill_set_persistence_load_error)) => {
1073 let PersistedComponents {
1074 body,
1075 hardcore,
1076 stats,
1077 skill_set,
1078 inventory,
1079 waypoint,
1080 pets,
1081 active_abilities,
1082 map_marker,
1083 } = character_data;
1084 let character_data = (
1085 body,
1086 hardcore,
1087 stats,
1088 skill_set,
1089 inventory,
1090 waypoint,
1091 pets,
1092 active_abilities,
1093 map_marker,
1094 );
1095 self.state.emit_event_now(UpdateCharacterDataEvent {
1098 entity: response.target_entity,
1099 components: character_data,
1100 metadata: skill_set_persistence_load_error,
1101 })
1102 },
1103 Err(error) => {
1104 self.notify_client(
1108 response.target_entity,
1109 ServerGeneral::CharacterDataLoadResult(Err(
1110 error.to_string()
1111 )),
1112 );
1113
1114 self.state.emit_event_now(ExitIngameEvent {
1116 entity: response.target_entity,
1117 })
1118 },
1119 }
1120 },
1121 }
1122 },
1123 });
1124
1125 drop(character_loader);
1126 drop(character_updater);
1127
1128 {
1129 let index = &mut self.index;
1134 let world = &mut self.world;
1135 let ecs = self.state.ecs_mut();
1136 let slow_jobs = ecs.write_resource::<SlowJobPool>();
1137
1138 index.reload_if_changed(|index| {
1139 let mut chunk_generator = ecs.write_resource::<ChunkGenerator>();
1140 let client = ecs.read_storage::<Client>();
1141 let mut terrain = ecs.write_resource::<common::terrain::TerrainGrid>();
1142 #[cfg(feature = "worldgen")]
1143 let rtsim = ecs.read_resource::<rtsim::RtSim>();
1144 #[cfg(not(feature = "worldgen"))]
1145 let rtsim = ();
1146
1147 chunk_generator.cancel_all();
1149
1150 if client.is_empty() {
1151 terrain.clear();
1153 } else {
1154 terrain.iter().for_each(|(pos, _)| {
1156 chunk_generator.generate_chunk(
1157 None,
1158 pos,
1159 &slow_jobs,
1160 Arc::clone(world),
1161 &rtsim,
1162 index.clone(),
1163 (
1164 *ecs.read_resource::<TimeOfDay>(),
1165 (*ecs.read_resource::<Calendar>()).clone(),
1166 ),
1167 );
1168 });
1169 }
1170 });
1171 }
1172
1173 let end_of_server_tick = Instant::now();
1174
1175 run_now::<sys::metrics::Sys>(self.state.ecs());
1177
1178 {
1179 let tick_metrics = self.state.ecs().read_resource::<TickMetrics>();
1181
1182 let tt = &tick_metrics.tick_time;
1183 tt.with_label_values(&["new connections"])
1184 .set((before_state_tick - before_new_connections).as_nanos() as i64);
1185 tt.with_label_values(&["handle server events"])
1186 .set((before_update_terrain_and_regions - before_handle_events).as_nanos() as i64);
1187 tt.with_label_values(&["update terrain and region map"])
1188 .set((before_sync - before_update_terrain_and_regions).as_nanos() as i64);
1189 tt.with_label_values(&["state"])
1190 .set((before_handle_events - before_state_tick).as_nanos() as i64);
1191 tt.with_label_values(&["world tick"])
1192 .set((before_entity_cleanup - before_world_tick).as_nanos() as i64);
1193 tt.with_label_values(&["entity cleanup"])
1194 .set((before_persistence_updates - before_entity_cleanup).as_nanos() as i64);
1195 tt.with_label_values(&["persistence_updates"])
1196 .set((end_of_server_tick - before_persistence_updates).as_nanos() as i64);
1197 for (label, duration) in state_tick_metrics.timings {
1198 tick_metrics
1199 .state_tick_time
1200 .with_label_values(&[label])
1201 .set(duration.as_nanos() as i64);
1202 }
1203 tick_metrics.tick_time_hist.observe(
1204 end_of_server_tick
1205 .duration_since(before_state_tick)
1206 .as_secs_f64(),
1207 );
1208 }
1209
1210 Ok(frontend_events)
1213 }
1214
1215 pub fn cleanup(&mut self) {
1217 self.state.cleanup();
1219
1220 #[cfg(feature = "persistent_world")]
1222 self.state
1223 .ecs()
1224 .try_fetch_mut::<TerrainPersistence>()
1225 .map(|mut t| t.maintain());
1226 }
1227
1228 fn update_region_map(&mut self) {
1230 prof_span!("Server::update_region_map");
1231 let ecs = self.state().ecs();
1232 ecs.write_resource::<RegionMap>().tick(
1233 ecs.read_storage::<comp::Pos>(),
1234 ecs.read_storage::<comp::Vel>(),
1235 ecs.read_storage::<comp::Presence>(),
1236 ecs.entities(),
1237 );
1238 }
1239
1240 fn initialize_client(&mut self, client: connection_handler::IncomingClient) -> Entity {
1241 let entity = self
1242 .state
1243 .ecs_mut()
1244 .create_entity_synced()
1245 .with(client)
1246 .build();
1247 self.state
1248 .ecs()
1249 .read_resource::<metrics::PlayerMetrics>()
1250 .clients_connected
1251 .inc();
1252 entity
1253 }
1254
1255 fn disconnect_all_clients_if_requested(&mut self) -> Option<DisconnectType> {
1259 let mut character_updater = self.state.ecs().fetch_mut::<CharacterUpdater>();
1260
1261 let disconnect_type = self.get_disconnect_all_clients_requested(&mut character_updater);
1262 if let Some(disconnect_type) = disconnect_type {
1263 let with_persistence = disconnect_type == DisconnectType::WithPersistence;
1264 let clients = self.state.ecs().read_storage::<Client>();
1265 let entities = self.state.ecs().entities();
1266
1267 info!(
1268 "Disconnecting all clients ({} persistence) as requested",
1269 if with_persistence { "with" } else { "without" }
1270 );
1271 for (_, entity) in (&clients, &entities).join() {
1272 info!("Emitting client disconnect event for entity: {:?}", entity);
1273 if with_persistence {
1274 self.state.emit_event_now(ClientDisconnectEvent(
1275 entity,
1276 comp::DisconnectReason::Kicked,
1277 ))
1278 } else {
1279 self.state
1280 .emit_event_now(ClientDisconnectWithoutPersistenceEvent(entity))
1281 };
1282 }
1283
1284 self.disconnect_all_clients_requested = false;
1285 }
1286
1287 disconnect_type
1288 }
1289
1290 fn get_disconnect_all_clients_requested(
1291 &self,
1292 character_updater: &mut CharacterUpdater,
1293 ) -> Option<DisconnectType> {
1294 let without_persistence_requested = character_updater.disconnect_all_clients_requested();
1295 let with_persistence_requested = self.disconnect_all_clients_requested;
1296
1297 if without_persistence_requested {
1298 return Some(DisconnectType::WithoutPersistence);
1299 };
1300 if with_persistence_requested {
1301 return Some(DisconnectType::WithPersistence);
1302 };
1303 None
1304 }
1305
1306 fn handle_new_connections(&mut self, frontend_events: &mut Vec<Event>) {
1308 while let Ok(sender) = self.connection_handler.info_requester_receiver.try_recv() {
1309 trace!("sending info to connection_handler");
1311 let _ = sender.send(connection_handler::ServerInfoPacket {
1312 info: self.get_server_info(),
1313 time: self.state.get_time(),
1314 });
1315 }
1316
1317 while let Ok(incoming) = self.connection_handler.client_receiver.try_recv() {
1318 let entity = self.initialize_client(incoming);
1319 frontend_events.push(Event::ClientConnected { entity });
1320 }
1321 }
1322
1323 pub fn notify_client<S>(&self, entity: EcsEntity, msg: S)
1324 where
1325 S: Into<ServerMsg>,
1326 {
1327 if let Some(client) = self.state.ecs().read_storage::<Client>().get(entity) {
1328 client.send_fallible(msg);
1329 }
1330 }
1331
1332 pub fn notify_players(&mut self, msg: ServerGeneral) { self.state.notify_players(msg); }
1333
1334 pub fn generate_chunk(&mut self, entity: EcsEntity, key: Vec2<i32>) {
1335 let ecs = self.state.ecs();
1336 let slow_jobs = ecs.read_resource::<SlowJobPool>();
1337 #[cfg(feature = "worldgen")]
1338 let rtsim = ecs.read_resource::<rtsim::RtSim>();
1339 #[cfg(not(feature = "worldgen"))]
1340 let rtsim = ();
1341 ecs.write_resource::<ChunkGenerator>().generate_chunk(
1342 Some(entity),
1343 key,
1344 &slow_jobs,
1345 Arc::clone(&self.world),
1346 &rtsim,
1347 self.index.clone(),
1348 (
1349 *ecs.read_resource::<TimeOfDay>(),
1350 (*ecs.read_resource::<Calendar>()).clone(),
1351 ),
1352 );
1353 }
1354
1355 fn process_command(&mut self, entity: EcsEntity, name: String, args: Vec<String>) {
1356 if let Ok(command) = name.parse::<ServerChatCommand>() {
1358 command.execute(self, entity, args);
1359 } else {
1360 #[cfg(feature = "plugins")]
1361 {
1362 let mut plugin_manager = self.state.ecs().write_resource::<PluginMgr>();
1363 let ecs_world = EcsWorld {
1364 entities: &self.state.ecs().entities(),
1365 health: self.state.ecs().read_component().into(),
1366 uid: self.state.ecs().read_component().into(),
1367 id_maps: &self.state.ecs().read_resource::<IdMaps>().into(),
1368 player: self.state.ecs().read_component().into(),
1369 };
1370 let uid = if let Some(uid) = ecs_world.uid.get(entity).copied() {
1371 uid
1372 } else {
1373 self.notify_client(
1374 entity,
1375 ServerGeneral::server_msg(
1376 comp::ChatType::CommandError,
1377 common::comp::Content::Plain(
1378 "Can't get player UUID (player may be disconnected?)".to_string(),
1379 ),
1380 ),
1381 );
1382 return;
1383 };
1384 match plugin_manager.command_event(&ecs_world, &name, args.as_slice(), uid) {
1385 Err(common_state::plugin::CommandResults::UnknownCommand) => self
1386 .notify_client(
1387 entity,
1388 ServerGeneral::server_msg(
1389 comp::ChatType::CommandError,
1390 common::comp::Content::Plain(format!(
1391 "Unknown command '/{name}'.\nType '/help' for available \
1392 commands",
1393 )),
1394 ),
1395 ),
1396 Ok(value) => {
1397 self.notify_client(
1398 entity,
1399 ServerGeneral::server_msg(
1400 comp::ChatType::CommandInfo,
1401 common::comp::Content::Plain(value.join("\n")),
1402 ),
1403 );
1404 },
1405 Err(common_state::plugin::CommandResults::PluginError(err)) => {
1406 self.notify_client(
1407 entity,
1408 ServerGeneral::server_msg(
1409 comp::ChatType::CommandError,
1410 common::comp::Content::Plain(format!(
1411 "Error occurred while executing command '/{name}'.\n{err}"
1412 )),
1413 ),
1414 );
1415 },
1416 Err(common_state::plugin::CommandResults::HostError(err)) => {
1417 error!(?err, ?name, ?args, "Can't execute command");
1418 self.notify_client(
1419 entity,
1420 ServerGeneral::server_msg(
1421 comp::ChatType::CommandError,
1422 common::comp::Content::Plain(format!(
1423 "Internal error {err:?} while executing '/{name}'.\nContact \
1424 the server administrator",
1425 )),
1426 ),
1427 );
1428 },
1429 }
1430 }
1431 }
1432 }
1433
1434 fn entity_admin_role(&self, entity: EcsEntity) -> Option<comp::AdminRole> {
1435 self.state
1436 .read_component_copied::<comp::Admin>(entity)
1437 .map(|admin| admin.0)
1438 }
1439
1440 pub fn number_of_players(&self) -> i64 {
1441 self.state.ecs().read_storage::<Client>().join().count() as i64
1442 }
1443
1444 pub fn add_admin(&mut self, username: &str, role: comp::AdminRole) {
1447 let mut editable_settings = self.editable_settings_mut();
1448 let login_provider = self.state.ecs().fetch::<LoginProvider>();
1449 let data_dir = self.data_dir();
1450 if let Some(entity) = add_admin(
1451 username,
1452 role,
1453 &login_provider,
1454 &mut editable_settings,
1455 &data_dir.path,
1456 )
1457 .and_then(|uuid| {
1458 let state = &self.state;
1459 (
1460 &state.ecs().entities(),
1461 &state.read_storage::<comp::Player>(),
1462 )
1463 .join()
1464 .find(|(_, player)| player.uuid() == uuid)
1465 .map(|(e, _)| e)
1466 }) {
1467 drop((data_dir, login_provider, editable_settings));
1468 self.state
1471 .write_component_ignore_entity_dead(entity, comp::Admin(role));
1472 };
1473 }
1474
1475 pub fn remove_admin(&self, username: &str) {
1478 let mut editable_settings = self.editable_settings_mut();
1479 let login_provider = self.state.ecs().fetch::<LoginProvider>();
1480 let data_dir = self.data_dir();
1481 if let Some(entity) = remove_admin(
1482 username,
1483 &login_provider,
1484 &mut editable_settings,
1485 &data_dir.path,
1486 )
1487 .and_then(|uuid| {
1488 let state = &self.state;
1489 (
1490 &state.ecs().entities(),
1491 &state.read_storage::<comp::Player>(),
1492 )
1493 .join()
1494 .find(|(_, player)| player.uuid() == uuid)
1495 .map(|(e, _)| e)
1496 }) {
1497 self.state
1499 .ecs()
1500 .write_storage::<comp::Admin>()
1501 .remove(entity);
1502 };
1503 }
1504
1505 #[cfg(feature = "worldgen")]
1510 pub fn create_centered_persister(&mut self, view_distance: u32) {
1511 let world_dims_chunks = self.world.sim().get_size();
1512 let world_dims_blocks = TerrainChunkSize::blocks(world_dims_chunks);
1513 let pos = comp::Pos(Vec3::from(world_dims_blocks.map(|e| e as f32 / 2.0)));
1521 self.state
1522 .create_persister(pos, view_distance, &self.world, &self.index)
1523 .build();
1524 }
1525
1526 pub fn chunks_pending(&mut self) -> bool {
1528 self.state_mut()
1529 .mut_resource::<ChunkGenerator>()
1530 .pending_chunks()
1531 .next()
1532 .is_some()
1533 }
1534
1535 pub fn set_sql_log_mode(&mut self, sql_log_mode: SqlLogMode) {
1537 let mut database_settings = self.database_settings.write().unwrap();
1543 database_settings.sql_log_mode = sql_log_mode;
1544 drop(database_settings);
1547 info!("SQL log mode changed to {:?}", sql_log_mode);
1548 }
1549
1550 pub fn disconnect_all_clients(&mut self) {
1551 info!("Disconnecting all clients due to local console command");
1552 self.disconnect_all_clients_requested = true;
1553 }
1554}
1555
1556impl Drop for Server {
1557 fn drop(&mut self) {
1558 self.state
1559 .notify_players(ServerGeneral::Disconnect(DisconnectReason::Shutdown));
1560
1561 #[cfg(feature = "persistent_world")]
1562 self.state
1563 .ecs()
1564 .try_fetch_mut::<TerrainPersistence>()
1565 .map(|mut terrain_persistence| {
1566 info!("Unloading terrain persistence...");
1567 terrain_persistence.unload_all()
1568 });
1569
1570 #[cfg(feature = "worldgen")]
1571 {
1572 debug!("Saving rtsim state...");
1573 self.state.ecs().write_resource::<rtsim::RtSim>().save(true);
1574 }
1575 }
1576}
1577
1578#[must_use]
1579pub fn handle_edit<T, S: settings::EditableSetting>(
1580 data: T,
1581 result: Option<(String, Result<(), settings::SettingError<S>>)>,
1582) -> Option<T> {
1583 use crate::settings::SettingError;
1584 let (info, result) = result?;
1585 match result {
1586 Ok(()) => {
1587 info!("{}", info);
1588 Some(data)
1589 },
1590 Err(SettingError::Io(err)) => {
1591 warn!(
1592 ?err,
1593 "Failed to write settings file to disk, but succeeded in memory (success message: \
1594 {})",
1595 info,
1596 );
1597 Some(data)
1598 },
1599 Err(SettingError::Integrity(err)) => {
1600 error!(?err, "Encountered an error while validating the request",);
1601 None
1602 },
1603 }
1604}
1605
1606#[must_use]
1611pub fn add_admin(
1612 username: &str,
1613 role: comp::AdminRole,
1614 login_provider: &LoginProvider,
1615 editable_settings: &mut EditableSettings,
1616 data_dir: &std::path::Path,
1617) -> Option<common::uuid::Uuid> {
1618 use crate::settings::EditableSetting;
1619 let role_ = role.into();
1620 match login_provider.username_to_uuid(username) {
1621 Ok(uuid) => handle_edit(
1622 uuid,
1623 editable_settings.admins.edit(data_dir, |admins| {
1624 match admins.insert(uuid, settings::AdminRecord {
1625 username_when_admined: Some(username.into()),
1626 date: chrono::Utc::now(),
1627 role: role_,
1628 }) {
1629 None => Some(format!(
1630 "Successfully added {} ({}) as {:?}!",
1631 username, uuid, role
1632 )),
1633 Some(old_admin) if old_admin.role == role_ => {
1634 info!("{} ({}) already has role: {:?}!", username, uuid, role);
1635 None
1636 },
1637 Some(old_admin) => Some(format!(
1638 "{} ({}) role changed from {:?} to {:?}!",
1639 username, uuid, old_admin.role, role
1640 )),
1641 }
1642 }),
1643 ),
1644 Err(err) => {
1645 error!(
1646 ?err,
1647 "Could not find uuid for this name; either the user does not exist or there was \
1648 an error communicating with the auth server."
1649 );
1650 None
1651 },
1652 }
1653}
1654
1655#[must_use]
1660pub fn remove_admin(
1661 username: &str,
1662 login_provider: &LoginProvider,
1663 editable_settings: &mut EditableSettings,
1664 data_dir: &std::path::Path,
1665) -> Option<common::uuid::Uuid> {
1666 use crate::settings::EditableSetting;
1667 match login_provider.username_to_uuid(username) {
1668 Ok(uuid) => handle_edit(
1669 uuid,
1670 editable_settings.admins.edit(data_dir, |admins| {
1671 if let Some(admin) = admins.remove(&uuid) {
1672 Some(format!(
1673 "Successfully removed {} ({}) with role {:?} from the admins list",
1674 username, uuid, admin.role,
1675 ))
1676 } else {
1677 info!("{} ({}) is not an admin!", username, uuid);
1678 None
1679 }
1680 }),
1681 ),
1682 Err(err) => {
1683 error!(
1684 ?err,
1685 "Could not find uuid for this name; either the user does not exist or there was \
1686 an error communicating with the auth server."
1687 );
1688 None
1689 },
1690 }
1691}