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.2 by ajm, Wed Nov 29 21:27:25 2000 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.core.LoggerImpl;
25	<	import uk.ac.ukc.iscream.core.Logger;
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 20 | Line 39 | import java.io.IOException;
39		* @author  $Author$
40		* @version $Id$
41		*/
42	<	class FileLogger implements LoggerImpl {
42	>	public class FileLogger implements LoggerImpl {
43
44		//---FINAL ATTRIBUTES---
45
#	Line 46 | Line 65 | 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.LoggerClassParam1");
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 | class FileLogger implements LoggerImpl {
79		open = true;
80		}
81		catch(IOException e){
82	<	System.out.println(formatLogLine(this.toString(), "Attemp 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(this.toString(), Logger.SYSINIT, "started");
68	<	write(this.toString(), Logger.SYSMSG, "using verbosity " + _verbosityLevel);
85	>	write(toString(), Logger.SYSINIT, "started");
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) {
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
89	–	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){
#	Line 100 | Line 116 | class FileLogger implements LoggerImpl {
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()));
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(formatLogLine(this.toString(), "Write failed: file not open"));
126	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Write failed - file not open"));
127		}
128		}
129
#	Line 120 | Line 136 | class FileLogger implements LoggerImpl {
136		public void clear(){
137		// Check file is open
138		if(open){
139	<	write(this.toString(), Logger.SYSMSG, "Attempting to clear logfile");
139	>	write(toString(), Logger.SYSMSG, "Attempting to clear logfile");
140		try{
141		// Close appending writer
142		open = false;
#	Line 131 | Line 147 | class FileLogger implements LoggerImpl {
147		}
148		catch(IOException e){
149		// We'd best log the error
150	<	write(this.toString(), Logger.ERROR, "Attempt to clear logfile failed: "+e.getMessage());
150	>	write(toString(), Logger.ERROR, "Attempt to clear logfile failed - "+e.getMessage());
151		// As it's an IOException we should suspend logging
152		open = false;
153		}
154		}
155		else{
156		// If file is not open we should print this to the screen
157	<	System.out.println(formatLogLine(this.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 150 | Line 166 | class FileLogger implements LoggerImpl {
166		public void close(){
167		// Check to see if a file is open
168		if(open){
169	<	write(this.toString(), Logger.SYSMSG, "Attempting to terminate logging");
169	>	write(toString(), Logger.SYSMSG, "Attempting to terminate logging");
170		try{
171		open = false;
172		writer.close();
173		}
174		catch(IOException e){
175	<	write(this.toString(), Logger.ERROR, "Attempt to close logfile failed: "+e.getMessage());
175	>	write(toString(), Logger.ERROR, "Attempt to close logfile failed - " + e.getMessage());
176		// As it's an IOException we should suspend logging
177		open = false;
178		}
179		}
180		else{
181		// If file is not open we should print this to the screen
182	<	System.out.println(formatLogLine(this.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 180 | Line 196 | class FileLogger implements LoggerImpl {
196		// Check to see if a file is open
197		if(open){
198		// If file is already open then we should log that this went wrong
199	<	write(this.toString(), Logger.WARNING, "Open failed: a file is already open");
199	>	write(this.toString(), Logger.WARNING, "Open failed - a file is already open");
200		}
201		else{
202		this.filename = filename;
203		if(!fileCheck()) {
204		// Have to system.out.println errors because logging mechanism failed !
205	<	System.out.println(formatLogLine(this.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 196 | Line 212 | class FileLogger implements LoggerImpl {
212		open = true;
213		}
214		catch(IOException e){
215	<	System.out.println(formatLogLine(this.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 211 | Line 227 | class FileLogger implements LoggerImpl {
227		// Check to see if a file is open
228		if(open){
229		// Make a note of the fact that writing has been suspended
230	<	write(this.toString(), Logger.SYSMSG, "Writing suspended");
230	>	write(toString(), Logger.SYSMSG, "Writing suspended");
231		// Make sure writing not permitted
232		open=false;
233		}
234		else{
235		// If file is not open we should print this to the screen
236	<	System.out.println(formatLogLine(this.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 230 | Line 246 | 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(this.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
253		open=true;
254		// Make a note of the fact that writing has been resumed
255	<	write(this.toString(), Logger.SYSMSG, "Writing resumed");
255	>	write(toString(), Logger.SYSMSG, "Writing resumed");
256		}
257		}
258
#	Line 244 | Line 260 | 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.org.iscream.cms.server.util.FormatName class
264	+	* to format the toString()
265	+	*
266		* @return the name of this class and its CVS revision
267		*/
268		public String toString() {
269	<	return this.getClass().getName() + "(" + REVISION.substring(11, REVISION.length() - 2) + ")";
269	>	return FormatName.getName(
270	>	_name,
271	>	getClass().getName(),
272	>	REVISION);
273		}
274
275		//---PRIVATE METHODS---
276
277		/**
256	–	* This method generates a nicely formatted line for the log,
257	–	* including the date/time and the source of the message. The date
258	–	* and time are formatted using the DateFormat class, and the source
259	–	* class is formatted using the toString() method found in every
260	–	* source file. This is then prepended to the message and returned.
261	–	*
262	–	* @param source A string representation of the calling object.
263	–	* @param message The message to be logged.
264	–	* @return The string to be written to the log.
265	–	*/
266	–	private String formatLogLine(String source, String message){
267	–	String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(new Date());
268	–	return "[" + date + "] " + source + ": " + message;
269	–	}
270	–
271	–	/**
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 297 | Line 303 | class FileLogger implements LoggerImpl {
303		}
304		}
305		catch(IOException e){
306	<	System.out.println(formatLogLine(this.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 312 | Line 330 | class FileLogger implements LoggerImpl {
330		*/
331		private String filename;
332
315	–	/**
316	–	* The verbosity level of this instance
317	–	*/
318	–	private int _verbosityLevel;
319	–
333		/**
334		* A reference to the writer being used.
335		*/
#	Line 326 | Line 339 | class FileLogger implements LoggerImpl {
339		* A boolean signifying whether a file is open or not.
340		*/
341		private boolean open = false;
342	+
343	+	/**
344	+	* This is the friendly identifier of the
345	+	* component this class is running in.
346	+	* eg, a Filter may be called "filter1",
347	+	* If this class does not have an owning
348	+	* component,  a name from the configuration
349	+	* can be placed here.  This name could also
350	+	* be changed to null for utility classes.
351	+	*/
352	+	private String _name = Core.NAME;
353
354		//---STATIC ATTRIBUTES---
355

Diff Legend

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