cdns_rs/sync/

log.rs

/*-
 * cdns-rs - a simple sync/async DNS query library
 * 
 * Copyright (C) 2020  Aleksandr Morozov
 * 
 * Copyright 2025 Aleksandr Morozov
 * 
 * Licensed under the EUPL, Version 1.2 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence").
 * 
 * You may not use this work except in compliance with the Licence.
 * 
 * You may obtain a copy of the Licence at:
 * 
 *    https://joinup.ec.europa.eu/software/page/eupl
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * Licence for the specific language governing permissions and limitations
 * under the Licence.
 */

pub mod cdns_custom_output
{
    use std::{fmt::{self, Write}, str, sync::{LazyLock, Mutex, OnceLock}};

    struct DummyOutputAdapter{}

    unsafe impl Send for DummyOutputAdapter {}

    impl Write for DummyOutputAdapter
    {
        fn write_str(&mut self, _s: &str) -> fmt::Result 
        {
            return Ok(());
        }
    }

    impl DummyOutputAdapter
    {
        fn new() -> Self
        {
            return Self{};
        }
    }

    static IS_INITIALIZED: OnceLock<bool> = OnceLock::new();

    /// An instance which implements the io::Write + Send
    static WRITABLE_BUFFER: LazyLock<Mutex<Box<dyn Write + Send>>> = LazyLock::new(|| { Mutex::new(Box::new(DummyOutputAdapter::new())) });
    static LAST_ERROR: LazyLock<Mutex<Option<String>>> = LazyLock::new(|| { Mutex::new(None) });

    /// Initializes the output to the custom buffer.
    /// This function does not check if you set the output twice and panics!
    /// 
    /// # Arguments
    /// 
    /// * `w` - a dynamic instance in [Box] which implements [Write] and [Send]
    /// 
    /// # Panics
    /// 
    /// If the mutex was poisoned, may panic. Also will panic, if it will be 
    /// attempted to reinitialize the instance. If this is a problem, use 
    /// [initialize_safe]
    pub 
    fn initialize(w: Box<dyn Write + Send>)
    {
        // occure the lock
        let mut lock = WRITABLE_BUFFER.lock().unwrap();

        // set new instance
        *lock = w;

        // lock the status
        IS_INITIALIZED.get_or_init(|| true);

        return;
    }

    /// Initializes the output to the custom buffer.
    /// 
    /// # Arguments
    /// 
    /// * `w` - a dynamic instance in [Box] which implements [Write] and [Send]
    /// 
    /// # Returns
    /// 
    /// * [bool] true if mutex is not poisoned
    /// 
    /// * [bool] false if mutex was poisoned
    /// 
    /// # Panics
    /// 
    /// Does not panic!
    pub 
    fn initialize_safe(w: Box<dyn Write + Send>) -> bool
    {
        // check if instance is initialized
        if let None = IS_INITIALIZED.get()
        {
            // lock
            match WRITABLE_BUFFER.lock()
            {
                Ok(mut r) => 
                {
                    // set instance
                    *r = w;
    
                    // lock
                    IS_INITIALIZED.get_or_init(|| true);

                    return true;
                },
                Err(_e) => 
                    return false,
            }
        }
        else
        {
            return false;
        }
    }

    /// Returns the status. Once initialized, can not be deinitialized.
    /// 
    /// # Returns
    /// 
    /// * [bool] true, if initialized
    /// 
    /// * [bool] false, if not initialized
    /// 
    /// # Panics
    /// 
    /// May panic is mutex is poisoned!
    pub 
    fn is_initialized() -> bool
    {
        return IS_INITIALIZED.get().is_some();
    }

    /// Returns the status of the mutex answering the quiestion if
    /// the mutex which guards the access is poisoned.
    /// 
    /// # Returns
    /// 
    /// * [bool] true, if poisoned
    /// 
    /// * [bool] false, if not poisoned
    /// 
    /// # Panics
    /// 
    /// Never panics!
    pub 
    fn is_poisoned() -> bool
    {
        return WRITABLE_BUFFER.is_poisoned();
    }

    /// Moves the last error from storage.
    pub 
    fn last_error() -> Option<String>
    {
        match LAST_ERROR.lock()
        {
            Ok(mut r) => return (*r).take(),
            Err(_e) => return None,
        }
    }

    #[inline]
    pub 
    fn cdns_custom_output_write(s: &str)
    {
        if IS_INITIALIZED.get().is_some() == false
        {
            // just ignore
            return;
        }

        match WRITABLE_BUFFER.lock()
        {
            Ok(mut r) =>
            {
                let err = (*r).write_str(s);

                if let Err(e) = err
                {
                    match LAST_ERROR.lock()
                    {
                        Ok(mut r) => *r = Some(e.to_string()),
                        Err(_e) => {}
                    }
                }
            }
            Err(_e) => {}
        }

        return;
    }
}

use crate::error::Writer;

/*
n = force_none
c = force_custom
d = debug_assertions
t = test

V - set
X - not allowed
O - does not care, ignored
     n c d t
none V X O O
std  X X O O
cus  X V O O
*/

#[cfg(
    all(
        feature = "no_error_output",
        feature = "custom_error_output",
    )
)]
compile_error!("It is not allowed to use features 
    'no_error_output' and 'custom_error_output' simultaniously");


// ------ OUTPUT to stdout and stderr ------ FEAUTE: no + any(debug_assertions, test)

/// A macro for printing error to stderror all error messages generated by
/// the library.
#[cfg(
    all(
        not(feature = "no_error_output"),
        not(feature = "custom_error_output"),
        any( debug_assertions, test)
    )
)]
#[macro_export]
macro_rules! write_error 
{
    ($($arg:tt)*) => (
        eprintln!($($arg)*)
    )
}

#[cfg(
    all(
        not(feature = "no_error_output"),
        not(feature = "custom_error_output"),
        any( debug_assertions, test)
    )
)]
pub 
fn sync_log_writer(w: Writer)
{
    eprintln!("{}", s);
}


// ------ OUTPUT to custom ----- FEATURE: custom_error_output

#[cfg(
    all(
        not(feature = "no_error_output"),
        feature = "custom_error_output",
        any(debug_assertions, test)
    )
)]
pub use cdns_custom_output::*;


/// A macro for printing to progrmas buffer all error messages generated by
/// the library.
#[cfg(
    all(
        not(feature = "no_error_output"),
        feature = "custom_error_output",
        any(debug_assertions, test)
    )
)]
#[macro_export]
macro_rules! write_error 
{
    ($($arg:tt)*) => (
        $crate::sync::log::cdns_custom_output::cdns_custom_output_write(format!($($arg)*).as_str())
    )
}

#[cfg(
    all(
        not(feature = "no_error_output"),
        feature = "custom_error_output",
        any(debug_assertions, test)
    )
)]
pub 
fn sync_log_writer(w: Writer)
{
    if w.is_some() == true
    {
        cdns_custom_output_write(unsafe { w.get_str() });
    }
}


// ----- OUTPUT to null ----- FEATURE: no_error_output

/*#[cfg(
    all(
        not(feature = "custom_error_output"),
        feature = "no_error_output",
    )
)]
#[inline]
pub 
fn empty_func() { return; }*/

/// A macro for printing to nowhere all error messages generated by
/// the library.
#[cfg(
    all(
        not(feature = "custom_error_output"),
        feature = "no_error_output",
    )
)]
#[macro_export]
macro_rules! write_error 
{
    ($($arg:tt)*) => (
        {}
    )
}

#[cfg(
    all(
        not(feature = "custom_error_output"),
        feature = "no_error_output",
    )
)]
#[inline]
pub 
fn sync_log_writer(_w: Writer)
{
    return;
}