syslog-rs 6.5.0

A native Rust implementation of the glibc/libc/windows syslog client and windows native log for logging.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

/*-
 * syslog-rs - a syslog client translated from libc to rust
 * 
 * Copyright 2025 Aleksandr Morozov
 * 
 * The syslog-rs crate can be redistributed and/or modified
 * under the terms of either of the following licenses:
 *
 *   1. the Mozilla Public License Version 2.0 (the “MPL”) OR
 *
 *   2. The MIT License (MIT)
 *                     
 *   3. EUROPEAN UNION PUBLIC LICENCE v. 1.2 EUPL © the European Union 2007, 2016
 */

use std::fmt;

use tokio::sync::oneshot;

use crate::
{
    error::SyRes, 
    formatters::SyslogFormatter, 
    map_error_code, 
    sy_sync_queue::
    {
        SyCmd, 
        SyslogQueueChanRcv, 
        SyslogQueueChanSnd, 
        SyslogQueueChannel, 
        SyslogQueueOneChanRcv, 
        SyslogQueueOneChanSnd
    }, 
    SyslogDestination
};


impl<F: SyslogFormatter, D: SyslogDestination, S: SyslogQueueChannel<F, D>> SyslogQueueChanRcv<F, D, S> 
for tokio::sync::mpsc::UnboundedReceiver<SyCmd<F, D, S>>
{
    fn q_recv_blocking(&mut self) -> Option<SyCmd<F, D, S>>
    {
        return 
            self
                .blocking_recv();
    }
}
 

impl<F: SyslogFormatter, D: SyslogDestination, S: SyslogQueueChannel<F, D>> SyslogQueueChanSnd<F, D, S> 
for tokio::sync::mpsc::UnboundedSender<SyCmd<F, D, S>>
{
    fn q_send_blocking(&self, msg: SyCmd<F, D, S>) -> SyRes<()> 
    {
        return 
            self
                .send(msg)
                .map_err(|e| 
                    map_error_code!(SendError, "send_blocking() error: '{}'", e)

                );
    }

    async 
    fn q_send(&self, msg: SyCmd<F, D, S>) -> SyRes<()>
    {
        return 
            self
                .send(msg)
                .map_err(|e| 
                    map_error_code!(SendError, "send_blocking() error: '{}'", e)

                );
    }
}

impl<C: Send + fmt::Debug> SyslogQueueOneChanSnd<C> for tokio::sync::oneshot::Sender<C>
{
    fn send_once_blocking(self, data: C) -> Result<(), C>
    {
        return 
            self.send(data);
                
    }
}

impl<C> SyslogQueueOneChanRcv<C> for tokio::sync::oneshot::Receiver<C>
{
    fn recv_once_blocking(self) -> SyRes<C> 
    {
        return 
            self
                .blocking_recv()
                .map_err(|e|
                    map_error_code!(UnboundedChannelError, "channel error: '{}'", e)

                );
    }

    async 
    fn recv_once(self) -> SyRes<C> where Self: Sized
    {
        return 
            self
                .await
                .map_err(|e|
                    map_error_code!(UnboundedChannelError, "channel error: '{}'", e)

                );

    }
}

#[derive(Debug, Clone)]
pub struct TokioQueueAdapter;

unsafe impl Send for TokioQueueAdapter {}

impl<F: SyslogFormatter, D: SyslogDestination> SyslogQueueChannel<F, D> for TokioQueueAdapter
{
    const ADAPTER_NAME: &'static str = "tokio";
    
    type ChannelSnd = tokio::sync::mpsc::UnboundedSender<SyCmd<F, D, Self>>;

    type ChannelRcv = tokio::sync::mpsc::UnboundedReceiver<SyCmd<F, D, Self>>;

    type OneShotChannelSnd<C: Send + fmt::Debug> = tokio::sync::oneshot::Sender<C>;

    type OneShotChannelRcv<C> = tokio::sync::oneshot::Receiver<C>;

    fn create_channel() -> (Self::ChannelSnd, Self::ChannelRcv) 
    {
        return tokio::sync::mpsc::unbounded_channel::<SyCmd<F, D, Self>>();
    }

    fn create_oneshot_channel<C: Send + fmt::Debug>() -> (Self::OneShotChannelSnd<C>, Self::OneShotChannelRcv<C>) 
    {
        return oneshot::channel::<C>();
    }
}


pub type DefaultQueueAdapter = TokioQueueAdapter;