nebkor/joecalsend
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

cleanup and renames ('state' to 'service')

Browse source
This commit is contained in:
Joe Ardent 2025-08-03 13:46:03 -07:00
parent c8621da2f0
commit b486b33fa5
7 changed files with 56 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
src/app/mod.rs
View file

@ -1,11 +1,13 @@
use std::{collections::BTreeMap, net::SocketAddr, time::Duration};
use axum::body::Bytes;
use crossterm::event::{Event, EventStream, KeyCode, KeyEvent, KeyEventKind};
use futures::{FutureExt, StreamExt};
use joecalsend::{JoecalService, ReceiveDialog, ReceiveRequest, TransferEvent, error::Result};
use julid::Julid;
use log::{LevelFilter, debug, error, warn};
use ratatui::{Frame, widgets::TableState};
use ratatui_explorer::FileExplorer;
use tokio::sync::mpsc::UnboundedReceiver;
pub mod widgets;
@ -19,10 +21,12 @@ pub struct App {
// addr -> (alias, fingerprint)
pub peers: Peers,
pub receive_requests: BTreeMap<Julid, ReceiveRequest>,
upload_state: TableState,
receiving_state: TableState,
// for getting messages back from the web server or web client about things we've done; the
// other end is held by the service
event_listener: UnboundedReceiver<TransferEvent>,
file_picker: FileExplorer,
content: Option<Bytes>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@ -46,10 +50,12 @@ impl App {
service,
event_listener,
screen: vec![CurrentScreen::Main],
file_picker: FileExplorer::new().expect("could not create file explorer"),
content: None,
events: Default::default(),
peers: Default::default(),
receive_requests: Default::default(),
upload_state: Default::default(),
receiving_state: Default::default(),
}
}
@ -60,7 +66,7 @@ impl App {
match evt {
Event::Key(key)
if key.kind == KeyEventKind::Press
=> self.handle_key_event(key),
=> self.handle_key_event(key, evt),
Event::Mouse(_) => {}
Event::Resize(_, _) => {}
_ => {}
@ -86,7 +92,7 @@ impl App {
Ok(())
}
pub fn handle_key_event(&mut self, key_event: KeyEvent) {
pub fn handle_key_event(&mut self, key_event: KeyEvent, event: crossterm::event::Event) {
match self.screen.last_mut().unwrap() {
CurrentScreen::Logging => match key_event.code {
KeyCode::Esc => self.pop(),
@ -96,8 +102,8 @@ impl App {
_ => {}
},
CurrentScreen::Receiving => match key_event.code {
KeyCode::Up => self.upload_state.select_previous(),
KeyCode::Down => self.upload_state.select_next(),
KeyCode::Up => self.receiving_state.select_previous(),
KeyCode::Down => self.receiving_state.select_next(),
KeyCode::Char('a') => self.accept(),
KeyCode::Char('d') => self.deny(),
KeyCode::Esc => self.pop(),
@ -110,7 +116,7 @@ impl App {
KeyCode::Char('q') => self.exit(),
KeyCode::Tab => *s = SendingScreen::Peers,
KeyCode::Enter => todo!("send the selected file or enter directory"),
_ => todo!("have the file picker handle it"),
_ => self.file_picker.handle(&event).unwrap_or_default(),
},
SendingScreen::Peers => match key_event.code {
KeyCode::Esc => self.pop(),
@ -132,7 +138,7 @@ impl App {
}
pub fn accept(&mut self) {
let Some(idx) = self.upload_state.selected() else {
let Some(idx) = self.receiving_state.selected() else {
return;
};
// keys are sorted, so we can use the table selection index
@ -150,7 +156,7 @@ impl App {
}
pub fn deny(&mut self) {
let Some(idx) = self.upload_state.selected() else {
let Some(idx) = self.receiving_state.selected() else {
return;
};
// keys are sorted, so we can use the table selection index

4
src/app/widgets.rs
View file

@ -126,7 +126,7 @@ impl Widget for &mut App {
NetworkInfoWidget.render(footer_left.inner(footer_margin), buf);
receive_requests(
&rx_reqs,
&mut self.upload_state,
&mut self.receiving_state,
header_left.inner(header_margin),
buf,
);
@ -140,7 +140,7 @@ impl Widget for &mut App {
outer_frame(*current_screen, &CONTENT_RECEIVE_MENU, area, buf);
receive_requests(
&rx_reqs,
&mut self.upload_state,
&mut self.receiving_state,
area.inner(subscreen_margin),
buf,
);

17
src/discovery.rs
View file

@ -14,18 +14,19 @@ use tokio::net::UdpSocket;
use crate::{Config, JoecalService, RunningState, models::Device};
impl JoecalService {
pub async fn announce(
&self,
socket: Option<SocketAddr>,
config: &Config,
) -> crate::error::Result<()> {
pub async fn announce(&self, socket: Option<SocketAddr>) -> crate::error::Result<()> {
trace!("announcing");
announce_http(&self.device, socket, self.client.clone()).await?;
announce_multicast(&self.device, config.multicast_addr, self.socket.clone()).await?;
announce_multicast(
&self.device,
self.config.multicast_addr,
self.socket.clone(),
)
.await?;
Ok(())
}
pub async fn listen_multicast(&self, config: &Config) -> crate::error::Result<()> {
pub async fn listen_multicast(&self) -> crate::error::Result<()> {
let mut buf = [0; 65536];
let mut timeout = tokio::time::interval(Duration::from_secs(5));
@ -48,7 +49,7 @@ impl JoecalService {
match r {
Ok((size, src)) => {
let received_msg = String::from_utf8_lossy(&buf[..size]);
self.process_device(&received_msg, src, config).await;
self.process_device(&received_msg, src, &self.config).await;
}
Err(e) => {
error!("Error receiving message: {e}");

26
src/http_server.rs
View file

@ -1,7 +1,7 @@
use std::net::SocketAddr;
use axum::{
Extension, Json, Router,
Json, Router,
extract::DefaultBodyLimit,
routing::{get, post},
};
@ -9,20 +9,16 @@ use tokio::{net::TcpListener, sync::mpsc};
use tower_http::limit::RequestBodyLimitLayer;
use crate::{
Config, JoecalService,
JoecalService,
discovery::register_device,
transfer::{register_prepare_upload, register_upload},
transfer::{prepare_upload, receive_upload},
};
impl JoecalService {
pub async fn start_http_server(
&self,
stop_rx: mpsc::Receiver<()>,
config: &Config,
) -> crate::error::Result<()> {
let app = self.create_router(config);
pub async fn start_http_server(&self, stop_rx: mpsc::Receiver<()>) -> crate::error::Result<()> {
let app = self.create_router();
// TODO: make addr config
let addr = SocketAddr::from(([0, 0, 0, 0], config.port));
let addr = SocketAddr::from(([0, 0, 0, 0], self.config.port));
let listener = TcpListener::bind(&addr).await?;
axum::serve(
@ -34,7 +30,7 @@ impl JoecalService {
Ok(())
}
fn create_router(&self, config: &Config) -> Router {
fn create_router(&self) -> Router {
let device = self.device.clone();
Router::new()
.route("/api/localsend/v2/register", post(register_device))
@ -42,14 +38,10 @@ impl JoecalService {
"/api/localsend/v2/info",
get(move || async move { Json(device) }),
)
.route(
"/api/localsend/v2/prepare-upload",
post(register_prepare_upload),
)
.route("/api/localsend/v2/upload", post(register_upload))
.route("/api/localsend/v2/prepare-upload", post(prepare_upload))
.route("/api/localsend/v2/upload", post(receive_upload))
.layer(DefaultBodyLimit::disable())
.layer(RequestBodyLimitLayer::new(1024 * 1024 * 1024))
.layer(Extension(config.download_dir.clone()))
.with_state(self.clone())
}
}

24
src/lib.rs
View file

@ -67,6 +67,7 @@ pub struct JoecalService {
pub running_state: Arc<Mutex<RunningState>>,
pub socket: Arc<UdpSocket>,
pub client: reqwest::Client,
pub config: Config,
shutdown_sender: OnceLock<ShutdownSender>,
// the receiving end will be held by the application so it can update the UI based on backend
// events
@ -76,6 +77,7 @@ pub struct JoecalService {
impl JoecalService {
pub async fn new(
device: Device,
config: Config,
transfer_event_tx: UnboundedSender<TransferEvent>,
) -> crate::error::Result<Self> {
let socket = UdpSocket::bind(LISTENING_SOCKET_ADDR).await?;
@ -85,6 +87,7 @@ impl JoecalService {
Ok(Self {
device,
config,
client: reqwest::Client::new(),
socket: socket.into(),
transfer_event_tx,
@ -95,40 +98,39 @@ impl JoecalService {
})
}
pub async fn start(&self, config: &Config, handles: &mut JoinSet<Listeners>) {
let state = self.clone();
let konfig = config.clone();
pub async fn start(&self, handles: &mut JoinSet<Listeners>) {
let service = self.clone();
handles.spawn({
let (tx, shutdown_rx) = mpsc::channel(1);
let _ = self.shutdown_sender.set(tx);
async move {
if let Err(e) = state.start_http_server(shutdown_rx, &konfig).await {
if let Err(e) = service.start_http_server(shutdown_rx).await {
error!("HTTP server error: {e}");
}
Listeners::Http
}
});
let state = self.clone();
let konfig = config.clone();
let service = self.clone();
handles.spawn({
async move {
if let Err(e) = state.listen_multicast(&konfig).await {
if let Err(e) = service.listen_multicast().await {
error!("UDP listener error: {e}");
}
Listeners::Multicast
}
});
let state = self.clone();
let config = config.clone();
let service = self.clone();
handles.spawn({
async move {
loop {
let rstate = state.running_state.lock().await;
let rstate = service.running_state.lock().await;
if *rstate == RunningState::Stopping {
break;
}
if let Err(e) = state.announce(None, &config).await {
if let Err(e) = service.announce(None).await {
error!("Announcement error: {e}");
}
tokio::time::sleep(std::time::Duration::from_secs(5)).await;

4
src/main.rs
View file

@ -35,14 +35,14 @@ async fn start_and_run(
) -> error::Result<()> {
let (event_tx, event_listener) = unbounded_channel();
let service = JoecalService::new(device, event_tx)
let service = JoecalService::new(device, config.clone(), event_tx)
.await
.expect("Could not create JoecalService");
let mut app = App::new(service, event_listener);
let mut handles = JoinSet::new();
app.service.start(&config, &mut handles).await;
app.service.start(&mut handles).await;
loop {
terminal.draw(|frame| app.draw(frame))?;
app.handle_events().await?;

11
src/transfer.rs
View file

@ -1,7 +1,7 @@
use std::{collections::HashMap, net::SocketAddr, path::PathBuf};
use axum::{
Extension, Json,
Json,
body::Bytes,
extract::{ConnectInfo, Query, State},
http::StatusCode,
@ -189,7 +189,7 @@ impl JoecalService {
}
}
pub async fn register_prepare_upload(
pub async fn prepare_upload(
State(service): State<JoecalService>,
ConnectInfo(addr): ConnectInfo<SocketAddr>,
Json(req): Json<PrepareUploadRequest>,
@ -259,10 +259,9 @@ pub async fn register_prepare_upload(
.into_response()
}
pub async fn register_upload(
pub async fn receive_upload(
Query(params): Query<UploadParams>,
State(service): State<JoecalService>,
Extension(download_dir): Extension<String>,
body: Bytes,
) -> impl IntoResponse {
// Extract query parameters
@ -298,8 +297,10 @@ pub async fn register_upload(
}
};
let download_dir = &service.config.download_dir;
// Create directory if it doesn't exist
if let Err(e) = tokio::fs::create_dir_all(&*download_dir).await {
if let Err(e) = tokio::fs::create_dir_all(download_dir).await {
return (
StatusCode::INTERNAL_SERVER_ERROR,
format!("Failed to create directory: {e}"),