d21f7b5915d3669f79fce68f21586362acfbf111
[feisty_meow.git] / nucleus / library / loggers / file_logger.cpp
1 /*****************************************************************************\
2 *                                                                             *
3 *  Name   : file_logger                                                       *
4 *  Author : Chris Koeritz                                                     *
5 *                                                                             *
6 *******************************************************************************
7 * Copyright (c) 2000-$now By Author.  This program is free software; you can  *
8 * redistribute it and/or modify it under the terms of the GNU General Public  *
9 * License as published by the Free Software Foundation; either version 2 of   *
10 * the License or (at your option) any later version.  This is online at:      *
11 *     http://www.fsf.org/copyleft/gpl.html                                    *
12 * Please send any updates to: fred@gruntose.com                               *
13 \*****************************************************************************/
14
15 #include "critical_events.h"
16 #include "file_logger.h"
17 #include "logging_filters.h"
18
19 #include <basis/astring.h>
20 #include <basis/functions.h>
21 #include <basis/mutex.h>
22 #include <configuration/application_configuration.h>
23 #include <filesystem/byte_filer.h>
24 #include <filesystem/directory.h>
25 #include <filesystem/filename.h>
26 #include <mathematics/chaos.h>
27 #include <structures/static_memory_gremlin.h>
28 #include <textual/byte_formatter.h>
29
30 #if defined(__UNIX__) || defined(__GNU_WINDOWS__)
31   #include <unistd.h>
32 #else
33   #include <io.h>
34 #endif
35 #include <stdio.h>
36
37 using namespace basis;
38 using namespace configuration;
39 using namespace filesystem;
40 using namespace mathematics;
41 using namespace structures;
42 using namespace textual;
43
44 namespace loggers {
45
46 const int REDUCE_FACTOR = 5;
47   // we whack this portion of the file every time we truncate.  if it's set
48   // to 14, for example, then a 14th of the file is whacked every time whacking
49   // is needed.
50
51 const int MAXIMUM_BUFFER_SIZE = 140000;
52   // the maximum allowed chunk that can be copied from the old logfile
53   // to the current one.
54
55 int static_chaos() {
56   static chaos __hidden_chaos;
57   return __hidden_chaos.inclusive(0, 1280004);
58 }
59
60 file_logger::file_logger()
61 : _filename(new astring()),
62   _file_limit(DEFAULT_LOG_FILE_SIZE),
63   _outfile(NULL_POINTER),
64   _flock(new mutex)
65 {
66   name("");
67 }
68
69 file_logger::file_logger(const astring &initial_filename, int limit)
70 : _filename(new astring()),
71   _file_limit(limit),
72   _outfile(NULL_POINTER),
73   _flock(new mutex)
74 {
75   name(initial_filename); 
76   // we don't open the file right away because we don't know they'll ever
77   // use the thing.
78 }
79
80 file_logger::~file_logger()
81 {
82   close_file();
83   WHACK(_filename);
84   WHACK(_flock);
85 }
86
87 basis::astring file_logger::log_file_for_app_name()
88 {
89   filename prog = application_configuration::application_name();
90   return application_configuration::make_logfile_name(prog.rootname() + ".log");
91 }
92
93 bool file_logger::reopen()
94 {
95   auto_synchronizer l(*_flock);
96   name(*_filename);
97   return open_file();
98 }
99
100 void file_logger::close_file()
101 {
102   auto_synchronizer l(*_flock);
103   if (_outfile) _outfile->flush();
104     // dump anything that hasn't gone out yet.
105   WHACK(_outfile);
106 }
107
108 void file_logger::name(const astring &new_name)
109 {
110   auto_synchronizer l(*_flock);
111   close_file();
112   *_filename = new_name; 
113 }
114
115 int file_logger::size_reduction() const
116 {
117   auto_synchronizer l(*_flock);
118   return int(_file_limit / REDUCE_FACTOR);
119 }
120
121 bool file_logger::good() const
122 {
123   auto_synchronizer l(*_flock);
124   if (!_outfile && !_file_limit) return true;
125   if (!_outfile) return false;
126   return _outfile->good();
127 }
128
129 astring file_logger::name() const
130 {
131   auto_synchronizer l(*_flock);
132   return *_filename;
133 }
134
135 void file_logger::flush()
136 {
137   auto_synchronizer l(*_flock);
138   if (!_outfile) open_file();
139   if (_outfile) _outfile->flush();
140 }
141
142 bool file_logger::open_file()
143 {
144   auto_synchronizer l(*_flock);
145   close_file();  // close any existing log file.
146
147   if (!_file_limit) {
148     // if there's a limit of zero, we'll never open the file.
149     return true;
150   }
151
152   // make sure we've got a name.
153   if (!*_filename) {
154     // if the name is empty, they don't want to save to a normal log file.
155     _outfile = new byte_filer;
156     return true;
157   }
158
159   // canonicalize the name so that we use the same tag for synchronization.
160   // this might still fail if there are some jokers using different relative
161   // paths to the file.  but if it's an absolute name, it should work.
162   for (int i = 0; i < _filename->length(); i++)
163     if ((*_filename)[i] == '\\') (*_filename)[i] = '/';
164
165   // make sure the directory containing the log file exists, if we can.
166   filename temp_file(*_filename);
167   filename temp_dir(temp_file.dirname());
168   if (!temp_dir.good() || !temp_dir.is_directory()) {
169     directory::recursive_create(temp_dir);
170   }
171
172   // if this opening doesn't work, then we just can't log.
173   _outfile = new byte_filer(*_filename, "a+b");
174   return _outfile->good();
175 }
176
177 outcome file_logger::log(const base_string &to_show, int filter)
178 {
179   if (!_file_limit) return common::OKAY;
180
181   size_t current_size = 0;
182   {
183     auto_synchronizer l(*_flock);
184     if (!member(filter)) return common::OKAY;
185     if (!_outfile) open_file();
186     if (!_outfile) return common::BAD_INPUT;  // file opening failed.
187     if (!_outfile->good()) return common::BAD_INPUT;
188       // there is no log file currently.
189   
190     // dump the string out.
191     if (to_show.length())
192       _outfile->write((abyte *)to_show.observe(), to_show.length());
193 //hmmm: need eol feature again.
194 //    if (eol() != NO_ENDING) {
195 //      astring end = get_ending();
196 astring end = parser_bits::platform_eol_to_chars();
197       _outfile->write((abyte *)end.s(), end.length());
198 //    }
199     current_size = _outfile->tell();
200     flush();
201   }
202
203   // check if we need to truncate yet.
204   if (current_size > _file_limit) truncate(_file_limit - size_reduction());
205   return common::OKAY;
206 }
207
208 outcome file_logger::log_bytes(const byte_array &to_log, int filter)
209 {
210   if (!_file_limit) return common::OKAY;
211
212   size_t current_size = 0;
213   {
214     auto_synchronizer l(*_flock);
215     if (!member(filter)) return common::OKAY;
216     if (!_outfile) open_file();
217     if (!_outfile) return common::BAD_INPUT;  // file opening failed.
218     if (!_outfile->good()) return common::BAD_INPUT;
219       // there is no log file currently.
220   
221     // dump the contents out.
222     if (to_log.length())
223       _outfile->write(to_log.observe(), to_log.length());
224     current_size = _outfile->tell();
225     flush();
226   }
227
228   // check if we need to truncate yet.
229   if (current_size > _file_limit)
230     truncate(_file_limit - size_reduction());
231   return common::OKAY;
232 }
233
234 outcome file_logger::format_bytes(const byte_array &to_log, int filter)
235 {
236   if (!_file_limit) return common::OKAY;
237
238   {
239     auto_synchronizer l(*_flock);
240     if (!member(filter)) return common::OKAY;
241     if (!_outfile) open_file();
242     if (!_outfile) return common::BAD_INPUT;  // file opening failed.
243     if (!_outfile->good()) return common::BAD_INPUT;
244       // there is no log file currently.
245   }
246
247   // dump the contents out.
248   if (to_log.length()) {
249     astring dumped_form;
250     byte_formatter::text_dump(dumped_form, to_log);
251     log(dumped_form);
252   }
253
254   // check if we need to truncate yet.
255 //  int current_size = _outfile->tell();
256 //  flush();
257 //  if (current_size > _file_limit) truncate(_file_limit - size_reduction());
258
259   return common::OKAY;
260 }
261
262 //hmmm: should move the truncation functionality into a function on
263 //      the file object.
264
265 void file_logger::truncate(size_t new_size)
266 {
267   auto_synchronizer l(*_flock);
268   if (!_outfile) open_file();
269   if (!_outfile) return;  // file opening failed.
270   if (!_outfile->good()) return;
271     // there is no log file currently.
272
273   size_t current_size = 0;
274
275 ///  // our synchronization scheme allows us to use this inter-application
276 ///  // lock; the logger's own lock is always acquired first.  no one else can
277 ///  // grab the "file_lock", so no deadlocks.
278 ///
279 ///  rendezvous file_lock(*_filename + "_trunclock");
280 ///  if (!file_lock.healthy()) {
281 ///    critical_events::write_to_critical_events((astring("could not create "
282 ///       "lock for ") + *_filename).s());
283 ///    return;
284 ///  }
285 ///  // waiting forever until the file lock succeeds.  as long as there are
286 ///  // no deadlocks permitted, then this shouldn't be too dangerous...
287 ///  bool got_lock = file_lock.lock(rendezvous::ENDLESS_WAIT);
288 ///  if (!got_lock) {
289 ///    critical_events::write_to_critical_events((astring("could not acquire "
290 ///        "lock for ") + *_filename).s());
291 ///    return;
292 ///  }
293
294   // make sure we weren't second in line to clean the file.  if someone else
295   // already did this, we don't need to do it again.
296   _outfile->seek(0, byte_filer::FROM_END);
297   current_size = _outfile->tell();
298   if (current_size <= new_size) {
299     // release the lock and leave since we don't need to change the file.
300 ///    file_lock.unlock();
301     return;
302   }
303   // create a bogus temporary name.
304   astring new_file(astring::SPRINTF, "%s.tmp.%d", name().s(),
305       static_chaos());
306
307   // unlink the temp file, if it exists.
308   unlink(new_file.s());
309
310   // grab the current size before we close our file.
311   current_size = _outfile->tell();
312
313   // redo the main stream for reading also.
314   WHACK(_outfile);
315   _outfile = new byte_filer(*_filename, "rb");
316
317   // open the temp file as blank for writing.
318   byte_filer *hold_stream = new byte_filer(new_file, "w+b");
319
320   int start_of_keep = int(current_size - new_size);
321
322   // position the old file where it will be about the right size.
323   _outfile->seek(start_of_keep, byte_filer::FROM_START);
324
325   astring buff(' ', MAXIMUM_BUFFER_SIZE + 1);
326
327   // we only read as long as the file end isn't hit and we're not past the
328   // original end of the file.  if the file got bigger during the truncation,
329   // that's definitely not our doing and should not be coddled.  we've seen
330   // a situation where we never thought we'd hit the end of the file yet before
331   // adding this size check.
332   size_t bytes_written = 0;  // how many bytes have gone out already.
333 //hmmm: loop could be extracted to some kind of dump from file one into file
334 //      two operation that starts at a particular address and has a particular
335 //      size or range.
336   while (!_outfile->eof() && (bytes_written <= new_size)) {
337     // grab a line from the input file.
338     buff[0] = '\0';  // set it to be an empty string.
339     int bytes_read = _outfile->read((abyte *)buff.s(), MAXIMUM_BUFFER_SIZE);
340     if (!bytes_read)
341       break;
342     bytes_written += bytes_read;
343     // write the line and a CR to the output file.
344     if (!_outfile->eof() || bytes_read)
345       hold_stream->write((abyte *)buff.s(), bytes_read);
346   }
347   WHACK(_outfile);
348   _outfile = new byte_filer(*_filename, "w+b");
349
350   // we think the new stream is ready for writing.
351   size_t hold_size = hold_stream->tell();
352     // get the current length of the clipped chunk.
353   bytes_written = 0;  // reset our counter.
354
355   // jump back to the beginning of the temp file.
356   hold_stream->seek(0, byte_filer::FROM_START);
357   while (!hold_stream->eof() && (bytes_written <= hold_size) ) {
358     // scoot all the old data back into our file.
359     int bytes_read = hold_stream->read((abyte *)buff.s(), MAXIMUM_BUFFER_SIZE);
360     if (!bytes_read)
361       break;
362         // something funky happened; we shouldn't be at the end of the file yet.
363     bytes_written += bytes_read;
364     if (!hold_stream->eof() || bytes_read)
365       _outfile->write((abyte *)buff.s(), bytes_read);
366   }
367   WHACK(hold_stream);
368   unlink(new_file.s());  // trash the temp file.
369 ///  file_lock.unlock();  // repeal the process-wide lock.
370   name(*_filename);  // re-open the regular file with append semantics.
371 }
372
373 } //namespace.
374