ddidderr/lanspread
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects Releases Wiki Activity

wip

Browse Source
This commit is contained in:
ddidderr
2025-11-11 21:30:26 +01:00
parent d831179783
commit 9c1b94fa6a
9 changed files with 191 additions and 450 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/lanspread-tauri-deno-ts/src-tauri/Cargo.toml
+1 -1
View File
@@ -28,7 +28,7 @@ tauri-build = { version = "2", features = [] }
[dependencies]
# local
lanspread-client = { path = "../../lanspread-client" }
lanspread-peer = { path = "../../lanspread-peer" }
lanspread-db = { path = "../../lanspread-db" }
lanspread-mdns = { path = "../../lanspread-mdns" }
crates/lanspread-tauri-deno-ts/src-tauri/src/lib.rs
+156 -78
View File
@@ -1,14 +1,13 @@
use std::{
collections::HashSet,
net::SocketAddr,
path::{Path, PathBuf},
sync::Arc,
};
use eyre::bail;
use lanspread_client::{ClientCommand, ClientEvent};
use lanspread_db::db::{Game, GameDB};
use lanspread_mdns::{LANSPREAD_SERVICE_TYPE, discover_service};
use lanspread_peer::{PeerCommand, PeerEvent, start_peer};
use tauri::{AppHandle, Emitter as _, Manager};
use tauri_plugin_shell::{ShellExt, process::Command};
use tokio::sync::{RwLock, mpsc::UnboundedSender};
@@ -16,8 +15,7 @@ use tokio::sync::{RwLock, mpsc::UnboundedSender};
// Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
struct LanSpreadState {
server_addr: RwLock<Option<SocketAddr>>,
client_ctrl: UnboundedSender<ClientCommand>,
peer_ctrl: Arc<RwLock<Option<UnboundedSender<PeerCommand>>>>,
games: Arc<RwLock<GameDB>>,
games_in_download: Arc<RwLock<HashSet<String>>>,
games_folder: Arc<RwLock<String>>,
@@ -27,8 +25,15 @@ struct LanSpreadState {
fn request_games(state: tauri::State<LanSpreadState>) {
log::debug!("request_games");
if let Err(e) = state.inner().client_ctrl.send(ClientCommand::ListGames) {
log::error!("Failed to send message to client: {e:?}");
let peer_ctrl =
tauri::async_runtime::block_on(async { state.inner().peer_ctrl.read().await.clone() });
if let Some(peer_ctrl) = peer_ctrl {
if let Err(e) = peer_ctrl.send(PeerCommand::ListGames) {
log::error!("Failed to send message to peer: {e:?}");
}
} else {
log::warn!("Peer system not initialized yet");
}
}
@@ -46,11 +51,18 @@ fn install_game(id: String, state: tauri::State<LanSpreadState>) -> bool {
return false;
}
if let Err(e) = state.inner().client_ctrl.send(ClientCommand::GetGame(id)) {
log::error!("Failed to send message to client: {e:?}");
}
let peer_ctrl =
tauri::async_runtime::block_on(async { state.inner().peer_ctrl.read().await.clone() });
true
if let Some(peer_ctrl) = peer_ctrl {
if let Err(e) = peer_ctrl.send(PeerCommand::GetGame(id)) {
log::error!("Failed to send message to peer: {e:?}");
}
true
} else {
log::warn!("Peer system not initialized yet");
false
}
}
/// Backup the current game folder by renaming it to `___TO_BE_DELETE___GameNameHere`
@@ -157,22 +169,25 @@ fn update_game(id: String, state: tauri::State<LanSpreadState>) -> bool {
log::info!("Starting update for game: {id}");
// Start the download process
if let Err(e) = state
.inner()
.client_ctrl
.send(ClientCommand::GetGame(id.clone()))
{
log::error!("Failed to send message to client: {e:?}");
let peer_ctrl =
tauri::async_runtime::block_on(async { state.inner().peer_ctrl.read().await.clone() });
// Try to restore backup if download fails to start
if let Err(restore_err) = restore_game_folder(&game_path, &backup_path) {
log::error!("Failed to restore backup after download failure: {restore_err}");
if let Some(peer_ctrl) = peer_ctrl {
if let Err(e) = peer_ctrl.send(PeerCommand::GetGame(id.clone())) {
log::error!("Failed to send message to peer: {e:?}");
// Try to restore backup if download fails to start
if let Err(restore_err) = restore_game_folder(&game_path, &backup_path) {
log::error!("Failed to restore backup after download failure: {restore_err}");
}
return false;
}
return false;
true
} else {
log::warn!("Peer system not initialized yet");
false
}
true
}
#[cfg(target_os = "windows")]
@@ -304,11 +319,21 @@ fn set_game_install_state_from_path(game_db: &mut GameDB, path: &Path, installed
fn update_game_directory(app_handle: tauri::AppHandle, path: String) {
log::info!("update_game_directory: {path}");
app_handle
.state::<LanSpreadState>()
.client_ctrl
.send(ClientCommand::SetGameDir(path.clone()))
.expect("Failed to send ClientCommand: SetGameDir");
let peer_ctrl = tauri::async_runtime::block_on(async {
app_handle
.state::<LanSpreadState>()
.inner()
.peer_ctrl
.read()
.await
.clone()
});
if let Some(peer_ctrl) = peer_ctrl {
if let Err(e) = peer_ctrl.send(PeerCommand::SetGameDir(path.clone())) {
log::error!("Failed to send PeerCommand::SetGameDir: {e}");
}
}
{
tauri::async_runtime::block_on(async {
@@ -366,24 +391,30 @@ fn update_game_directory(app_handle: tauri::AppHandle, path: String) {
});
}
async fn find_server(app: AppHandle) {
log::info!("Looking for server...");
async fn find_peers(app: AppHandle) {
log::info!("Looking for peers...");
loop {
match discover_service(LANSPREAD_SERVICE_TYPE) {
Ok(server_addr) => {
log::info!("Found server at {server_addr}");
Ok(peer_addr) => {
log::info!("Found peer at {peer_addr}");
let state: tauri::State<LanSpreadState> = app.state();
*state.server_addr.write().await = Some(server_addr);
state
.client_ctrl
.send(ClientCommand::ServerAddr(server_addr))
.expect("Failed to send ClientCommand: ServerAddr");
request_games(state);
let peer_ctrl = state.peer_ctrl.read().await.clone();
if let Some(peer_ctrl) = peer_ctrl {
if let Err(e) = peer_ctrl.send(PeerCommand::ConnectToPeer(peer_addr)) {
log::error!("Failed to send PeerCommand::ConnectToPeer: {e}");
}
request_games(state);
} else {
log::warn!(
"Peer system not initialized yet, cannot connect to discovered peer"
);
}
break;
}
Err(e) => {
log::warn!("Failed to find server: {e} - retrying...");
log::warn!("Failed to find peers: {e} - retrying...");
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
}
}
}
@@ -391,7 +422,7 @@ async fn find_server(app: AppHandle) {
async fn update_game_db(games: Vec<Game>, app: AppHandle) {
for game in &games {
log::trace!("client event ListGames iter: {game:?}");
log::trace!("peer event ListGames iter: {game:?}");
}
let state = app.state::<LanSpreadState>();
@@ -481,17 +512,11 @@ pub fn run() {
.level(log::LevelFilter::Info)
.level_for("mdns_sd::service_daemon", log::LevelFilter::Off);
// channel to pass commands to the client
let (tx_client_control, rx_client_control) =
tokio::sync::mpsc::unbounded_channel::<ClientCommand>();
// channel to receive events from the client
let (tx_client_event, mut rx_client_event) =
tokio::sync::mpsc::unbounded_channel::<ClientEvent>();
// channel to receive events from the peer
let (tx_peer_event, mut rx_peer_event) = tokio::sync::mpsc::unbounded_channel::<PeerEvent>();
let lanspread_state = LanSpreadState {
server_addr: RwLock::new(None),
client_ctrl: tx_client_control,
peer_ctrl: Arc::new(RwLock::new(None)),
games: Arc::new(RwLock::new(GameDB::empty())),
games_in_download: Arc::new(RwLock::new(HashSet::new())),
games_folder: Arc::new(RwLock::new(String::new())),
@@ -510,45 +535,73 @@ pub fn run() {
update_game
])
.manage(lanspread_state)
.setup(|app| {
.setup({
let tx_peer_event_clone = tx_peer_event.clone();
move |app| {
let app_handle = app.handle().clone();
// discover server
tauri::async_runtime::spawn(async move { find_server(app_handle).await });
// discover peers
tauri::async_runtime::spawn(async move { find_peers(app_handle).await });
// Initialize peer system when games directory is set
let app_handle_clone = app.handle().clone();
tauri::async_runtime::spawn(async move {
lanspread_client::run(rx_client_control, tx_client_event).await
// Wait for games directory to be set
loop {
let games_folder = {
let state = app_handle_clone.state::<LanSpreadState>();
state.games_folder.read().await.clone()
};
if !games_folder.is_empty() {
match start_peer(games_folder, tx_peer_event_clone) {
Ok(peer_ctrl) => {
let state = app_handle_clone.state::<LanSpreadState>();
*state.peer_ctrl.write().await = Some(peer_ctrl);
log::info!("Peer system initialized successfully");
}
Err(e) => {
log::error!("Failed to initialize peer system: {e}");
}
}
break;
}
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
}
});
let app_handle = app.handle().clone();
tauri::async_runtime::spawn(async move {
while let Some(event) = rx_client_event.recv().await {
while let Some(event) = rx_peer_event.recv().await {
match event {
ClientEvent::ListGames(games) => {
log::info!("ClientEvent::ListGames received");
PeerEvent::ListGames(games) => {
log::info!("PeerEvent::ListGames received");
update_game_db(games, app_handle.clone()).await;
}
ClientEvent::GotGameFiles { id, file_descriptions } => {
log::info!("ClientEvent::GotGameFiles received");
PeerEvent::GotGameFiles { id, file_descriptions } => {
log::info!("PeerEvent::GotGameFiles received");
if let Err(e) = app_handle.emit(
"game-download-pre",
Some(id.clone()),
) {
log::error!("ClientEvent::GotGameFiles: Failed to emit game-download-pre event: {e}");
log::error!("PeerEvent::GotGameFiles: Failed to emit game-download-pre event: {e}");
}
app_handle
.state::<LanSpreadState>()
.inner()
.client_ctrl
.send(ClientCommand::DownloadGameFiles{
let state = app_handle.state::<LanSpreadState>();
let peer_ctrl = state.peer_ctrl.read().await.clone();
if let Some(peer_ctrl) = peer_ctrl {
if let Err(e) = peer_ctrl.send(PeerCommand::DownloadGameFiles{
id,
file_descriptions,
})
.expect("Failed to send ClientCommand: DownloadGameFiles");
}) {
log::error!("Failed to send PeerCommand::DownloadGameFiles: {e}");
}
}
}
ClientEvent::DownloadGameFilesBegin { id } => {
log::info!("ClientEvent::DownloadGameFilesBegin received");
PeerEvent::DownloadGameFilesBegin { id } => {
log::info!("PeerEvent::DownloadGameFilesBegin received");
app_handle
.state::<LanSpreadState>()
@@ -559,13 +612,13 @@ pub fn run() {
.insert(id.clone());
if let Err(e) = app_handle.emit("game-download-begin", Some(id)) {
log::error!("ClientEvent::DownloadGameFilesBegin: Failed to emit game-download-begin event: {e}");
log::error!("PeerEvent::DownloadGameFilesBegin: Failed to emit game-download-begin event: {e}");
}
}
ClientEvent::DownloadGameFilesFinished { id } => {
log::info!("ClientEvent::DownloadGameFilesFinished received");
PeerEvent::DownloadGameFilesFinished { id } => {
log::info!("PeerEvent::DownloadGameFilesFinished received");
if let Err(e) = app_handle.emit("game-download-finished", Some(id.clone())) {
log::error!("ClientEvent::DownloadGameFilesFinished: Failed to emit game-download-finished event: {e}");
log::error!("PeerEvent::DownloadGameFilesFinished: Failed to emit game-download-finished event: {e}");
}
app_handle
@@ -594,22 +647,22 @@ pub fn run() {
if !games_folder.is_empty() {
let backup_name = format!("___TO_BE_DELETE___{id}");
let backup_path = PathBuf::from(games_folder).join(backup_name);
let backup_path = PathBuf::from(&games_folder).join(backup_name);
if let Err(e) = cleanup_backup_folder(&backup_path) {
log::error!("Failed to cleanup backup folder after successful update: {e}");
}
}
log::info!("ClientEvent::UnpackGameFinished received");
log::info!("PeerEvent::UnpackGameFinished received");
if let Err(e) = app_handle.emit("game-unpack-finished", Some(id.clone())) {
log::error!("ClientEvent::UnpackGameFinished: Failed to emit game-unpack-finished event: {e}");
log::error!("PeerEvent::UnpackGameFinished: Failed to emit game-unpack-finished event: {e}");
}
});
}
}
ClientEvent::DownloadGameFilesFailed { id } => {
log::warn!("ClientEvent::DownloadGameFilesFailed received");
PeerEvent::DownloadGameFilesFailed { id } => {
log::warn!("PeerEvent::DownloadGameFilesFailed received");
if let Err(e) = app_handle.emit("game-download-failed", Some(id.clone())) {
log::error!("Failed to emit game-download-failed event: {e}");
@@ -652,12 +705,37 @@ pub fn run() {
log::error!("Failed to restore backup after download failure: {e}");
}
}
},
}
PeerEvent::PeerConnected(addr) => {
log::info!("Peer connected: {}", addr);
if let Err(e) = app_handle.emit("peer-connected", Some(addr.to_string())) {
log::error!("Failed to emit peer-connected event: {e}");
}
}
PeerEvent::PeerDisconnected(addr) => {
log::info!("Peer disconnected: {}", addr);
if let Err(e) = app_handle.emit("peer-disconnected", Some(addr.to_string())) {
log::error!("Failed to emit peer-disconnected event: {e}");
}
}
PeerEvent::PeerDiscovered(addr) => {
log::info!("Peer discovered: {}", addr);
if let Err(e) = app_handle.emit("peer-discovered", Some(addr.to_string())) {
log::error!("Failed to emit peer-discovered event: {e}");
}
}
PeerEvent::PeerLost(addr) => {
log::info!("Peer lost: {}", addr);
if let Err(e) = app_handle.emit("peer-lost", Some(addr.to_string())) {
log::error!("Failed to emit peer-lost event: {e}");
}
}
}
}
});
Ok(())
}
})
.run(tauri::generate_context!())
.expect("error while running tauri application");