ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/cms/source/server/uk/org/iscream/cms/server/core/loggers/FileLogger.java

Comparing projects/cms/source/server/uk/org/iscream/cms/server/core/loggers/FileLogger.java (file contents):
Revision 1.5 by tdb, Sun Jan 28 19:57:59 2001 UTC vs.
Revision 1.12 by tdb, Wed Feb 5 16:43:47 2003 UTC

#	Line 1 | Line 1
1	+	/*
2	+	* i-scream central monitoring system
3	+	* http://www.i-scream.org.uk
4	+	* Copyright (C) 2000-2002 i-scream
5	+	*
6	+	* This program is free software; you can redistribute it and/or
7	+	* modify it under the terms of the GNU General Public License
8	+	* as published by the Free Software Foundation; either version 2
9	+	* of the License, or (at your option) any later version.
10	+	*
11	+	* This program is distributed in the hope that it will be useful,
12	+	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	+	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14	+	* GNU General Public License for more details.
15	+	*
16	+	* You should have received a copy of the GNU General Public License
17	+	* along with this program; if not, write to the Free Software
18	+	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19	+	*/
20	+
21		//---PACKAGE DECLARATION---
22	<	package uk.ac.ukc.iscream.core.loggers;
22	>	package uk.org.iscream.cms.server.core.loggers;
23
24		//---IMPORTS---
25	<	import uk.ac.ukc.iscream.util.*;
26	<	import uk.ac.ukc.iscream.core.*;
25	>	import uk.org.iscream.cms.util.*;
26	>	import uk.org.iscream.cms.server.core.*;
27		import java.util.Date;
28		import java.text.DateFormat;
29		import java.util.Locale;
#	Line 46 | Line 66 | public class FileLogger implements LoggerImpl {
66		* @throws IOException if there is a problem with the file check.
67		*/
68		public FileLogger() throws IOException{
69	<	_verbosityLevel = Integer.parseInt(System.getProperty("uk.ac.ukc.iscream.Verbosity"));
50	<	filename = System.getProperty("uk.ac.ukc.iscream.LoggerClass.FileLogger.filename");
69	>	filename = System.getProperty("uk.org.iscream.cms.server.LoggerClass.FileLogger.filename");
70		// Perform file check to make sure writing is ok
71		if(!fileCheck()){
72		// Have to system.out.println errors because logging mechanism failed !
73	<	System.out.println(formatLogLine(this.toString(), "File check failed, construction terminated"));
73	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "File check failed, construction terminated"));
74		throw new IOException("File check failed, unable to create FileLog");
75		}
76		try{
#	Line 61 | Line 80 | public class FileLogger implements LoggerImpl {
80		open = true;
81		}
82		catch(IOException e){
83	<	System.out.println(formatLogLine(toString(), "Attempt to setup writer failed - " + e.getMessage()));
83	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Attempt to setup writer failed - " + e.getMessage()));
84		}
85		// Put an initial line into the log
86		write(toString(), Logger.SYSINIT, "started");
68	–	write(toString(), Logger.SYSMSG, "using verbosity " + _verbosityLevel);
87		}
88
89		//---PUBLIC METHODS---
90
91	<	/**
92	<	* The write() method writes a line of log to the file, prepending
93	<	* it with some information about where to line came from and the
94	<	* date. This formatting is handled by the formatLogLine() method.
95	<	* There is some synchronisation here due to problems with the logfiles
96	<	* having multiple lines written on the same line, followed by dotted
79	<	* newlines in the wrong places. This is due to this method being
80	<	* called by multiple threads.
91	>	/**
92	>	* The write() method takes a line of text, pre-formatted
93	>	* and outputs it using a method defined by the actual
94	>	* implementation. The verbosity is given in case the
95	>	* implementation wishes to utilise it in the layout -
96	>	* eg. a different colour or font.
97		*
98	<	* @param source A string representation of the calling object.
99	<	* @param message The message to be logged.
100	<	*/
101	<	public synchronized void write(String source, int verbosity, String message) {
102	<	if (verbosity <= _verbosityLevel) {
103	<	// Check to make sure file is open
104	<	if(open){
105	<	// Produce a nicely formatted line for the logfile
106	<	String line = formatLogLine(source, message);
107	<	try{
108	<	// We have to synchronize here due to problems with two write()'s being called before a newLine()
109	<	synchronized(writer){
110	<	// Attempt to write the line
111	<	writer.write(line);
112	<	// Best to use newLine() as it will use the correct platform encoding
113	<	writer.newLine();
114	<	}
115	<	// Make sure the line is written immeidiately
116	<	writer.flush();
117	<	}
118	<	catch(IOException e){
119	<	// We'd best log the error
120	<	System.out.println(formatLogLine(this.toString(), "Writing to logfile failed - " + e.getMessage()));
121	<	// As it's an IOException we should suspend logging
122	<	open = false;
123	<	}
124	<	}
125	<	else{
126	<	// If file is not open we should print this to the screen
127	<	System.out.println(formatLogLine(this.toString(), "Write failed - file not open"));
128	<	}
113	<	}
98	>	* This instance writes the line to a file.
99	>	*
100	>	* @param line A line of formatted text to be logged
101	>	* @param verbosity the verbosity of this message
102	>	*/
103	>	public synchronized void write(String line, int verbosity) {
104	>	// Check to make sure file is open
105	>	if(open){
106	>	// Produce a nicely formatted line for the logfile
107	>	try{
108	>	// We have to synchronize here due to problems with two write()'s being called before a newLine()
109	>	synchronized(writer){
110	>	// Attempt to write the line
111	>	writer.write(line);
112	>	// Best to use newLine() as it will use the correct platform encoding
113	>	writer.newLine();
114	>	}
115	>	// Make sure the line is written immeidiately
116	>	writer.flush();
117	>	}
118	>	catch(IOException e){
119	>	// We'd best log the error
120	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Writing to logfile failed - " + e.getMessage()));
121	>	// As it's an IOException we should suspend logging
122	>	open = false;
123	>	}
124	>	}
125	>	else{
126	>	// If file is not open we should print this to the screen
127	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Write failed - file not open"));
128	>	}
129		}
130
131		/**
#	Line 140 | Line 155 | public class FileLogger implements LoggerImpl {
155		}
156		else{
157		// If file is not open we should print this to the screen
158	<	System.out.println(formatLogLine(toString(), "Clearing failed - file not open"));
158	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Clearing failed - file not open"));
159		}
160		}
161
#	Line 165 | Line 180 | public class FileLogger implements LoggerImpl {
180		}
181		else{
182		// If file is not open we should print this to the screen
183	<	System.out.println(formatLogLine(toString(), "Close failed - file not open"));
183	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Close failed - file not open"));
184		}
185		}
186
#	Line 188 | Line 203 | public class FileLogger implements LoggerImpl {
203		this.filename = filename;
204		if(!fileCheck()) {
205		// Have to system.out.println errors because logging mechanism failed !
206	<	System.out.println(formatLogLine(toString(), "File check failed, construction terminated"));
206	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "File check failed, construction terminated"));
207		throw new IOException("File check failed, unable to create FileLog");
208		}
209		try{
#	Line 198 | Line 213 | public class FileLogger implements LoggerImpl {
213		open = true;
214		}
215		catch(IOException e){
216	<	System.out.println(formatLogLine(toString(), "Attempt to open writer failed - " + e.getMessage()));
216	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Attempt to open writer failed - " + e.getMessage()));
217		}
218		}
219		}
#	Line 219 | Line 234 | public class FileLogger implements LoggerImpl {
234		}
235		else{
236		// If file is not open we should print this to the screen
237	<	System.out.println(formatLogLine(toString(), "Suspend failed - file not open"));
237	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Suspend failed - file not open"));
238		}
239		}
240
#	Line 232 | Line 247 | public class FileLogger implements LoggerImpl {
247		// Check to see if a file is open
248		if(open){
249		// If file is open we should print this to the screen
250	<	System.out.println(formatLogLine(toString(), "Resume failed - file open"));
250	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Resume failed - file open"));
251		}
252		else{
253		// Permit writing again
#	Line 246 | Line 261 | public class FileLogger implements LoggerImpl {
261		* Overrides the {@link java.lang.Object#toString() Object.toString()}
262		* method to provide clean logging (every class should have this).
263		*
264	<	* This uses the uk.ac.ukc.iscream.util.FormatName class
264	>	* This uses the uk.org.iscream.cms.util.FormatName class
265		* to format the toString()
266		*
267		* @return the name of this class and its CVS revision
#	Line 261 | Line 276 | public class FileLogger implements LoggerImpl {
276		//---PRIVATE METHODS---
277
278		/**
264	–	* This method generates a nicely formatted line for the log,
265	–	* including the date/time and the source of the message. The date
266	–	* and time are formatted using the DateFormat class, and the source
267	–	* class is formatted using the toString() method found in every
268	–	* source file. This is then prepended to the message and returned.
269	–	*
270	–	* @param source A string representation of the calling object.
271	–	* @param message The message to be logged.
272	–	* @return The string to be written to the log.
273	–	*/
274	–	private String formatLogLine(String source, String message){
275	–	String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(new Date());
276	–	return "[" + date + "] " + source + ": " + message;
277	–	}
278	–
279	–	/**
279		* The fileCheck() method is used to ensure that writing is ok. It
280		* performs so basic checks to make sure that if the file exists
281		* it can be written to, and if not a new file is created. A boolean
#	Line 305 | Line 304 | public class FileLogger implements LoggerImpl {
304		}
305		}
306		catch(IOException e){
307	<	System.out.println(formatLogLine(toString(), "File check failed - "+e.getMessage()));
307	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "File check failed - "+e.getMessage()));
308		}
309
310		return fileOK;
311		}
312
313	+	/**
314	+	* This method is provided if this class wishes to log
315	+	* a message itself.
316	+	*
317	+	* @param source A String representation of the source
318	+	* @param verbosity the verbosity of this message
319	+	* @param message The message to log
320	+	*/
321	+	private void write(String source, int verbosity, String message) {
322	+	write(FormatName.formatLogLine(source, verbosity, message), verbosity);
323	+	}
324	+
325		//---ACCESSOR/MUTATOR METHODS---
326
327		//---ATTRIBUTES---
#	Line 319 | Line 330 | public class FileLogger implements LoggerImpl {
330		* The filename of the currently open, or last open, file.
331		*/
332		private String filename;
322	–
323	–	/**
324	–	* The verbosity level of this instance
325	–	*/
326	–	private int _verbosityLevel;
333
334		/**
335		* A reference to the writer being used.

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines