forked from lavina/lavina
113 lines
3.1 KiB
Rust
113 lines
3.1 KiB
Rust
//! Domain definitions and implementation of common chat logic.
|
|
use std::ops::Deref;
|
|
use std::sync::Arc;
|
|
|
|
use anyhow::Result;
|
|
use prometheus::Registry as MetricsRegistry;
|
|
|
|
use crate::clustering::broadcast::Broadcasting;
|
|
use crate::clustering::{ClusterConfig, ClusterMetadata, LavinaClient};
|
|
use crate::dialog::DialogRegistry;
|
|
use crate::player::{PlayerConnection, PlayerId, PlayerRegistry};
|
|
use crate::repo::Storage;
|
|
use crate::room::{RoomHandle, RoomId, RoomInfo, RoomRegistry};
|
|
|
|
pub mod auth;
|
|
pub mod clustering;
|
|
pub mod dialog;
|
|
pub mod player;
|
|
pub mod prelude;
|
|
pub mod repo;
|
|
pub mod room;
|
|
pub mod terminator;
|
|
|
|
mod table;
|
|
|
|
#[derive(Clone)]
|
|
pub struct LavinaCore {
|
|
services: Arc<Services>,
|
|
}
|
|
|
|
impl Deref for LavinaCore {
|
|
type Target = Services;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.services
|
|
}
|
|
}
|
|
|
|
impl LavinaCore {
|
|
pub async fn connect_to_player(&self, player_id: &PlayerId) -> PlayerConnection {
|
|
self.services.players.connect_to_player(&self, player_id).await
|
|
}
|
|
|
|
pub async fn get_room(&self, room_id: &RoomId) -> Option<RoomHandle> {
|
|
self.services.rooms.get_room(&self.services, room_id).await
|
|
}
|
|
|
|
pub async fn create_player(&self, player_id: &PlayerId) -> Result<()> {
|
|
self.services.storage.create_user(player_id.as_inner()).await
|
|
}
|
|
|
|
pub async fn get_all_rooms(&self) -> Vec<RoomInfo> {
|
|
self.services.rooms.get_all_rooms().await
|
|
}
|
|
|
|
pub async fn stop_player(&self, player_id: &PlayerId) -> Result<Option<()>> {
|
|
self.services.players.stop_player(player_id).await
|
|
}
|
|
}
|
|
|
|
pub struct Services {
|
|
pub(crate) players: PlayerRegistry,
|
|
pub(crate) rooms: RoomRegistry,
|
|
pub(crate) dialogs: DialogRegistry,
|
|
pub(crate) broadcasting: Broadcasting,
|
|
pub(crate) client: LavinaClient,
|
|
pub(crate) storage: Storage,
|
|
pub(crate) cluster_metadata: ClusterMetadata,
|
|
}
|
|
|
|
impl LavinaCore {
|
|
pub async fn new(
|
|
metrics: &mut MetricsRegistry,
|
|
cluster_config: ClusterConfig,
|
|
storage: Storage,
|
|
) -> Result<LavinaCore> {
|
|
// TODO shutdown all services in reverse order on error
|
|
let broadcasting = Broadcasting::new();
|
|
let client = LavinaClient::new(cluster_config.addresses.clone());
|
|
let rooms = RoomRegistry::new(metrics)?;
|
|
let dialogs = DialogRegistry::new();
|
|
let players = PlayerRegistry::empty(metrics)?;
|
|
|
|
let services = Services {
|
|
players,
|
|
rooms,
|
|
dialogs,
|
|
broadcasting,
|
|
client,
|
|
storage,
|
|
cluster_metadata: cluster_config.metadata,
|
|
};
|
|
|
|
Ok(LavinaCore {
|
|
services: Arc::new(services),
|
|
})
|
|
}
|
|
|
|
pub async fn shutdown(self) -> Storage {
|
|
let _ = self.players.shutdown_all().await;
|
|
let services = match Arc::try_unwrap(self.services) {
|
|
Ok(e) => e,
|
|
Err(_) => {
|
|
panic!("failed to acquire services ownership on shutdown");
|
|
}
|
|
};
|
|
let _ = services.players.shutdown();
|
|
let _ = services.dialogs.shutdown();
|
|
let _ = services.rooms.shutdown();
|
|
services.storage
|
|
}
|
|
}
|