leyoda/rqbit
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial commit for desktop configuration. Broken now

Browse source
This commit is contained in:
Igor Katson 2023-12-06 14:30:32 +00:00
parent dd355b0a74
commit a3475784e9
No known key found for this signature in database
GPG key ID: B4EC22B66D61A3F5
8 changed files with 304 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

179
desktop/src-tauri/src/main.rs
View file

@ -1,24 +1,134 @@
// Prevents additional console window on Windows in release, DO NOT REMOVE!!
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
mod config;
use std::sync::Arc;
use anyhow::Context;
use config::RqbitDesktopConfig;
use http::StatusCode;
use librqbit::{
api::{
ApiAddTorrentResponse, EmptyJsonResponse, TorrentDetailsResponse, TorrentListResponse,
TorrentStats,
},
librqbit_spawn, AddTorrent, AddTorrentOptions, Api, ApiError, Session, SessionOptions,
dht::PersistentDhtConfig,
librqbit_spawn, AddTorrent, AddTorrentOptions, Api, ApiError, PeerConnectionOptions, Session,
SessionOptions,
};
use parking_lot::RwLock;
use tracing::error_span;
struct State {
const ERR_NOT_CONFIGURED: ApiError =
ApiError::new_from_text(StatusCode::FAILED_DEPENDENCY, "not configured");
struct StateShared {
config: config::RqbitDesktopConfig,
api: Api,
session: Arc<Session>,
}
impl StateShared {}
struct State {
shared: Arc<RwLock<Option<StateShared>>>,
rust_log_reload_tx: tokio::sync::mpsc::UnboundedSender<String>,
}
impl State {
fn api(&self) -> Result<Api, ApiError> {
let g = self.shared.read();
match &*g {
Some(s) => Ok(s.api.clone()),
None => Err(ERR_NOT_CONFIGURED),
}
}
fn current_config(&self) -> Option<RqbitDesktopConfig> {
self.shared.read().as_ref().map(|s| s.config.clone())
}
async fn configure(&self, config: RqbitDesktopConfig) -> Result<(), ApiError> {
let existing = self.shared.write().take();
if let Some(existing) = existing {
existing.session.stop().await;
}
let config_clone = config.clone();
let session = Session::new_with_opts(
config.default_download_location,
SessionOptions {
disable_dht: config.dht.disable,
disable_dht_persistence: config.dht.disable_persistence,
dht_config: Some(PersistentDhtConfig {
config_filename: Some(config.dht.persistence_filename),
..Default::default()
}),
persistence: !config.persistence.disable,
persistence_filename: Some(config.persistence.filename),
peer_opts: Some(PeerConnectionOptions {
connect_timeout: Some(config.peer_opts.connect_timeout),
read_write_timeout: Some(config.peer_opts.read_write_timeout),
..Default::default()
}),
listen_port_range: if !config.tcp_listen.disable {
Some(config.tcp_listen.min_port..config.tcp_listen.max_port)
} else {
None
},
enable_upnp_port_forwarding: !config.upnp.disable,
..Default::default()
},
)
.await
.context("couldn't set up librqbit session")?;
let api = Api::new(session.clone(), None);
if !config.http_api.disable {
let http_api_task = librqbit::http_api::HttpApi::new(
session.clone(),
Some(self.rust_log_reload_tx.clone()),
)
.make_http_api_and_run(config.http_api.listen_addr, config.http_api.read_only);
session.spawn("http api", error_span!("http_api"), http_api_task);
}
*self.shared.write() = Some(StateShared {
config: config_clone,
api,
session,
});
Ok(())
}
}
#[tauri::command]
fn torrents_list(state: tauri::State<State>) -> TorrentListResponse {
state.api.api_torrent_list()
fn config_default() -> config::RqbitDesktopConfig {
config::RqbitDesktopConfig::default()
}
#[tauri::command]
fn config_current(state: tauri::State<'_, State>) -> Option<config::RqbitDesktopConfig> {
state.current_config()
}
#[tauri::command]
async fn config_change(
state: tauri::State<'_, State>,
config: RqbitDesktopConfig,
) -> Result<EmptyJsonResponse, ApiError> {
state.configure(config).await.map(|_| EmptyJsonResponse {})
}
#[tauri::command]
fn torrents_list(state: tauri::State<State>) -> Result<TorrentListResponse, ApiError> {
Ok(state.api()?.api_torrent_list())
}
#[tauri::command]
@ -28,7 +138,7 @@ async fn torrent_create_from_url(
opts: Option<AddTorrentOptions>,
) -> Result<ApiAddTorrentResponse, ApiError> {
state
.api
.api()?
.api_add_torrent(AddTorrent::Url(url.into()), opts)
.await
}
@ -45,7 +155,7 @@ async fn torrent_create_from_base64_file(
.context("invalid base64")
.map_err(|e| ApiError::new_from_anyhow(StatusCode::BAD_REQUEST, e))?;
state
.api
.api()?
.api_add_torrent(AddTorrent::TorrentFileBytes(bytes.into()), opts)
.await
}
@ -55,7 +165,7 @@ async fn torrent_details(
state: tauri::State<'_, State>,
id: usize,
) -> Result<TorrentDetailsResponse, ApiError> {
state.api.api_torrent_details(id)
state.api()?.api_torrent_details(id)
}
#[tauri::command]
@ -63,7 +173,7 @@ async fn torrent_stats(
state: tauri::State<'_, State>,
id: usize,
) -> Result<TorrentStats, ApiError> {
state.api.api_stats_v1(id)
state.api()?.api_stats_v1(id)
}
#[tauri::command]
@ -71,7 +181,7 @@ async fn torrent_action_delete(
state: tauri::State<'_, State>,
id: usize,
) -> Result<EmptyJsonResponse, ApiError> {
state.api.api_torrent_action_delete(id)
state.api()?.api_torrent_action_delete(id)
}
#[tauri::command]
@ -79,7 +189,7 @@ async fn torrent_action_pause(
state: tauri::State<'_, State>,
id: usize,
) -> Result<EmptyJsonResponse, ApiError> {
state.api.api_torrent_action_pause(id)
state.api()?.api_torrent_action_pause(id)
}
#[tauri::command]
@ -87,7 +197,7 @@ async fn torrent_action_forget(
state: tauri::State<'_, State>,
id: usize,
) -> Result<EmptyJsonResponse, ApiError> {
state.api.api_torrent_action_forget(id)
state.api()?.api_torrent_action_forget(id)
}
#[tauri::command]
@ -95,7 +205,7 @@ async fn torrent_action_start(
state: tauri::State<'_, State>,
id: usize,
) -> Result<EmptyJsonResponse, ApiError> {
state.api.api_torrent_action_start(id)
state.api()?.api_torrent_action_start(id)
}
#[tauri::command]
@ -133,41 +243,15 @@ fn init_logging() -> tokio::sync::mpsc::UnboundedSender<String> {
reload_tx
}
async fn start_session() {
async fn start() {
tauri::async_runtime::set(tokio::runtime::Handle::current());
let rust_log_reload_tx = init_logging();
tauri::async_runtime::set(tokio::runtime::Handle::current());
let download_folder = directories::UserDirs::new()
.expect("directories::UserDirs::new()")
.download_dir()
.expect("download_dir()")
.to_path_buf();
let session = Session::new_with_opts(
download_folder,
SessionOptions {
disable_dht: false,
disable_dht_persistence: false,
persistence: true,
listen_port_range: Some(4240..4260),
..Default::default()
},
)
.await
.expect("couldn't set up librqbit session");
let api = Api::new(session.clone(), None);
librqbit_spawn(
"http api",
error_span!("http_api"),
librqbit::http_api::HttpApi::new(session, Some(rust_log_reload_tx))
.make_http_api_and_run("127.0.0.1:3030".parse().unwrap(), false),
);
tauri::Builder::default()
.manage(State { api })
.manage(State {
shared: Arc::new(RwLock::new(None)),
rust_log_reload_tx,
})
.invoke_handler(tauri::generate_handler![
torrents_list,
torrent_details,
@ -178,7 +262,10 @@ async fn start_session() {
torrent_action_forget,
torrent_action_start,
torrent_create_from_base64_file,
get_version
get_version,
config_default,
config_current,
config_change,
])
.run(tauri::generate_context!())
.expect("error while running tauri application");
@ -189,5 +276,5 @@ fn main() {
.enable_all()
.build()
.expect("couldn't set up tokio runtime")
.block_on(start_session())
.block_on(start())
}