muzzman_daemon/
daemon.rs

1use std::{
2    net::{SocketAddr, UdpSocket},
3    sync::{Arc, Mutex},
4    time::{Duration, SystemTime},
5};
6
7const CLIENT_TIMEOUT: Duration = Duration::new(3, 0);
8
9use crate::{
10    packets::{ClientPackets, ServerPackets},
11    row::{IntoRawSock, RawSock},
12    DAEMON_PORT,
13};
14use bytes_kman::TBytes;
15use muzzman_lib::{
16    prelude::{TElement, TLocation, TModuleInfo},
17    session::TSession,
18};
19use polling::Poller;
20
21pub struct DaemonInner {
22    socket: UdpSocket,
23    clients: Vec<(SystemTime, SocketAddr)>,
24    buffer: [u8; 4096],
25}
26
27pub struct Daemon {
28    session: Box<dyn TSession>,
29    socket_fd: RawSock,
30    poller: Poller,
31    inner: Arc<Mutex<DaemonInner>>,
32}
33
34unsafe impl Sync for Daemon {}
35unsafe impl Send for Daemon {}
36
37impl Daemon {
38    pub fn new() -> Result<Self, std::io::Error> {
39        let socket = UdpSocket::bind(format!("127.0.0.1:{DAEMON_PORT}")).unwrap();
40        socket.set_nonblocking(true).unwrap();
41
42        let socket_clone = socket.try_clone().unwrap();
43        let socket_fd = socket.into_raw();
44        let socket = socket_clone;
45
46        let poller = Poller::new()?;
47        poller.add(
48            socket_fd,
49            polling::Event {
50                key: 0,
51                readable: true,
52                writable: false,
53            },
54        )?;
55        let socket = socket;
56        let mut session = muzzman_lib::LocalSession::default();
57
58        let inner = Arc::new(Mutex::new(DaemonInner {
59            socket,
60            clients: Vec::new(),
61            buffer: [0; 4096],
62        }));
63
64        let inner_clone = inner.clone();
65        session.callback = Some(Box::new(move |event| {
66            let clients = inner_clone.clients();
67            for client in clients {
68                inner_clone.send(ClientPackets::NewSessionEvent(event.clone()), &client);
69            }
70        }));
71        let session = session.new_session();
72        let default_location = session.get_default_location().unwrap();
73        default_location
74            .set_path(dirs::home_dir().unwrap().join("Downloads"))
75            .unwrap();
76
77        Ok(Self {
78            session,
79            inner,
80            poller,
81            socket_fd,
82        })
83    }
84
85    pub fn run(mut self) {
86        let mut events = Vec::new();
87        events.push(polling::Event {
88            key: 0,
89            readable: false,
90            writable: false,
91        });
92        loop {
93            self.poller.wait(&mut events, None).unwrap();
94            for event in events.iter() {
95                if event.key == 0 {
96                    self.poller
97                        .modify(
98                            self.socket_fd,
99                            polling::Event {
100                                key: 0,
101                                readable: true,
102                                writable: false,
103                            },
104                        )
105                        .unwrap();
106                    self.respond_to_requests();
107                }
108            }
109        }
110    }
111
112    fn respond_to_requests(&mut self) {
113        let Some((addr, packets)) = self.inner.recv() else{
114                return
115            };
116        for packet in packets {
117            match packet {
118                ServerPackets::GetDefaultLocation { id } => {
119                    let packet = match self.session.get_default_location() {
120                        Ok(ok) => ClientPackets::GetDefaultLocation(id, Ok(ok.id())),
121                        Err(err) => ClientPackets::GetDefaultLocation(id, Err(err)),
122                    };
123                    self.inner.send(packet, &addr);
124                }
125                ServerPackets::LocationGetName { id, from } => {
126                    let packet =
127                        ClientPackets::LocationGetName(id, self.session.location_get_name(&from));
128                    self.inner.send(packet, &addr);
129                }
130                ServerPackets::LocationSetName { id, from, to } => {
131                    let packet = ClientPackets::LocationSetName(
132                        id,
133                        self.session.location_set_name(&from, &to),
134                    );
135                    self.inner.send(packet, &addr)
136                }
137                ServerPackets::LocationGetDesc { id, from } => {
138                    let packet =
139                        ClientPackets::LocationGetDesc(id, self.session.location_get_desc(&from));
140
141                    self.inner.send(packet, &addr)
142                }
143                ServerPackets::LocationSetDesc { id, from, to } => {
144                    let packet = ClientPackets::LocationSetDesc(
145                        id,
146                        self.session.location_set_desc(&from, &to),
147                    );
148                    self.inner.send(packet, &addr)
149                }
150                ServerPackets::LocationGetInfo { id, from } => {
151                    let packet = ClientPackets::LocationGetInfo(
152                        id,
153                        self.session.location_get_location_info(&from),
154                    );
155                    self.inner.send(packet, &addr)
156                }
157                ServerPackets::CreateElement {
158                    id,
159                    location_id,
160                    name,
161                } => {
162                    let packet = match self.session.create_element(&name, &location_id) {
163                        Ok(ok) => ClientPackets::CreateElement(id, Ok(ok.id())),
164                        Err(err) => ClientPackets::CreateElement(id, Err(err)),
165                    };
166                    self.inner.send(packet, &addr)
167                }
168                ServerPackets::ElementGetName { id, element_id } => {
169                    let packet = ClientPackets::ElementGetName(
170                        id,
171                        self.session.element_get_name(&element_id),
172                    );
173                    self.inner.send(packet, &addr);
174                }
175                ServerPackets::ElementSetName { id, element_id, to } => {
176                    let packet = ClientPackets::ElementSetName(
177                        id,
178                        self.session.element_set_name(&element_id, &to),
179                    );
180                    self.inner.send(packet, &addr);
181                }
182                ServerPackets::ElementGetDesc { id, element_id } => {
183                    let packet = ClientPackets::ElementGetDesc(
184                        id,
185                        self.session.element_get_desc(&element_id),
186                    );
187                    self.inner.send(packet, &addr);
188                }
189                ServerPackets::ElementSetDesc { id, element_id, to } => {
190                    let packet = ClientPackets::ElementSetDesc(
191                        id,
192                        self.session.element_set_desc(&element_id, &to),
193                    );
194                    self.inner.send(packet, &addr);
195                }
196                ServerPackets::ElementGetMeta { id, element_id } => {
197                    let packet = ClientPackets::ElementGetMeta(
198                        id,
199                        self.session.element_get_meta(&element_id),
200                    );
201                    self.inner.send(packet, &addr);
202                }
203                ServerPackets::ElementSetMeta { id, element_id, to } => {
204                    let packet = ClientPackets::ElementSetMeta(
205                        id,
206                        self.session.element_set_meta(&element_id, &to),
207                    );
208                    self.inner.send(packet, &addr);
209                }
210                ServerPackets::ElementGetInfo { id, element_id } => {
211                    let packet = ClientPackets::ElementGetInfo(
212                        id,
213                        Box::new(self.session.element_get_element_info(&element_id)),
214                    );
215                    self.inner.send(packet, &addr);
216                }
217                ServerPackets::LoadModule { id, path } => {
218                    let packet = ClientPackets::LoadModule(
219                        id,
220                        match self.session.load_module(path) {
221                            Ok(ok) => Ok(ok.id()),
222                            Err(err) => Err(err),
223                        },
224                    );
225                    self.inner.send(packet, &addr);
226                }
227                ServerPackets::RemoveModule { id, module_id } => {
228                    let packet = ClientPackets::RemoveModule(
229                        id,
230                        match self.session.remove_module(module_id) {
231                            Ok(_) => Ok(()),
232                            Err(err) => Err(err),
233                        },
234                    );
235                    self.inner.send(packet, &addr);
236                }
237                ServerPackets::GetActionsLen { id } => {
238                    let packet = ClientPackets::GetActionsLen(id, self.session.get_actions_len());
239                    self.inner.send(packet, &addr);
240                }
241                ServerPackets::GetActions { id, range } => {
242                    let packet = ClientPackets::GetActions(
243                        id,
244                        match self.session.get_actions(range) {
245                            Ok(ok) => {
246                                let mut tmp = Vec::new();
247                                for k in ok {
248                                    tmp.push((k.0, k.1.id(), k.2));
249                                }
250                                Ok(tmp)
251                            }
252                            Err(err) => Err(err),
253                        },
254                    );
255                    self.inner.send(packet, &addr);
256                }
257                ServerPackets::RunAction {
258                    id,
259                    module_id,
260                    name,
261                    data,
262                } => {
263                    let packet = ClientPackets::RunAction(
264                        id,
265                        self.session.run_action(&module_id, name, data),
266                    );
267                    self.inner.send(packet, &addr);
268                }
269                ServerPackets::GetModulesLen { id } => {
270                    let packet = ClientPackets::GetModulesLen(id, self.session.get_modules_len());
271                    self.inner.send(packet, &addr);
272                }
273                ServerPackets::GetModules { id, range } => {
274                    let packet = ClientPackets::GetModules(
275                        id,
276                        match self.session.get_modules(range) {
277                            Ok(ok) => {
278                                let mut tmp = Vec::with_capacity(ok.len());
279                                for k in ok {
280                                    tmp.push(k.id())
281                                }
282                                Ok(tmp)
283                            }
284                            Err(err) => Err(err),
285                        },
286                    );
287                    self.inner.send(packet, &addr);
288                }
289                ServerPackets::ModuleGetName { id, module_id } => {
290                    let packet =
291                        ClientPackets::ModuleGetName(id, self.session.module_get_name(&module_id));
292                    self.inner.send(packet, &addr)
293                }
294                ServerPackets::ModuleSetName { id, module_id, to } => {
295                    let packet = ClientPackets::ModuleSetName(
296                        id,
297                        self.session.module_set_name(&module_id, to),
298                    );
299                    self.inner.send(packet, &addr);
300                }
301                ServerPackets::ModuleGetDefaultName { id, module_id } => {
302                    let packet = ClientPackets::ModuleGetDefaultName(
303                        id,
304                        self.session.module_get_default_name(&module_id),
305                    );
306                    self.inner.send(packet, &addr)
307                }
308                ServerPackets::ModuleGetDesc { id, module_id } => {
309                    let packet =
310                        ClientPackets::ModuleGetDesc(id, self.session.module_get_desc(&module_id));
311                    self.inner.send(packet, &addr)
312                }
313                ServerPackets::ModuleSetDesc { id, module_id, to } => {
314                    let packet = ClientPackets::ModuleSetDesc(
315                        id,
316                        self.session.module_set_desc(&module_id, to),
317                    );
318                    self.inner.send(packet, &addr);
319                }
320                ServerPackets::ModuleGetDefaultDesc { id, module_id } => {
321                    let packet = ClientPackets::ModuleGetDefaultDesc(
322                        id,
323                        self.session.module_get_default_desc(&module_id),
324                    );
325                    self.inner.send(packet, &addr)
326                }
327                ServerPackets::ModuleGetProxy { id, module_id } => {
328                    let packet = ClientPackets::ModuleGetProxy(
329                        id,
330                        self.session.module_get_proxy(&module_id),
331                    );
332                    self.inner.send(packet, &addr)
333                }
334                ServerPackets::ModuleSetProxy { id, module_id, to } => {
335                    let packet = ClientPackets::ModuleSetProxy(
336                        id,
337                        self.session.module_set_proxy(&module_id, to),
338                    );
339                    self.inner.send(packet, &addr)
340                }
341                ServerPackets::ModuleGetSettings { id, module_id } => {
342                    let packet = ClientPackets::ModuleGetSettings(
343                        id,
344                        Box::new(self.session.module_get_settings(&module_id)),
345                    );
346                    self.inner.send(packet, &addr)
347                }
348                ServerPackets::ModuleSetSettings { id, module_id, to } => {
349                    let packet = ClientPackets::ModuleSetSettings(
350                        id,
351                        self.session.module_set_settings(&module_id, to),
352                    );
353                    self.inner.send(packet, &addr)
354                }
355                ServerPackets::ModuleGetElementSettings { id, module_id } => {
356                    let packet = ClientPackets::ModuleGetElementSettings(
357                        id,
358                        self.session.module_get_element_settings(&module_id),
359                    );
360                    self.inner.send(packet, &addr);
361                }
362                ServerPackets::ModuleSetElementSettings { id, module_id, to } => {
363                    let packet = ClientPackets::ModuleSetElementSettings(
364                        id,
365                        self.session.module_set_element_settings(&module_id, to),
366                    );
367                    self.inner.send(packet, &addr)
368                }
369                ServerPackets::ModuleInitLocation {
370                    id,
371                    module_id,
372                    location_id,
373                    data,
374                } => {
375                    let packet = ClientPackets::ModuleInitLocation(
376                        id,
377                        self.session
378                            .module_init_location(&module_id, &location_id, data),
379                    );
380                    self.inner.send(packet, &addr)
381                }
382                ServerPackets::ModuleInitElement {
383                    id,
384                    module_id,
385                    element_id,
386                } => {
387                    let packet = ClientPackets::ModuleInitElement(
388                        id,
389                        self.session.module_init_element(&module_id, &element_id),
390                    );
391                    self.inner.send(packet, &addr)
392                }
393                ServerPackets::ModuleAcceptUrl { id, module_id, url } => {
394                    // TODO: Error handlering for url
395                    let packet = ClientPackets::ModuleAcceptUrl(
396                        id,
397                        self.session.module_accept_url(&module_id, url),
398                    );
399                    self.inner.send(packet, &addr)
400                }
401                ServerPackets::ModuleAcceptExtension {
402                    id,
403                    module_id,
404                    filename,
405                } => {
406                    let packet = ClientPackets::ModuleAcceptExtension(
407                        id,
408                        self.session.module_accept_extension(&module_id, &filename),
409                    );
410                    self.inner.send(packet, &addr);
411                }
412                ServerPackets::MoveElement {
413                    id,
414                    element_id,
415                    location_id,
416                } => {
417                    let packet = ClientPackets::MoveElement(
418                        id,
419                        self.session.move_element(&element_id, &location_id),
420                    );
421                    self.inner.send(packet, &addr)
422                }
423                ServerPackets::DestroyElement { id, element_id } => {
424                    let packet = ClientPackets::DestroyElement(
425                        id,
426                        match self.session.destroy_element(element_id) {
427                            Ok(_) => Ok(()),
428                            Err(err) => Err(err),
429                        },
430                    );
431                    self.inner.send(packet, &addr)
432                }
433                ServerPackets::ElementGetElementData { id, element_id } => {
434                    let packet = ClientPackets::ElementGetElementData(
435                        id,
436                        self.session.element_get_element_data(&element_id),
437                    );
438                    self.inner.send(packet, &addr)
439                }
440                ServerPackets::ElementSetElementData { id, element_id, to } => {
441                    let packet = ClientPackets::ElementSetElementData(
442                        id,
443                        self.session.element_set_element_data(&element_id, to),
444                    );
445                    self.inner.send(packet, &addr)
446                }
447                ServerPackets::ElementGetModuleData { id, element_id } => {
448                    let packet = ClientPackets::ElementGetModuleData(
449                        id,
450                        self.session.element_get_module_data(&element_id),
451                    );
452                    self.inner.send(packet, &addr)
453                }
454                ServerPackets::ElementSetModuleData { id, element_id, to } => {
455                    let packet = ClientPackets::ElementSetModuleData(
456                        id,
457                        self.session.element_set_module_data(&element_id, to),
458                    );
459                    self.inner.send(packet, &addr)
460                }
461                ServerPackets::ElementGetModule { id, element_id } => {
462                    let packet = ClientPackets::ElementGetModule(
463                        id,
464                        match self.session.element_get_module(&element_id) {
465                            Ok(ok) => match ok {
466                                Some(some) => Ok(Some(some.id())),
467                                None => Ok(None),
468                            },
469                            Err(err) => Err(err),
470                        },
471                    );
472                    self.inner.send(packet, &addr)
473                }
474                ServerPackets::ElementSetModule {
475                    id,
476                    element_id,
477                    module,
478                } => {
479                    let packet = ClientPackets::ElementSetModule(
480                        id,
481                        self.session.element_set_module(&element_id, module),
482                    );
483                    self.inner.send(packet, &addr)
484                }
485                ServerPackets::ElementGetStatuses { id, element_id } => {
486                    let packet = ClientPackets::ElementGetStatuses(
487                        id,
488                        self.session.element_get_statuses(&element_id),
489                    );
490                    self.inner.send(packet, &addr)
491                }
492                ServerPackets::ElementSetStatuses { id, element_id, to } => {
493                    let packet = ClientPackets::ElementSetStatuses(
494                        id,
495                        self.session.element_set_statuses(&element_id, to),
496                    );
497                    self.inner.send(packet, &addr)
498                }
499                ServerPackets::ElementGetStatus { id, element_id } => {
500                    let packet = ClientPackets::ElementGetStatus(
501                        id,
502                        self.session.element_get_status(&element_id),
503                    );
504                    self.inner.send(packet, &addr)
505                }
506                ServerPackets::ElementSetStatus { id, element_id, to } => {
507                    let packet = ClientPackets::ElementSetStatus(
508                        id,
509                        self.session.element_set_status(&element_id, to),
510                    );
511                    self.inner.send(packet, &addr)
512                }
513                ServerPackets::ElementGetData { id, element_id } => {
514                    let packet = ClientPackets::ElementGetData(
515                        id,
516                        self.session.element_get_data(&element_id),
517                    );
518                    self.inner.send(packet, &addr)
519                }
520                ServerPackets::ElementSetData { id, element_id, to } => {
521                    let packet = ClientPackets::ElementSetData(
522                        id,
523                        self.session.element_set_data(&element_id, to),
524                    );
525                    self.inner.send(packet, &addr)
526                }
527                ServerPackets::ElementGetProgress { id, element_id } => {
528                    let packet = ClientPackets::ElementGetProgress(
529                        id,
530                        self.session.element_get_progress(&element_id),
531                    );
532                    self.inner.send(packet, &addr)
533                }
534                ServerPackets::ElementSetProgress { id, element_id, to } => {
535                    let packet = ClientPackets::ElementSetProgress(
536                        id,
537                        self.session.element_set_progress(&element_id, to),
538                    );
539                    self.inner.send(packet, &addr)
540                }
541                ServerPackets::ElementGetShouldSave { id, element_id } => {
542                    let packet = ClientPackets::ElementGetShouldSave(
543                        id,
544                        self.session.element_get_should_save(&element_id),
545                    );
546                    self.inner.send(packet, &addr)
547                }
548                ServerPackets::ElementSetShouldSave { id, element_id, to } => {
549                    let packet = ClientPackets::ElementSetShouldSave(
550                        id,
551                        self.session.element_set_should_save(&element_id, to),
552                    );
553                    self.inner.send(packet, &addr)
554                }
555                ServerPackets::ElementGetEnabled { id, element_id } => {
556                    let packet = ClientPackets::ElementGetEnabled(
557                        id,
558                        self.session.element_get_enabled(&element_id),
559                    );
560                    self.inner.send(packet, &addr)
561                }
562                ServerPackets::ElementSetEnabled { id, element_id, to } => {
563                    let packet = ClientPackets::ElementSetEnabled(
564                        id,
565                        self.session.element_set_enabled(&element_id, to, None),
566                    );
567                    self.inner.send(packet, &addr)
568                }
569                ServerPackets::ElementResolvModule { id, element_id } => {
570                    let packet = ClientPackets::ElementResolvModule(
571                        id,
572                        self.session.element_resolv_module(&element_id),
573                    );
574                    self.inner.send(packet, &addr)
575                }
576                ServerPackets::ElementWait { id, element_id } => {
577                    // TODO: Implement this better
578                    // This will block the daemon until the element is done
579                    // This is really bad because any request from other sessions will be ignored
580                    // and result into timeout
581                    // this is here because i'am lazy to makeit better with some event handler
582                    // if some one want to fix this go end do it
583                    //
584                    // Problem from 1/29/2023
585                    let packet =
586                        ClientPackets::ElementWait(id, self.session.element_wait(&element_id));
587                    self.inner.send(packet, &addr)
588                }
589                ServerPackets::ElementNotify {
590                    id,
591                    element_id,
592                    event,
593                } => {
594                    let packet = ClientPackets::ElementNotify(
595                        id,
596                        self.session.element_notify(&element_id, event),
597                    );
598                    self.inner.send(packet, &addr)
599                }
600                ServerPackets::ElementEmit {
601                    id,
602                    element_id,
603                    event,
604                } => {
605                    let packet = ClientPackets::ElementEmit(
606                        id,
607                        self.session.element_emit(&element_id, event),
608                    );
609                    self.inner.send(packet, &addr)
610                }
611                ServerPackets::ElementSubscribe { id, element_id, to } => {
612                    let packet = ClientPackets::ElementSubscribe(
613                        id,
614                        self.session.element_subscribe(&element_id, to),
615                    );
616                    self.inner.send(packet, &addr)
617                }
618                ServerPackets::ElementUnSubscribe { id, element_id, to } => {
619                    let packet = ClientPackets::ElementUnSubscribe(
620                        id,
621                        self.session.element_unsubscribe(&element_id, to),
622                    );
623                    self.inner.send(packet, &addr)
624                }
625                ServerPackets::CreateLocation {
626                    id,
627                    name,
628                    location_id,
629                } => {
630                    let packet = ClientPackets::CreateLocation(
631                        id,
632                        match self.session.create_location(&name, &location_id) {
633                            Ok(ok) => Ok(ok.id()),
634                            Err(err) => Err(err),
635                        },
636                    );
637                    self.inner.send(packet, &addr)
638                }
639                ServerPackets::GetLocationsLen { id, location_id } => {
640                    let packet = ClientPackets::GetLocationsLen(
641                        id,
642                        self.session.get_locations_len(&location_id),
643                    );
644                    self.inner.send(packet, &addr)
645                }
646                ServerPackets::GetLocations {
647                    id,
648                    location_id,
649                    range,
650                } => {
651                    let packet = ClientPackets::GetLocations(
652                        id,
653                        match self.session.get_locations(&location_id, range) {
654                            Ok(ok) => {
655                                let mut tmp = Vec::with_capacity(ok.len());
656
657                                for k in ok {
658                                    tmp.push(k.id())
659                                }
660
661                                Ok(tmp)
662                            }
663                            Err(err) => Err(err),
664                        },
665                    );
666                    self.inner.send(packet, &addr)
667                }
668                ServerPackets::DestroyLocation { id, location_id } => {
669                    let packet = ClientPackets::DestroyLocation(
670                        id,
671                        match self.session.destroy_location(location_id) {
672                            Ok(_) => Ok(()),
673                            Err(err) => Err(err),
674                        },
675                    );
676                    self.inner.send(packet, &addr)
677                }
678                ServerPackets::MoveLocation {
679                    id,
680                    location_id,
681                    to,
682                } => {
683                    let packet = ClientPackets::MoveLocation(
684                        id,
685                        self.session.move_location(&location_id, &to),
686                    );
687                    self.inner.send(packet, &addr)
688                }
689                ServerPackets::LocationGetPath { id, location_id } => {
690                    let packet = ClientPackets::LocationGetPath(
691                        id,
692                        self.session.location_get_path(&location_id),
693                    );
694                    self.inner.send(packet, &addr)
695                }
696                ServerPackets::LocationSetPath {
697                    id,
698                    location_id,
699                    to,
700                } => {
701                    let packet = ClientPackets::LocationSetPath(
702                        id,
703                        self.session.location_set_path(&location_id, to),
704                    );
705                    self.inner.send(packet, &addr)
706                }
707                ServerPackets::LocationGetShouldSave { id, location_id } => {
708                    let packet = ClientPackets::LocationGetShouldSave(
709                        id,
710                        self.session.location_get_should_save(&location_id),
711                    );
712                    self.inner.send(packet, &addr)
713                }
714                ServerPackets::LocationSetShouldSave {
715                    id,
716                    location_id,
717                    to,
718                } => {
719                    let packet = ClientPackets::LocationSetShouldSave(
720                        id,
721                        self.session.location_set_should_save(&location_id, to),
722                    );
723                    self.inner.send(packet, &addr)
724                }
725                ServerPackets::LocationGetElementsLen { id, location_id } => {
726                    let packet = ClientPackets::LocationGetElementsLen(
727                        id,
728                        self.session.location_get_elements_len(&location_id),
729                    );
730                    self.inner.send(packet, &addr)
731                }
732                ServerPackets::LocationGetElements {
733                    id,
734                    location_id,
735                    range,
736                } => {
737                    let packet = ClientPackets::LocationGetElements(
738                        id,
739                        match self.session.location_get_elements(&location_id, range) {
740                            Ok(ok) => {
741                                let mut tmp = Vec::with_capacity(ok.len());
742
743                                for k in ok {
744                                    tmp.push(k.id())
745                                }
746
747                                Ok(tmp)
748                            }
749                            Err(err) => Err(err),
750                        },
751                    );
752                    self.inner.send(packet, &addr)
753                }
754                ServerPackets::LocationNotify {
755                    id,
756                    location_id,
757                    event,
758                } => {
759                    let packet = ClientPackets::LocationNotify(
760                        id,
761                        self.session.location_notify(&location_id, event),
762                    );
763                    self.inner.send(packet, &addr)
764                }
765                ServerPackets::LocationEmit {
766                    id,
767                    location_id,
768                    event,
769                } => {
770                    let packet = ClientPackets::LocationEmit(
771                        id,
772                        self.session.location_emit(&location_id, event),
773                    );
774                    self.inner.send(packet, &addr)
775                }
776                ServerPackets::LocationSubscribe {
777                    id,
778                    location_id,
779                    to,
780                } => {
781                    let packet = ClientPackets::LocationSubscribe(
782                        id,
783                        self.session.location_subscribe(&location_id, to),
784                    );
785                    self.inner.send(packet, &addr)
786                }
787                ServerPackets::LocationUnSubscribe {
788                    id,
789                    location_id,
790                    to,
791                } => {
792                    let packet = ClientPackets::LocationUnSubscribe(
793                        id,
794                        self.session.location_unsubscribe(&location_id, to),
795                    );
796                    self.inner.send(packet, &addr)
797                }
798                ServerPackets::ModuleAcceptedProtocols { id, module_id } => {
799                    let packet = ClientPackets::ModuleAcceptedProtocols(
800                        id,
801                        self.session.module_accepted_protocols(&module_id),
802                    );
803                    self.inner.send(packet, &addr)
804                }
805                ServerPackets::ElementGetUrl { id, element_id } => {
806                    let packet =
807                        ClientPackets::ElementGetUrl(id, self.session.element_get_url(&element_id));
808                    self.inner.send(packet, &addr)
809                }
810                ServerPackets::ElementSetUrl { id, element_id, to } => {
811                    let packet = ClientPackets::ElementSetUrl(
812                        id,
813                        self.session.element_set_url(&element_id, to),
814                    );
815                    self.inner.send(packet, &addr)
816                }
817                ServerPackets::Tick => {}
818            }
819        }
820    }
821}
822
823trait TDaemonInner {
824    fn send(&self, packet: ClientPackets, to: &SocketAddr);
825    fn recv(&self) -> Option<(SocketAddr, Vec<ServerPackets>)>;
826    // garbage collect clients
827    fn gc_clients(&self);
828    fn clients(&self) -> Vec<SocketAddr>;
829}
830
831impl DaemonInner {
832    fn get_inner(&mut self) -> (&mut [u8], &mut UdpSocket) {
833        (&mut self.buffer, &mut self.socket)
834    }
835}
836
837impl TDaemonInner for Arc<Mutex<DaemonInner>> {
838    fn send(&self, packet: ClientPackets, to: &SocketAddr) {
839        let mut bytes = packet.to_bytes();
840        bytes.reverse();
841        let _ = self.lock().unwrap().socket.send_to(&bytes, to);
842    }
843
844    fn recv(&self) -> Option<(SocketAddr, Vec<ServerPackets>)> {
845        let mut inner = self.lock().unwrap();
846
847        let (buffer, socket) = inner.get_inner();
848
849        let Ok((len, from)) = socket.recv_from(buffer) else{return None};
850
851        {
852            let mut finded = false;
853            for client in inner.clients.iter_mut() {
854                if client.1 == from {
855                    client.0 = SystemTime::now();
856                    finded = true;
857                    break;
858                }
859            }
860
861            if !finded {
862                inner.clients.push((SystemTime::now(), from))
863            }
864        }
865
866        let mut buffer = inner.buffer[0..len].to_vec();
867        let mut packets = Vec::new();
868        while !buffer.is_empty() {
869            let Some(packet) = ServerPackets::from_bytes(&mut buffer) else{continue};
870            packets.push(packet)
871        }
872
873        Some((from, packets))
874    }
875
876    fn gc_clients(&self) {
877        self.lock()
878            .unwrap()
879            .clients
880            .retain(|(time, _)| time.elapsed().unwrap() > CLIENT_TIMEOUT);
881    }
882
883    fn clients(&self) -> Vec<SocketAddr> {
884        self.gc_clients();
885        self.lock()
886            .unwrap()
887            .clients
888            .iter()
889            .map(|(_, addr)| *addr)
890            .collect::<Vec<SocketAddr>>()
891    }
892}
muzzman_daemon/daemon.rs

muzzman_daemon/
daemon.rs
