blub

2 files changed, 51 insertions, 65 deletions

diff --git a/src/interface.rs b/src/interface.rs
index 0020736..fcdb470 100644
--- a/src/interface.rs
+++ b/src/interface.rs
@@ -1,24 +1,22 @@
+use super::protocol::{ClientboundPacket, ServerboundPacket};
+use crate::handle_packet;
+use log::{debug, error, info, warn};
 use std::io;
 use std::io::{BufRead, BufReader, ErrorKind, Write};
 use std::os::unix::net::{UnixListener, UnixStream};
 use std::thread;
 
-use super::protocol::{ClientboundPacket, ServerboundPacket};
-use crossbeam_channel::Sender;
-use log::{debug, error, info, warn};
-
-pub fn network_loop(s: Sender<(u32, ServerboundPacket, Sender<ClientboundPacket>)>) {
+pub fn network_loop() {
     let listener = UnixListener::bind("/run/user/1000/calendar").unwrap();
     let mut id_counter = 0;
 
     loop {
         let (stream, addr) = listener.accept().unwrap();
-        let s = s.clone();
         let id = id_counter;
         id_counter += 1;
         thread::spawn(move || {
             info!("client connected: {:?}", addr);
-            if let Err(err) = handle_connection(id, stream.try_clone().unwrap(), s.clone()) {
+            if let Err(err) = handle_connection(id, stream.try_clone().unwrap()) {
                 warn!("client dropped: {:?} ({})", addr, err);
             } else {
                 info!("client dropped: {:?}", addr);
@@ -27,11 +25,7 @@ pub fn network_loop(s: Sender<(u32, ServerboundPacket, Sender<ClientboundPacket>
     }
 }
 
-fn handle_connection(
-    id: u32,
-    mut stream: UnixStream,
-    s: Sender<(u32, ServerboundPacket, Sender<ClientboundPacket>)>,
-) -> io::Result<()> {
+fn handle_connection(id: u32, mut stream: UnixStream) -> io::Result<()> {
     let mut reader = BufReader::new(stream.try_clone()?);
     let (responder, responses) = crossbeam_channel::unbounded();
     responder
@@ -52,22 +46,23 @@ fn handle_connection(
             }
         }
     });
-    let mut buf = String::new();
-    loop {
-        if reader.read_line(&mut buf)? == 0 {
-            break Ok(());
-        };
-        match serde_json::from_str::<ServerboundPacket>(buf.as_str()) {
-            Ok(packet) => {
-                debug!("{id} <- {packet:?}");
-                s.send((id, packet, responder.clone()))
-                    .map_err(|_| io::Error::from(ErrorKind::InvalidInput))?;
+    {
+        let mut buf = String::new();
+        loop {
+            if reader.read_line(&mut buf)? == 0 {
+                break Ok(());
+            };
+            match serde_json::from_str::<ServerboundPacket>(buf.as_str()) {
+                Ok(packet) => {
+                    debug!("{id} <- {packet:?}");
+                    handle_packet(id, packet, responder.clone());
+                }
+                Err(err) => responder
+                    .send(ClientboundPacket::Error(format!("{}", &err)))
+                    .map_err(|_| io::Error::from(ErrorKind::InvalidInput))?,
             }
-            Err(err) => responder
-                .send(ClientboundPacket::Error(format!("{}", &err)))
-                .map_err(|_| io::Error::from(ErrorKind::InvalidInput))?,
-        }
 
-        buf.clear();
+            buf.clear();
+        }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index e447202..9a84286 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,52 +2,43 @@ pub mod condition;
 pub mod interface;
 pub mod protocol;
 
-use crossbeam_channel::{Receiver, Sender};
-use interface::network_loop;
-use protocol::{ClientboundPacket, ServerboundPacket};
-use std::time::Duration;
-
 use crate::{
     condition::{Condition, Property},
     protocol::Task,
 };
+use crossbeam_channel::Sender;
+use interface::network_loop;
+use protocol::{ClientboundPacket, ServerboundPacket};
 
 fn main() {
-    let (s, r) = crossbeam_channel::unbounded();
-    std::thread::spawn(move || network_loop(s));
-    main_loop(r)
+    network_loop();
 }
 
-fn main_loop(packets: Receiver<(u32, ServerboundPacket, Sender<ClientboundPacket>)>) {
-    loop {
-        for (client_id, packet, responder) in packets.try_iter() {
-            println!("{:?}, {:?}, {:?}", client_id, packet, responder);
-            match packet {
-                ServerboundPacket::Download => {
-                    let _ = responder.send(ClientboundPacket::DownloadResponse(vec![Task {
-                        name: "blub".to_string(),
-                        description: "blob".to_string(),
-                        tags: vec![],
-                        priority: 69.0,
-                        completed: None,
-                        scheduled: None,
-                        occurence: Some(Condition::And(vec![
-                            Condition::Equal {
-                                modulus: None,
-                                prop: Property::Monthofyear,
-                                value: 1,
-                            },
-                            Condition::Equal {
-                                modulus: None,
-                                prop: Property::Hour,
-                                value: 12,
-                            },
-                        ])),
-                        deadline: None,
-                    }]));
-                }
-            }
+pub fn handle_packet(client: u32, packet: ServerboundPacket, responder: Sender<ClientboundPacket>) {
+    println!("{:?}, {:?}, {:?}", client, packet, responder);
+    match packet {
+        ServerboundPacket::Download => {
+            let _ = responder.send(ClientboundPacket::DownloadResponse(vec![Task {
+                name: "blub".to_string(),
+                description: "blob".to_string(),
+                tags: vec![],
+                priority: 69.0,
+                completed: None,
+                scheduled: None,
+                occurence: Some(Condition::And(vec![
+                    Condition::Equal {
+                        modulus: None,
+                        prop: Property::Monthofyear,
+                        value: 1,
+                    },
+                    Condition::Equal {
+                        modulus: None,
+                        prop: Property::Hour,
+                        value: 12,
+                    },
+                ])),
+                deadline: None,
+            }]));
         }
-        std::thread::sleep(Duration::from_secs_f64(10.0 / 30.0));
     }
 }