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

add default duration

Browse source
This commit is contained in:
Joe Ardent 2025-08-13 17:48:55 -07:00
parent 471fc5d73c
commit 8791468c17
5 changed files with 66 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
src/app/mod.rs
View file

@ -7,7 +7,7 @@ use std::{
use crossterm::event::{Event, EventStream, KeyCode, KeyEvent, KeyEventKind};
use futures::{FutureExt, StreamExt};
use jocalsend::{JocalService, ReceiveDialog, ReceiveRequest, TransferEvent, error::Result};
use jocalsend::{JocalEvent, JocalService, ReceiveDialog, ReceiveRequest, error::Result};
use julid::Julid;
use log::{LevelFilter, debug, error, warn};
use ratatui::{
@ -54,7 +54,7 @@ pub struct App {
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>,
event_listener: UnboundedReceiver<JocalEvent>,
file_finder: FileFinder,
text: Option<String>,
input: Input,
@ -83,7 +83,7 @@ pub enum FileMode {
}
impl App {
pub fn new(service: JocalService, event_listener: UnboundedReceiver<TransferEvent>) -> Self {
pub fn new(service: JocalService, event_listener: UnboundedReceiver<JocalEvent>) -> Self {
App {
service,
event_listener,
@ -117,12 +117,15 @@ impl App {
if let Some(event) = transfer_event {
debug!("got transferr event {event:?}");
match event {
TransferEvent::ReceiveRequest { id, request } => {
JocalEvent::ReceiveRequest { id, request } => {
self.receive_requests.insert(id, request);
}
TransferEvent::Cancelled(id) | TransferEvent::Received(id) => {
JocalEvent::Cancelled(id) | JocalEvent::ReceivedInbound(id) => {
self.receive_requests.remove(&id);
}
JocalEvent::SendApproved(_id) => todo!(),
JocalEvent::SendDenied(_id) => todo!(),
JocalEvent::Tick => {}
}
}
}

6
src/discovery.rs
View file

@ -1,7 +1,6 @@
use std::{
net::{SocketAddr, SocketAddrV4},
sync::Arc,
time::Duration,
};
use axum::{
@ -11,7 +10,7 @@ use axum::{
use log::{debug, error, trace, warn};
use tokio::net::UdpSocket;
use crate::{Config, JocalService, RunningState, models::Device};
use crate::{Config, DEFAULT_INTERVAL, JocalService, RunningState, models::Device};
impl JocalService {
pub async fn announce(&self, socket: Option<SocketAddr>) -> crate::error::Result<()> {
@ -29,7 +28,7 @@ impl JocalService {
pub async fn listen_multicast(&self) -> crate::error::Result<()> {
let mut buf = [0; 65536];
let mut timeout = tokio::time::interval(Duration::from_secs(5));
let mut timeout = tokio::time::interval(DEFAULT_INTERVAL);
timeout.tick().await;
loop {
@ -45,7 +44,6 @@ impl JocalService {
}
},
r = self.socket.recv_from(&mut buf) => {
trace!("received multicast datagram");
match r {
Ok((size, src)) => {
let received_msg = String::from_utf8_lossy(&buf[..size]);

59
src/lib.rs
View file

@ -32,11 +32,14 @@ pub const MULTICAST_IP: Ipv4Addr = Ipv4Addr::new(224, 0, 0, 167);
pub const LISTENING_SOCKET_ADDR: SocketAddrV4 =
SocketAddrV4::new(Ipv4Addr::from_bits(0), DEFAULT_PORT);
pub const DEFAULT_INTERVAL: Duration = Duration::from_millis(200);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Listeners {
pub enum JocalTasks {
Udp,
Http,
Multicast,
Tick,
}
#[derive(Debug, Clone, PartialEq, Eq)]
@ -46,10 +49,13 @@ pub enum ReceiveDialog {
}
#[derive(Debug, Clone)]
pub enum TransferEvent {
Received(Julid),
pub enum JocalEvent {
ReceivedInbound(Julid),
SendApproved(Julid),
SendDenied(Julid),
Cancelled(Julid),
ReceiveRequest { id: Julid, request: ReceiveRequest },
Tick,
}
#[derive(Clone)]
@ -80,13 +86,13 @@ pub struct JocalService {
http_handle: OnceLock<axum_server::Handle>,
// the receiving end will be held by the application so it can update the UI based on backend
// events
transfer_event_tx: UnboundedSender<TransferEvent>,
transfer_event_tx: UnboundedSender<JocalEvent>,
}
impl JocalService {
pub async fn new(
config: Config,
) -> crate::error::Result<(Self, UnboundedReceiver<TransferEvent>)> {
) -> crate::error::Result<(Self, UnboundedReceiver<JocalEvent>)> {
let (tx, rx) = mpsc::unbounded_channel();
let socket = UdpSocket::bind(LISTENING_SOCKET_ADDR).await?;
socket.set_multicast_loop_v4(true)?;
@ -113,31 +119,45 @@ impl JocalService {
))
}
pub async fn start(&self, handles: &mut JoinSet<Listeners>) {
pub async fn start(&self, handles: &mut JoinSet<JocalTasks>) {
let service = self.clone();
handles.spawn({
async move {
handles.spawn(async move {
if let Err(e) = service.start_http_server().await {
error!("HTTP server error: {e}");
}
Listeners::Http
}
JocalTasks::Http
});
let service = self.clone();
handles.spawn({
async move {
handles.spawn(async move {
if let Err(e) = service.listen_multicast().await {
error!("UDP listener error: {e}");
}
Listeners::Multicast
}
JocalTasks::Multicast
});
let service = self.clone();
handles.spawn({
async move {
handles.spawn(async move {
let service = &service;
let mut tick = tokio::time::interval(DEFAULT_INTERVAL);
loop {
let rstate = service.running_state.lock().await;
if *rstate == RunningState::Stopping {
break;
}
tick.tick().await;
service
.transfer_event_tx
.send(JocalEvent::Tick)
.unwrap_or_else(|e| log::warn!("could not send tick event: {e:?}"));
}
JocalTasks::Tick
});
let service = self.clone();
handles.spawn(async move {
loop {
let rstate = service.running_state.lock().await;
if *rstate == RunningState::Stopping {
@ -146,10 +166,9 @@ impl JocalService {
if let Err(e) = service.announce(None).await {
error!("Announcement error: {e}");
}
tokio::time::sleep(Duration::from_secs(5)).await;
}
Listeners::Udp
tokio::time::sleep(Duration::from_secs(2)).await;
}
JocalTasks::Udp
});
}
@ -168,7 +187,7 @@ impl JocalService {
peers.clear();
}
pub fn send_event(&self, event: TransferEvent) {
pub fn send_event(&self, event: JocalEvent) {
if let Err(e) = self.transfer_event_tx.send(event.clone()) {
error!("got error sending transfer event '{event:?}': {e:?}");
}

4
src/main.rs
View file

@ -1,7 +1,7 @@
use std::{path::Path, str::FromStr, time::Duration};
use clap::Parser;
use jocalsend::{Config, JocalService, Listeners, error::Result};
use jocalsend::{Config, JocalService, JocalTasks, error::Result};
use log::{error, info};
use ratatui::DefaultTerminal;
use ratatui_explorer::FileExplorer;
@ -105,7 +105,7 @@ async fn start_and_run(terminal: &mut DefaultTerminal, config: Config) -> Result
Ok(())
}
async fn shutdown(handles: &mut JoinSet<Listeners>) {
async fn shutdown(handles: &mut JoinSet<JocalTasks>) {
let mut timeout = tokio::time::interval(Duration::from_secs(5));
timeout.tick().await;
loop {

8
src/transfer.rs
View file

@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize};
use tokio::sync::mpsc::unbounded_channel;
use crate::{
JocalService, ReceiveDialog, ReceiveRequest, TransferEvent,
JocalEvent, JocalService, ReceiveDialog, ReceiveRequest,
error::{LocalSendError, Result},
models::{Device, FileMetadata},
};
@ -239,7 +239,7 @@ pub async fn handle_prepare_upload(
match service
.transfer_event_tx
.send(TransferEvent::ReceiveRequest { id, request })
.send(JocalEvent::ReceiveRequest { id, request })
{
Ok(_) => {}
Err(e) => {
@ -354,7 +354,7 @@ pub async fn handle_receive_upload(
}
if let Ok(id) = Julid::from_str(session_id) {
service.send_event(TransferEvent::Received(id));
service.send_event(JocalEvent::ReceivedInbound(id));
};
StatusCode::OK.into_response()
@ -384,7 +384,7 @@ pub async fn handle_cancel(
session.status = SessionStatus::Cancelled;
if let Ok(id) = Julid::from_str(&params.session_id) {
service.send_event(TransferEvent::Cancelled(id));
service.send_event(JocalEvent::Cancelled(id));
};
StatusCode::OK.into_response()