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.10 by tdb, Sat May 18 18:16:01 2002 UTC

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

Diff Legend

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