src/handlers/file

src/handlers/file_handler.rs

Lines

98.66 %

Functions

100.00 %

Regions

98.50 %


//
// File Name:    file_handler.rs
// Directory:    src/handlers
// Project Name: flogging
//
// Copyright (C) 2025 Bradley Willcott
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
// This library (crate) is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This library (crate) is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this library (crate).  If not, see <https://www.gnu.org/licenses/>.
//

//!
//! # FileHandler
//!

use std::{
    fmt,
    fs::{File, exists},
    io::{Error, ErrorKind::InvalidInput, Write},
};

use crate::*;

///
/// Publishes log entries to the file whose name was provided during
/// initialization.
///
#[derive(Debug, Default)]
pub struct FileHandler {
    filename: String,
    formatter: Formatter,
    file: Option<File>,
    writer: Option<Vec<u8>>,
}

impl FileHandler {
    fn _create(filename: &str) -> Result<Self, Error> {
        if filename.is_empty() {
            return Err(Error::new(InvalidInput, "'filename' must not be empty"));
        }

        let fh = FileHandler {
            filename: filename.to_string(),
            formatter: FormatType::Iso8601.create(None),
            file: {
                let f = File::options().append(true).create(true).open(filename)?;
                Some(f)
            },
            writer: None,
        };

        Ok(fh)
    }

    fn log(&self) -> String {
        if let Some(w) = self.writer.to_owned() {
            String::from_utf8(w).unwrap()
        } else {
            String::new()
        }
    }
}

impl fmt::Display for FileHandler {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} : {}", self.filename, self.formatter)
    }
}

impl HandlerTrait for FileHandler {
    ///
    /// Create a new handler instance.
    ///
    /// ## Parameters
    /// - `name` - This the `filename` of the log file.
    ///
    fn create(name: &str) -> Result<Self, Error> {
        FileHandler::_create(name)
    }

    ///
    /// Flushes and closes the file.\
    /// Also, removes the internal buffer, if in `test_mode`.\
    /// Will therefore, no longer be *in* `test_mode`.
    ///
    fn close(&mut self) {
        self.flush();
        self.file = None;
    }

    fn flush(&mut self) {
        if let Some(f) = &self.file {
            f.sync_all().expect("sync_all failed");
        }
    }

    fn get_formatter(&self) -> Formatter {
        self.formatter.clone()
    }

    fn get_log(&self) -> String {
        self.log()
    }

    fn is_open(&self) -> bool {
        self.file.is_some()
    }

    fn publish(&mut self, log_entry: &LogEntry) {
        if self.is_open() {
            let mut buf = self.formatter.format(log_entry);
            buf.push('\n');

            if let Some(w) = self.writer.as_mut() {
                writeln!(w, "{}", self.formatter.format(log_entry)).expect("writeln!() failed");
            } else {
                self.file
                    .as_mut()
                    .unwrap()
                    .write_all(buf.as_bytes())
                    .expect("write_all() failed");
            }
        }
    }

    fn set_formatter(&mut self, formatter: Formatter) {
        self.formatter = formatter;
    }

    ///
    /// Sets the test mode to `state`.
    ///
    /// If set to `true`, use `get_log()` to obtain the
    /// log.
    ///
    fn set_test_mode(&mut self, state: bool) {
        if state {
            // true
            self.writer = Some(Vec::new());
        } else {
            self.writer = None;
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::*;
    use std::{
        fs::File,
        io::{Error, Read, Result},
    };

    #[test]
    fn file_handler() {
        let mut log = Logger::file_logger(module_path!(), "test_logs/file_handler.log");
        log.set_fn_name("file_handler");

        let h = log.get_handler(crate::Handler::File).unwrap();
        h.set_test_mode(false);

        assert!(h.is_open());
        assert_eq!(
            h.get_formatter().to_string(),
            "dt_fmt: \"%+\" - fmt_string: \"{dt:35} {mod_path}->{fn_name} [{level:7}] {message}\""
                .to_string()
        );

        log.info("trait methods");
        log.warning("The sky is falling!");

        let h = log.get_handler(crate::Handler::File).unwrap();

        assert_eq!(h.get_log(), "".to_string());

        h.flush();
        h.close();
        log.exiting_with("This should get thrown away.");
    }

    #[test]
    fn file_handler_file_test() {
        let expected = "flogging::handlers::file_handler::tests->file_handler_file_test [INFO   ] trait methods
flogging::handlers::file_handler::tests->file_handler_file_test [WARNING] The sky is falling!\n"
            .to_string();

        let mut log = Logger::builder(module_path!())
            .set_fn_name("file_handler_file_test")
            .remove_file("test_logs/file_handler_file_test.log")
            .add_file_handler_with(
                "test_logs/file_handler_file_test.log",
                FormatType::Simple,
                None,
            )
            .build();

        let h = log.get_handler(crate::Handler::File).unwrap();
        h.set_test_mode(false);

        assert!(h.is_open());
        assert_eq!(
            h.get_formatter().to_string(),
            "dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
                .to_string()
        );

        log.info("trait methods");
        log.warning("The sky is falling!");

        let h = log.get_handler(crate::Handler::File).unwrap();

        assert_eq!(h.get_log(), "".to_string());

        h.flush();
        h.close();
        assert!(!h.is_open());

        log.severe("This should get thrown away.");

        if let Ok(mut file) = File::open("test_logs/file_handler_file_test.log") {
            let mut buf = String::new();
            if let Ok(_count) = file.read_to_string(&mut buf) {
                assert_eq!(expected, buf);
            }
        }
    }

    #[test]
    fn file_handler_test_mode() {
        let expected = "flogging::handlers::file_handler::tests->file_handler_test_mode [INFO   ] trait methods
flogging::handlers::file_handler::tests->file_handler_test_mode [WARNING] The sky is falling!\n"
            .to_string();

        let mut log = Logger::builder(module_path!())
            .set_fn_name("file_handler_test_mode")
            .remove_file("test_logs/file_handler_test_mode.log")
            .add_file_handler_with(
                "test_logs/file_handler_test_mode.log",
                FormatType::Simple,
                None,
            )
            .build();

        let h = log.get_handler(crate::Handler::File).unwrap();
        h.set_test_mode(true);

        assert!(h.is_open());
        assert_eq!(
            h.get_formatter().to_string(),
            "dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
                .to_string()
        );

        log.info("trait methods");
        log.warning("The sky is falling!");

        let h = log.get_handler(crate::Handler::File).unwrap();
        let buf = h.get_log();

        assert_eq!(expected, buf);

        h.flush();
        h.close();
    }

    #[test]
    #[should_panic(expected = "'filename' must not be empty")]
    fn filename_empty() {
        let _ = Logger::file_logger(module_path!(), "");
    }
}

Line	Count	Source (jump to first uncovered line)
1		//
2		// File Name: file_handler.rs
3		// Directory: src/handlers
4		// Project Name: flogging
5		//
6		// Copyright (C) 2025 Bradley Willcott
7		//
8		// SPDX-License-Identifier: GPL-3.0-or-later
9		//
10		// This library (crate) is free software: you can redistribute it and/or modify
11		// it under the terms of the GNU General Public License as published by
12		// the Free Software Foundation, either version 3 of the License, or
13		// (at your option) any later version.
14		//
15		// This library (crate) is distributed in the hope that it will be useful,
16		// but WITHOUT ANY WARRANTY; without even the implied warranty of
17		// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18		// GNU General Public License for more details.
19		//
20		// You should have received a copy of the GNU General Public License
21		// along with this library (crate). If not, see <https://www.gnu.org/licenses/>.
22		//
23
24		//!
25		//! # FileHandler
26		//!
27
28		use std::{
29		fmt,
30		fs::{File, exists},
31		io::{Error, ErrorKind::InvalidInput, Write},
32		};
33
34		use crate::*;
35
36		///
37		/// Publishes log entries to the file whose name was provided during
38		/// initialization.
39		///
40		#[derive(Debug, Default)]
41		pub struct FileHandler {
42		filename: String,
43		formatter: Formatter,
44		file: Option<File>,
45		writer: Option<Vec<u8>>,
46		}
47
48		impl FileHandler {
49	20	fn _create(filename: &str) -> Result<Self, Error> {
50	20	if filename.is_empty() {
51	1	return Err(Error::new(InvalidInput, "'filename' must not be empty"));
52	19	}
53
54	19	let fh = FileHandler {
55	19	filename: filename.to_string(),
56	19	formatter: FormatType::Iso8601.create(None),
57		file: {
58	19	let f = File::options().append(true).create(true).open(filename)?;
59	19	Some(f)
60		},
61	19	writer: None,
62		};
63
64	19	Ok(fh)
65	20	}
66
67	3	fn log(&self) -> String {
68	3	if let Some(w) = self.writer.to_owned() {
69	1	String::from_utf8(w).unwrap()
70		} else {
71	2	String::new()
72		}
73	3	}
74		}
75
76		impl fmt::Display for FileHandler {
77	1	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
78	1	write!(f, "{} : {}", self.filename, self.formatter)
79	1	}
80		}
81
82		impl HandlerTrait for FileHandler {
83		///
84		/// Create a new handler instance.
85		///
86		/// ## Parameters
87		/// - `name` - This the `filename` of the log file.
88		///
89	20	fn create(name: &str) -> Result<Self, Error> {
90	20	FileHandler::_create(name)
91	20	}
92
93		///
94		/// Flushes and closes the file.\
95		/// Also, removes the internal buffer, if in `test_mode`.\
96		/// Will therefore, no longer be in `test_mode`.
97		///
98	3	fn close(&mut self) {
99	3	self.flush();
100	3	self.file = None;
101	3	}
102
103	6	fn flush(&mut self) {
104	6	if let Some(f) = &self.file {
105	6	f.sync_all().expect("sync_all failed");
106	6	}
107	6	}
108
109	3	fn get_formatter(&self) -> Formatter {
110	3	self.formatter.clone()
111	3	}
112
113	3	fn get_log(&self) -> String {
114	3	self.log()
115	3	}
116
117	53	fn is_open(&self) -> bool {
118	53	self.file.is_some()
119	53	}
120
121	49	fn publish(&mut self, log_entry: &LogEntry) {
122	49	if self.is_open() {
123	48	let mut buf = self.formatter.format(log_entry);
124	48	buf.push('\n');
125
126	2	if let Some(w) = self.writer.as_mut() {
127	2	writeln!(w, "{}", self.formatter.format(log_entry)).expect("writeln!() failed");
128	46	} else {
129	46	self.file
130	46	.as_mut()
131	46	.unwrap()
132	46	.write_all(buf.as_bytes())
133	46	.expect("write_all() failed");
134	46	}
135	1	}
136	49	}
137
138	3	fn set_formatter(&mut self, formatter: Formatter) {
139	3	self.formatter = formatter;
140	3	}
141
142		///
143		/// Sets the test mode to `state`.
144		///
145		/// If set to `true`, use `get_log()` to obtain the
146		/// log.
147		///
148	3	fn set_test_mode(&mut self, state: bool) {
149	1	if state {
150	1	// true
151	1	self.writer = Some(Vec::new());
152	2	} else {
153	2	self.writer = None;
154	2	}
155	3	}
156		}
157
158		#[cfg(test)]
159		mod tests {
160		use crate::*;
161		use std::{
162		fs::File,
163		io::{Error, Read, Result},
164		};
165
166		#[test]
167	1	fn file_handler() {
168	1	let mut log = Logger::file_logger(module_path!(), "test_logs/file_handler.log");
169	1	log.set_fn_name("file_handler");
170
171	1	let h = log.get_handler(crate::Handler::File).unwrap();
172	1	h.set_test_mode(false);
173
174	1	assert!(h.is_open());
175	1	assert_eq!(
176	1	h.get_formatter().to_string(),
177	1	"dt_fmt: \"%+\" - fmt_string: \"{dt:35} {mod_path}->{fn_name} [{level:7}] {message}\""
178	1	.to_string()
179		);
180
181	1	log.info("trait methods");
182	1	log.warning("The sky is falling!");
183
184	1	let h = log.get_handler(crate::Handler::File).unwrap();
185
186	1	assert_eq!(h.get_log(), "".to_string());
187
188	1	h.flush();
189	1	h.close();
190	1	log.exiting_with("This should get thrown away.");
191	1	}
192
193		#[test]
194	1	fn file_handler_file_test() {
195	1	let expected = "flogging::handlers::file_handler::tests->file_handler_file_test [INFO ] trait methods
196	1	flogging::handlers::file_handler::tests->file_handler_file_test [WARNING] The sky is falling!\n"
197	1	.to_string();
198
199	1	let mut log = Logger::builder(module_path!())
200	1	.set_fn_name("file_handler_file_test")
201	1	.remove_file("test_logs/file_handler_file_test.log")
202	1	.add_file_handler_with(
203	1	"test_logs/file_handler_file_test.log",
204	1	FormatType::Simple,
205	1	None,
206		)
207	1	.build();
208
209	1	let h = log.get_handler(crate::Handler::File).unwrap();
210	1	h.set_test_mode(false);
211
212	1	assert!(h.is_open());
213	1	assert_eq!(
214	1	h.get_formatter().to_string(),
215	1	"dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
216	1	.to_string()
217		);
218
219	1	log.info("trait methods");
220	1	log.warning("The sky is falling!");
221
222	1	let h = log.get_handler(crate::Handler::File).unwrap();
223
224	1	assert_eq!(h.get_log(), "".to_string());
225
226	1	h.flush();
227	1	h.close();
228	1	assert!(!h.is_open());
229
230	1	log.severe("This should get thrown away.");
231
232	1	if let Ok(mut file) = File::open("test_logs/file_handler_file_test.log") {
233	1	let mut buf = String::new();
234	1	if let Ok(_count) = file.read_to_string(&mut buf) {
235	1	assert_eq!(expected, buf);
236	0	}
237	0	}
238	1	}
239
240		#[test]
241	1	fn file_handler_test_mode() {
242	1	let expected = "flogging::handlers::file_handler::tests->file_handler_test_mode [INFO ] trait methods
243	1	flogging::handlers::file_handler::tests->file_handler_test_mode [WARNING] The sky is falling!\n"
244	1	.to_string();
245
246	1	let mut log = Logger::builder(module_path!())
247	1	.set_fn_name("file_handler_test_mode")
248	1	.remove_file("test_logs/file_handler_test_mode.log")
249	1	.add_file_handler_with(
250	1	"test_logs/file_handler_test_mode.log",
251	1	FormatType::Simple,
252	1	None,
253		)
254	1	.build();
255
256	1	let h = log.get_handler(crate::Handler::File).unwrap();
257	1	h.set_test_mode(true);
258
259	1	assert!(h.is_open());
260	1	assert_eq!(
261	1	h.get_formatter().to_string(),
262	1	"dt_fmt: \"\" - fmt_string: \"{mod_path}->{fn_name} [{level:7}] {message}\""
263	1	.to_string()
264		);
265
266	1	log.info("trait methods");
267	1	log.warning("The sky is falling!");
268
269	1	let h = log.get_handler(crate::Handler::File).unwrap();
270	1	let buf = h.get_log();
271
272	1	assert_eq!(expected, buf);
273
274	1	h.flush();
275	1	h.close();
276	1	}
277
278		#[test]
279		#[should_panic(expected = "'filename' must not be empty")]
280	1	fn filename_empty() {
281	1	let _ = Logger::file_logger(module_path!(), "");
282	1	}
283		}