yang5 0.1.0

libyang5 bindings for Rust
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
141
142
143
144
145
146
147

use std::borrow::Cow;
use std::ffi::CStr;
use std::os::raw::c_char;
use std::sync::OnceLock;

use crate::ffi;

static LOG_CALLBACK: OnceLock<Box<dyn LogCallback>> = OnceLock::new();

/// A custom logger to pass to libyang.
pub trait LogCallback: Send + Sync + 'static {
    fn log<'a>(
        &'a self,
        level: ffi::LY_LOG_LEVEL::Type,
        msg: Option<Cow<'a, str>>,
        data_path: Option<Cow<'a, str>>,
        schema_path: Option<Cow<'a, str>>,
        line: u64,
    );
}

/// Set the log level to [`ffi::LY_LOG_LEVEL::LY_LLDBG`]
pub(crate) fn set_log_level_trace() {
    unsafe { ffi::ly_log_level(ffi::LY_LOG_LEVEL::LY_LLDBG) };
}

/// Set the log level to [`ffi::LY_LOG_LEVEL::LY_LLVRB`]
pub(crate) fn set_log_level_debug() {
    unsafe { ffi::ly_log_level(ffi::LY_LOG_LEVEL::LY_LLVRB) };
}

/// Set the log level to [`ffi::LY_LOG_LEVEL::LY_LLWRN`]
pub(crate) fn set_log_level_warn() {
    unsafe { ffi::ly_log_level(ffi::LY_LOG_LEVEL::LY_LLWRN) };
}

/// Set the log level to [`ffi::LY_LOG_LEVEL::LY_LLERR`]
pub(crate) fn set_log_level_error() {
    unsafe { ffi::ly_log_level(ffi::LY_LOG_LEVEL::LY_LLERR) };
}

/// An error returned when the logging callback has already been initialized.
#[derive(Debug)]
pub struct LoggingCallbackAlreadySet {
    _private: (),
}

impl std::fmt::Display for LoggingCallbackAlreadySet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Logging callback already set")
    }
}

impl std::error::Error for LoggingCallbackAlreadySet {}

/// Initialize the logging callback.
///
/// The callback can only be initialized once.
pub(crate) fn init_logger<C>(
    callback: C,
) -> Result<(), LoggingCallbackAlreadySet>
where
    C: LogCallback,
{
    unsafe { ffi::ly_log_options(ffi::LY_LOLOG | ffi::LY_LOSTORE_LAST) };
    LOG_CALLBACK
        .set(Box::new(callback))
        .map_err(|_| LoggingCallbackAlreadySet { _private: () })?;
    unsafe { ffi::ly_set_log_clb(Some(log_callback)) };
    Ok(())
}

extern "C" fn log_callback(
    level: ffi::LY_LOG_LEVEL::Type,
    msg: *const c_char,
    data_path: *const c_char,
    schema_path: *const c_char,
    line: u64,
) {
    let msg = if !msg.is_null() {
        // SAFETY: we assume that the arguments passed to the callback
        // are valid null terminated string valids for the entire
        // execution of this function.
        let cstr = unsafe { CStr::from_ptr(msg) };
        Some(cstr.to_string_lossy())
    } else {
        None
    };

    let data_path = if !data_path.is_null() {
        // SAFETY: we assume that the arguments passed to the callback
        // are valid null terminated string valids for the entire
        // execution of this function.
        let cstr = unsafe { CStr::from_ptr(data_path) };
        Some(cstr.to_string_lossy())
    } else {
        None
    };

    let schema_path = if !schema_path.is_null() {
        // SAFETY: we assume that the arguments passed to the callback
        // are valid null terminated string valids for the entire
        // execution of this function.
        let cstr = unsafe { CStr::from_ptr(schema_path) };
        Some(cstr.to_string_lossy())
    } else {
        None
    };

    if let Some(cb) = LOG_CALLBACK.get() {
        cb.log(level, msg, data_path, schema_path, line);
    }
}

/// A logger that to log libyang message using the `log` crate.
#[derive(Debug, Default)]
pub struct DefaultLogger {
    _private: (),
}

impl LogCallback for DefaultLogger {
    fn log<'a>(
        &'a self,
        level: ffi::LY_LOG_LEVEL::Type,
        msg: Option<Cow<'a, str>>,
        data_path: Option<Cow<'a, str>>,
        schema_path: Option<Cow<'a, str>>,
        line: u64,
    ) {
        let level = match level {
            ffi::LY_LOG_LEVEL::LY_LLERR => log::Level::Error,
            ffi::LY_LOG_LEVEL::LY_LLWRN => log::Level::Warn,
            ffi::LY_LOG_LEVEL::LY_LLVRB => log::Level::Info,
            ffi::LY_LOG_LEVEL::LY_LLDBG => log::Level::Debug,
            unknown => {
                log::error!("Unexpected log level {unknown} from libyang5, logging as debug");
                log::Level::Debug
            }
        };
        let msg = msg.unwrap_or_else(|| Cow::from(""));
        log::log! {
            target: "libyang5",
            level,
            "schema_path={schema_path:?}, data_path={data_path:?}, line={line}, msg={msg}",
        }
    }
}