syslog_rs/sync/

syslog_sync_shared.rs

/*-
 * 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. EUROPEAN UNION PUBLIC LICENCE v. 1.2 EUPL © the European Union 2007, 2016
 */

use std::marker::PhantomData;
use std::{str, sync::Arc};


use std::sync::Mutex;

use crate::formatters::DefaultSyslogFormatter;
use crate::{formatters::SyslogFormatter, map_error_code};
use crate::{common::*, SyslogDestination, SyslogLocal};
use crate::error::SyRes;

use super::{syslog_trait::SyslogApi, StreamableSyslog, syslog_sync_internal::SyncSyslogInternal, StreamableSyslogApi, SyslogStream};


/// A single instance shared between all threads. A [Mutex] is used to 
/// guard the instance.
/// 
/// For this isntance a [SyslogApi] and [StreamableSyslogApi] are implemented.
/// 
/// # Generics
/// 
/// * `F` - a [SyslogFormatter] which sets the instance which would 
///     format the message.
/// 
/// * `D` - a [SyslogDestination] instance which is either:
///     [SyslogLocal], [SyslogFile], [SyslogNet], [SyslogTls]. By
///     default a `SyslogLocal` is selected.
#[derive(Debug, Clone)]
pub struct SyslogShared<F: SyslogFormatter = DefaultSyslogFormatter, D: SyslogDestination = SyslogLocal>
{   
    /// A giantly locked syslog data
    inner: Arc<Mutex<SyncSyslogInternal<F, D>>>,
}

unsafe impl<F: SyslogFormatter, D: SyslogDestination> Send for SyslogShared<F, D> {}
unsafe impl<F: SyslogFormatter, D: SyslogDestination> Sync for SyslogShared<F, D> {}

impl SyslogShared
{
    /// Opens a default connection to the local syslog server with default formatter.
    /// 
    /// In order to access the syslog API, use the [SyslogApi].
    /// 
    /// # Arguments
    /// 
    /// * `ident` - A program name which will appear on the logs. If none, will be determined
    ///     automatically.
    /// 
    /// * `logstat` - [LogStat] an instance config.
    /// 
    /// * `facility` - [LogFacility] a syslog facility.
    /// 
    /// * `net_tap_prov` - a [SyslogLocal] instance with configuration.
    /// 
    /// # Returns
    /// 
    /// A [SyRes] is returned ([Result]) with: 
    /// 
    /// * [Result::Ok] - with instance
    /// 
    /// * [Result::Err] - with error description.
    pub 
    fn openlog(ident: Option<&str>, logstat: LogStat, facility: LogFacility, net_tap_prov: SyslogLocal) -> SyRes<Self> 
    {
        let mut syslog = 
            SyncSyslogInternal::<DefaultSyslogFormatter, SyslogLocal>::new(ident, logstat, facility, net_tap_prov)?;
       
        if logstat.contains(LogStat::LOG_NDELAY) == true
        {
            syslog.connectlog()?;
        }

        return Ok( 
            Self
            {
                inner: Arc::new(Mutex::new(syslog)),
            }
        );
    }
}

impl<F: SyslogFormatter, D: SyslogDestination> SyslogShared<F, D>
{
    /// Opens a special connection to the destination syslog server with specific formatter.
    /// 
    /// All struct generic should be specified before calling this function.
    /// 
    /// In order to access the syslog API, use the [SyslogApi].
    /// 
    /// # Arguments
    /// 
    /// * `ident` - A program name which will appear on the logs. If none, will be determined
    ///     automatically.
    /// 
    /// * `logstat` - [LogStat] an instance config.
    /// 
    /// * `facility` - [LogFacility] a syslog facility.
    /// 
    /// * `net_tap_prov` - a destination server. A specific `D` instance which contains infomation 
    ///     about the destination server. See `syslog_provider.rs`.
    /// 
    /// # Returns
    /// 
    /// A [SyRes] is returned ([Result]) with: 
    /// 
    /// * [Result::Ok] - with instance
    /// 
    /// * [Result::Err] - with error description.
    pub 
    fn openlog_with(ident: Option<&str>, logstat: LogStat, facility: LogFacility, net_tap_prov: D) -> SyRes<SyslogShared<F, D>> 
    {
        let mut syslog = 
            SyncSyslogInternal::<F, D>::new(ident, logstat, facility, net_tap_prov)?;
       
        if logstat.contains(LogStat::LOG_NDELAY) == true
        {
            syslog.connectlog()?;
        }

        return Ok( 
            Self
            {
                inner: Arc::new(Mutex::new(syslog)),
            }
        );
    }
}

impl<F: SyslogFormatter, D: SyslogDestination> StreamableSyslogApi<D, F, SyslogShared<F, D>> 
for SyslogShared<F, D>
{
    fn make_stream(&self, pri: Priority) -> Box<dyn SyslogStream> 
    {
        let inst = 
            StreamableSyslog
            {
                inner: self.clone(),
                pri: pri,
                _p: PhantomData::<F>,
                _p1: PhantomData::<D>,

            };

        return Box::new(inst);
    }
}


impl<F: SyslogFormatter, D: SyslogDestination> SyslogApi<F, D> for SyslogShared<F, D>
{
    fn connectlog(&self) -> SyRes<()>
    {
        return 
            self
                .inner
                .lock()
                .map_err(|e| 
                    map_error_code!(MutexPoisoned, "{}", e)
                )?
                .connectlog();
    }

    fn setlogmask(&self, logmask: i32) -> SyRes<i32> 
    {
        let pri = 
            self
                .inner
                .lock()
                .map_err(|e| 
                    map_error_code!(MutexPoisoned, "{}", e)
                )?
                .set_logmask(logmask);

        return Ok(pri);
    }

    fn closelog(&self) -> SyRes<()> 
    {
        return 
            self
                .inner
                .lock()
                .map_err(|e| 
                    map_error_code!(MutexPoisoned, "{}", e)
                )?
                .disconnectlog();
    }

    #[inline]
    fn syslog(&self, pri: Priority, fmt: F) 
    {
        if let Ok(mut inner) = self.inner.lock()
        {
            inner.vsyslog1(pri, &fmt)
        }

        return;
    }

    /// This function can be used to update the facility name, for example
    /// after fork().
    /// 
    /// # Arguments
    /// 
    /// * `ident` - a new identity (up to 48 UTF8 chars)
    fn change_identity(&self, ident: &str) -> SyRes<()>
    {
        self
            .inner
            .lock()
            .map_err(|e| 
                map_error_code!(MutexPoisoned, "{}", e)
            )?
            .set_logtag(ident, true);

        return Ok(());
    }

    fn reconnect(&self) -> SyRes<()>
    {
        let mut lock = 
            self
                .inner
                .lock()
                .map_err(|e| 
                    map_error_code!(MutexPoisoned, "{}", e)
                )?;

        
        lock.disconnectlog()?;

        lock.connectlog()?;
            
        return Ok(());
    }

    fn update_tap_data(&self, tap_data: D) -> SyRes<()>
    {
        let mut lock = 
            self
                .inner
                .lock()
                .map_err(|e| 
                    map_error_code!(MutexPoisoned, "{}", e)
                )?;

        return lock.update_tap_data(tap_data);
    }

}