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.1 by tdb, Mon Nov 20 18:34:27 2000 UTC vs.
Revision 1.6 by tdb, Sun Feb 25 20:34:16 2001 UTC

#	Line 1 | Line 1
1		//---PACKAGE DECLARATION---
2	+	package uk.ac.ukc.iscream.core.loggers;
3
4		//---IMPORTS---
5	+	import uk.ac.ukc.iscream.util.*;
6		import uk.ac.ukc.iscream.core.*;
7		import java.util.Date;
8		import java.text.DateFormat;
#	Line 18 | Line 20 | import java.io.IOException;
20		* @author  $Author$
21		* @version $Id$
22		*/
23	<	class FileLogger implements LoggerImpl {
23	>	public class FileLogger implements LoggerImpl {
24
25		//---FINAL ATTRIBUTES---
26
#	Line 44 | Line 46 | class FileLogger implements LoggerImpl {
46		* @throws IOException if there is a problem with the file check.
47		*/
48		public FileLogger() throws IOException{
49	<	_verbosityLevel = Integer.parseInt(System.getProperty("uk.ac.ukc.iscream.Verbosity"));
48	<	filename = System.getProperty("uk.ac.ukc.iscream.LoggerClassParam1");
49	>	filename = System.getProperty("uk.ac.ukc.iscream.LoggerClass.FileLogger.filename");
50		// Perform file check to make sure writing is ok
51		if(!fileCheck()){
52		// Have to system.out.println errors because logging mechanism failed !
53	<	System.out.println(formatLogLine(this.toString(), "File check failed, construction terminated"));
53	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "File check failed, construction terminated"));
54		throw new IOException("File check failed, unable to create FileLog");
55		}
56		try{
#	Line 59 | Line 60 | class FileLogger implements LoggerImpl {
60		open = true;
61		}
62		catch(IOException e){
63	<	System.out.println(formatLogLine(this.toString(), "Attemp to setup writer failed: "+e.getMessage()));
63	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Attempt to setup writer failed - " + e.getMessage()));
64		}
65		// Put an initial line into the log
66	<	write(this.toString(), Logger.SYSINIT, "started");
66	<	write(this.toString(), Logger.SYSMSG, "using verbosity " + _verbosityLevel);
66	>	write(toString(), Logger.SYSINIT, "started");
67		}
68
69		//---PUBLIC METHODS---
#	Line 80 | Line 80 | class FileLogger implements LoggerImpl {
80		* @param source A string representation of the calling object.
81		* @param message The message to be logged.
82		*/
83	<	public synchronized void write(String source, int verbosity, String message) {
83	>	public synchronized void write(String line, int verbosity) {
84		// Check to make sure file is open
85		if(open){
86		// Produce a nicely formatted line for the logfile
87	–	String line = formatLogLine(source, message);
87		try{
88		// We have to synchronize here due to problems with two write()'s being called before a newLine()
89		synchronized(writer){
#	Line 98 | Line 97 | class FileLogger implements LoggerImpl {
97		}
98		catch(IOException e){
99		// We'd best log the error
100	<	System.out.println(formatLogLine(this.toString(), "Writing to logfile failed: "+e.getMessage()));
100	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Writing to logfile failed - " + e.getMessage()));
101		// As it's an IOException we should suspend logging
102		open = false;
103		}
104		}
105		else{
106		// If file is not open we should print this to the screen
107	<	System.out.println(formatLogLine(this.toString(), "Write failed: file not open"));
107	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Write failed - file not open"));
108		}
109		}
110
#	Line 118 | Line 117 | class FileLogger implements LoggerImpl {
117		public void clear(){
118		// Check file is open
119		if(open){
120	<	write(this.toString(), Logger.SYSMSG, "Attempting to clear logfile");
120	>	write(toString(), Logger.SYSMSG, "Attempting to clear logfile");
121		try{
122		// Close appending writer
123		open = false;
#	Line 129 | Line 128 | class FileLogger implements LoggerImpl {
128		}
129		catch(IOException e){
130		// We'd best log the error
131	<	write(this.toString(), Logger.ERROR, "Attempt to clear logfile failed: "+e.getMessage());
131	>	write(toString(), Logger.ERROR, "Attempt to clear logfile failed - "+e.getMessage());
132		// As it's an IOException we should suspend logging
133		open = false;
134		}
135		}
136		else{
137		// If file is not open we should print this to the screen
138	<	System.out.println(formatLogLine(this.toString(), "Clearing failed: file not open"));
138	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Clearing failed - file not open"));
139		}
140		}
141
#	Line 148 | Line 147 | class FileLogger implements LoggerImpl {
147		public void close(){
148		// Check to see if a file is open
149		if(open){
150	<	write(this.toString(), Logger.SYSMSG, "Attempting to terminate logging");
150	>	write(toString(), Logger.SYSMSG, "Attempting to terminate logging");
151		try{
152		open = false;
153		writer.close();
154		}
155		catch(IOException e){
156	<	write(this.toString(), Logger.ERROR, "Attempt to close logfile failed: "+e.getMessage());
156	>	write(toString(), Logger.ERROR, "Attempt to close logfile failed - " + e.getMessage());
157		// As it's an IOException we should suspend logging
158		open = false;
159		}
160		}
161		else{
162		// If file is not open we should print this to the screen
163	<	System.out.println(formatLogLine(this.toString(), "Close failed: file not open"));
163	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Close failed - file not open"));
164		}
165		}
166
#	Line 178 | Line 177 | class FileLogger implements LoggerImpl {
177		// Check to see if a file is open
178		if(open){
179		// If file is already open then we should log that this went wrong
180	<	write(this.toString(), Logger.WARNING, "Open failed: a file is already open");
180	>	write(this.toString(), Logger.WARNING, "Open failed - a file is already open");
181		}
182		else{
183		this.filename = filename;
184		if(!fileCheck()) {
185		// Have to system.out.println errors because logging mechanism failed !
186	<	System.out.println(formatLogLine(this.toString(), "File check failed, construction terminated"));
186	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "File check failed, construction terminated"));
187		throw new IOException("File check failed, unable to create FileLog");
188		}
189		try{
#	Line 194 | Line 193 | class FileLogger implements LoggerImpl {
193		open = true;
194		}
195		catch(IOException e){
196	<	System.out.println(formatLogLine(this.toString(), "Attempt to open writer failed: "+e.getMessage()));
196	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Attempt to open writer failed - " + e.getMessage()));
197		}
198		}
199		}
#	Line 209 | Line 208 | class FileLogger implements LoggerImpl {
208		// Check to see if a file is open
209		if(open){
210		// Make a note of the fact that writing has been suspended
211	<	write(this.toString(), Logger.SYSMSG, "Writing suspended");
211	>	write(toString(), Logger.SYSMSG, "Writing suspended");
212		// Make sure writing not permitted
213		open=false;
214		}
215		else{
216		// If file is not open we should print this to the screen
217	<	System.out.println(formatLogLine(this.toString(), "Suspend failed: file not open"));
217	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Suspend failed - file not open"));
218		}
219		}
220
#	Line 228 | Line 227 | class FileLogger implements LoggerImpl {
227		// Check to see if a file is open
228		if(open){
229		// If file is open we should print this to the screen
230	<	System.out.println(formatLogLine(this.toString(), "Resume failed: file open"));
230	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "Resume failed - file open"));
231		}
232		else{
233		// Permit writing again
234		open=true;
235		// Make a note of the fact that writing has been resumed
236	<	write(this.toString(), Logger.SYSMSG, "Writing resumed");
236	>	write(toString(), Logger.SYSMSG, "Writing resumed");
237		}
238		}
239
#	Line 242 | Line 241 | class FileLogger implements LoggerImpl {
241		* Overrides the {@link java.lang.Object#toString() Object.toString()}
242		* method to provide clean logging (every class should have this).
243		*
244	+	* This uses the uk.ac.ukc.iscream.util.FormatName class
245	+	* to format the toString()
246	+	*
247		* @return the name of this class and its CVS revision
248		*/
249		public String toString() {
250	<	return this.getClass().getName() + "(" + REVISION.substring(11, REVISION.length() - 2) + ")";
250	>	return FormatName.getName(
251	>	_name,
252	>	getClass().getName(),
253	>	REVISION);
254		}
255
256		//---PRIVATE METHODS---
257
258		/**
254	–	* This method generates a nicely formatted line for the log,
255	–	* including the date/time and the source of the message. The date
256	–	* and time are formatted using the DateFormat class, and the source
257	–	* class is formatted using the toString() method found in every
258	–	* source file. This is then prepended to the message and returned.
259	–	*
260	–	* @param source A string representation of the calling object.
261	–	* @param message The message to be logged.
262	–	* @return The string to be written to the log.
263	–	*/
264	–	private String formatLogLine(String source, String message){
265	–	String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(new Date());
266	–	return "[" + date + "] " + source + ": " + message;
267	–	}
268	–
269	–	/**
259		* The fileCheck() method is used to ensure that writing is ok. It
260		* performs so basic checks to make sure that if the file exists
261		* it can be written to, and if not a new file is created. A boolean
#	Line 295 | Line 284 | class FileLogger implements LoggerImpl {
284		}
285		}
286		catch(IOException e){
287	<	System.out.println(formatLogLine(this.toString(), "File check failed: "+e.getMessage()));
287	>	System.out.println(FormatName.formatLogLine(this.toString(), Logger.FATAL, "File check failed - "+e.getMessage()));
288		}
289
290		return fileOK;
291		}
292
293	+	private void write(String source, int verbosity, String message) {
294	+	write(FormatName.formatLogLine(source, verbosity, message), verbosity);
295	+	}
296	+
297		//---ACCESSOR/MUTATOR METHODS---
298
299		//---ATTRIBUTES---
#	Line 310 | Line 303 | class FileLogger implements LoggerImpl {
303		*/
304		private String filename;
305
313	–	/**
314	–	* The verbosity level of this instance
315	–	*/
316	–	private int _verbosityLevel;
317	–
306		/**
307		* A reference to the writer being used.
308		*/
#	Line 324 | Line 312 | class FileLogger implements LoggerImpl {
312		* A boolean signifying whether a file is open or not.
313		*/
314		private boolean open = false;
315	+
316	+	/**
317	+	* This is the friendly identifier of the
318	+	* component this class is running in.
319	+	* eg, a Filter may be called "filter1",
320	+	* If this class does not have an owning
321	+	* component,  a name from the configuration
322	+	* can be placed here.  This name could also
323	+	* be changed to null for utility classes.
324	+	*/
325	+	private String _name = Core.NAME;
326
327		//---STATIC ATTRIBUTES---
328

Diff Legend

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