restart listener when config changes

src-tauri/src/main.rs

@@ -2,8 +2,19 @@
     all(not(debug_assertions), target_os = "windows"),
     windows_subsystem = "windows"
 )]
+use std::error::Error;
 
-use tauri::{AppHandle, Manager, async_runtime as rt};
+use sqlx::{
+    SqlitePool,
+    sqlite::SqlitePoolOptions,
+    sqlite::SqliteConnectOptions,
+};
+use tauri::{
+    App,
+    AppHandle,
+    Manager,
+    async_runtime as rt,
+};
 use once_cell::sync::OnceCell;
 
 mod config;
@@ -14,20 +25,44 @@ mod state;
 mod server;
 mod tray;
 
-use crate::errors::*;
+use config::AppConfig;
+use server::Server;
+use errors::*;
 use state::AppState;
 
 
 pub static APP: OnceCell<AppHandle> = OnceCell::new();
 
-fn main() {
-    let initial_state = match rt::block_on(AppState::load()) {
-        Ok(state) => state,
-        Err(e) => {eprintln!("{}", e); return;}
-    };
 
+async fn setup(app: &mut App) -> Result<(), Box<dyn Error>> {
+    APP.set(app.handle()).unwrap();
+
+    let conn_opts = SqliteConnectOptions::new()
+        .filename(config::get_or_create_db_path())
+        .create_if_missing(true);
+    let pool_opts = SqlitePoolOptions::new();
+    let pool: SqlitePool = pool_opts.connect_with(conn_opts).await?;
+    sqlx::migrate!().run(&pool).await?;
+
+    let conf = AppConfig::load(&pool).await?;
+    let session = AppState::load_creds(&pool).await?;
+    let srv = Server::new(conf.listen_addr, conf.listen_port, app.handle()).await?;
+
+    config::set_auto_launch(conf.start_on_login)?;
+    if !conf.start_minimized {
+        app.get_window("main")
+            .ok_or(RequestError::NoMainWindow)?
+            .show()?;
+    }
+
+    let state = AppState::new(conf, session, srv, pool);
+    app.manage(state);
+    Ok(())
+}
+
+
+fn main() {
     tauri::Builder::default()
-        .manage(initial_state)
         .system_tray(tray::create())
         .on_system_tray_event(tray::handle_event)
         .invoke_handler(tauri::generate_handler![
@@ -38,22 +73,7 @@ fn main() {
             ipc::get_config,
             ipc::save_config,
         ])
-        .setup(|app| {
-            APP.set(app.handle()).unwrap();
-            let state = app.state::<AppState>();
-            let config = state.config.read().unwrap();
-            config::set_auto_launch(config.start_on_login)?;
-
-            let addr = std::net::SocketAddrV4::new(config.listen_addr, config.listen_port);
-            tauri::async_runtime::spawn(server::serve(addr, app.handle()));
-
-            if !config.start_minimized {
-                app.get_window("main")
-                    .ok_or(RequestError::NoMainWindow)?
-                    .show()?;
-            }
-            Ok(())
-        })
+        .setup(|app| rt::block_on(setup(app)))
         .build(tauri::generate_context!())
         .expect("error while running tauri application")
         .run(|app, run_event| match run_event {