server/Logger/FileLog.java

import java.util.Date;
import java.text.DateFormat;
import java.util.Locale;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * FileLog <br> <br>
 * 
 * The FileLog class is an implementation of the Log interface, and as the
 * name suggest writes all output to a file. The filename is specified
 * during construction, and there is no default for a no-arg constructor.
 * Various checks are carried out to check that writing will be possible and
 * an IOException is thrown if for some reason it fails. If the file exists
 * then the write() method will append to it. <br> <br>
 * 
 * Revision History: <br>
 * 1.8 - Added a fix to the write() method to ensure log is synchronised correctly [28/04/00] <br>
 * 1.7 - Added suspend() and resume() methods [26/04/00] <br>
 * 1.6 - Added open() method so that a new log file can be opened after a close() [26/04/00] <br>
 * 1.5 - Made sure writing cannot be attempted when logfile not open [26/04/00] <br>
 * 1.4 - Method of clearing the logfile improved [26/04/00] <br>
 * 1.3 - Improved javadoc comments and tidied up [26/04/00] <br>
 * 1.2 - Used the .newLine() method to write a new line, rather than \n [14/04/00] <br>
 * 1.1 - Used an interface to create seperate File & Screen logs [15/03/00] <br>
 * 1.0 - Original File-only version <br>
 * 
 * @author T.D.Bishop [tdb1@ukc.ac.uk]
 * @version 1.8, 28/04/2000
 */
public class FileLog implements Log {
    
        /**
         * This attribute is used by the Server class to print out versions
         * of all class files that form the server on startup.
         */
    public static String version = "1.8, 28/04/2000";
    
        /**
         * The constructor checks that writing will be ok, then sets up the
         * writer. It makes use of the fileCheck() method found later on to
         * ensure writing will be ok, and throws an IOException if there is
         * a problem. Errors at this stage cannot be logged because the
         * logging mechanism has not be setup completely, so any problems
         * are printed to the screen in the same format used for logging.
         * 
         * @param filename The filename to which logging should be written.
         * @throws IOException if there is a problem with the file check.
         */
    public FileLog(String filename) throws IOException{
        this.filename = filename;
                // Perform file check to make sure writing is ok
        if(!fileCheck()){
                        // Have to system.out.println errors because logging mechanism failed !
            System.out.println(formatLogLine(this, "File check failed, construction terminated"));
            throw new IOException("File check failed, unable to create FileLog");
        }
        try{
                        // Setup the writer
            writer = new BufferedWriter(new FileWriter(filename, true));
                        // File is now open
                        open = true;
        }
        catch(IOException e){
            System.out.println(formatLogLine(this, "Attemp to setup writer failed: "+e.getMessage()));
        }
                // Put an initial line into the log
        write(this, "Logging initialised");
    }
    
        /**
         * The write() method writes a line of log to the file, prepending
         * it with some information about where to line came from and the
         * date. This formatting is handled by the formatLogLine() method.
         * There is some synchronisation here due to problems with the logfiles
         * having multiple lines written on the same line, followed by dotted
         * newlines in the wrong places. This is due to this method being
         * called by multiple threads.
         * 
         * @param source A reference to the source of the message.
         * @param input The message to be logged.
         */
    public void write(Object source, String input){
                // Check to make sure file is open
                if(open){
                        // Produce a nicely formatted line for the logfile
                        String line = formatLogLine(source, input);
                        try{
                                // We have to synchronize here due to problems with two write()'s being called before a newLine()
                                synchronized(writer){
                                        // Attempt to write the line
                                        writer.write(line);
                                        // Best to use newLine() as it will use the correct platform encoding
                                        writer.newLine();
                                }
                                // Make sure the line is written immeidiately
                                writer.flush();
                        }
                        catch(IOException e){
                                // We'd best log the error
                        System.out.println(formatLogLine(this, "Writing to logfile failed: "+e.getMessage()));
                                // As it's an IOException we should suspend logging
                                open = false;
                }
                }
                else{
                        // If file is not open we should print this to the screen
                        System.out.println(formatLogLine(this, "Write failed: file not open"));
                }
    }
    
        /**
         * This method generates a nicely formatted line for the logfile,
         * including the date/time and the source of the message. The date
         * and time are formatted using the DateFormat class, and the source
         * class is formatted using the toString() method found in every
         * source file for the server. This is then prepended to the message
         * and returned.
         * 
         * @param source A reference to the source of the message.
         * @param input The message to be logged.
         * @return The string to be written to the log.
         */
    private String formatLogLine(Object source, String input){
                // Construct the date string using the DateFormat class
        String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(new Date());
                // Return the date, the toString() of the source and the input
        return "[" + date + "] " + source.toString() + ": " + input;
    }
        
    /**
         * The toString() method returns the name of the Class for formatting
         * when it writes to the logfile. <br>
         * 
         * @return The formatted string identifying this Class.
         */
    public String toString(){
        return this.getClass().getName();
    }
    
        /**
         * The clear() method erases the contents of the logfile. It does
         * this in a very clumsy way - by closing the writer and opening a
         * new one which is set not to append. This results in the logfile
         * being overwritten, which effectively erases it.
         */
    public void clear(){
                // Check file is open
                if(open){
                        write(this, "Attempting to clear logfile");
                        try{
                                // Close appending writer
                                open = false;
                                writer.close();
                                // Open a non-appending writer
                                writer = new BufferedWriter(new FileWriter(filename));
                                open = true;
                        }
                        catch(IOException e){
                                // We'd best log the error
                                write(this, "Attempt to clear logfile failed: "+e.getMessage());
                                // As it's an IOException we should suspend logging
                                open = false;
                        }
                }
                else{
                        // If file is not open we should print this to the screen
                        System.out.println(formatLogLine(this, "Clearing failed: file not open"));
                }
    }
    
        /**
         * The close() method closes the logfile and no more data can be written.
         * If writing is attempted after close() has been called an error will be
         * generated. The open() method can be used to reopen or open a new file.
         */
    public void close(){
                // Check to see if a file is open
                if(open){
                        write(this, "Attempting to terminate logging");
                        try{
                                open = false;
                        writer.close();         
                        }
                        catch(IOException e){
                                write(this, "Attempt to close logfile failed: "+e.getMessage());
                                // As it's an IOException we should suspend logging
                                open = false;
                        }
                }
                else{
                        // If file is not open we should print this to the screen
                        System.out.println(formatLogLine(this, "Close failed: file not open"));
                }
    }
    
        /**
         * The open() method opens a new file after the close() method has
         * been called on the FileLog. This enables the user to easily change
         * the file to which the log is being written. An error is generated
         * if a file is already open.
         * 
         * @param filename The new file to write to.
         * @throws IOException if the file cannot be written to.
         */
        public void open(String filename) throws IOException{
                // Check to see if a file is open
                if(open){
                        // If file is already open then we should log that this went wrong
                        write(this, "Open failed: a file is already open");
                }
                else{
                        this.filename = filename;
                        if(!fileCheck()) {
                                // Have to system.out.println errors because logging mechanism failed !
                                System.out.println(formatLogLine(this, "File check failed, construction terminated"));
                                throw new IOException("File check failed, unable to create FileLog");
                        }
                        try{
                                // Setup the writer
                                writer = new BufferedWriter(new FileWriter(filename, true));
                                // File is now open
                                open = true;
                        }
                        catch(IOException e){
                                System.out.println(formatLogLine(this, "Attempt to open writer failed: "+e.getMessage()));
                        }
                }
        }
        
        /**
         * The suspend() method halts writing to the file by setting the open
         * boolean to false, and thus blocking the write() method. A line is
         * written to the logfile beforehand to note that writing has been
         * suspended.
         */
        public void suspend(){
                // Check to see if a file is open
                if(open){
                        // Make a note of the fact that writing has been suspended
                        write(this, "Writing suspended");
                        // Make sure writing not permitted
                        open=false;
                }
                else{
                        // If file is not open we should print this to the screen
                        System.out.println(formatLogLine(this, "Suspend failed: file not open"));
                }
        }
        
        /**
         * The resume() method resumes writing to the file by setting the open
         * boolean to true. A line is written to the logfile to signify this
         * event occuring.
         */
        public void resume(){
                // Check to see if a file is open
                if(open){
                        // If file is open we should print this to the screen
                        System.out.println(formatLogLine(this, "Resume failed: file open"));
                }
                else{
                        // Permit writing again
                        open=true;
                        // Make a note of the fact that writing has been resumed
                        write(this, "Writing resumed");
                }
        }
        
        /**
         * The fileCheck() method is used to ensure that writing is ok. It
         * performs so basic checks to make sure that if the file exists
         * it can be written to, and if not a new file is created. A boolean
         * result is returned to signify success or failure.
         * 
         * @return A boolean value signify whether the test was sucessful.
         */
    private boolean fileCheck(){
        boolean fileOK = false;
        try{
            File file = new File(filename);
                        
                        // File already exists
            if(file.exists()) {
                /* Only want success if it is a file (not a directory)
                                 * and can be written to.
                                 */
                                if(file.isFile() && file.canWrite()) {
                    fileOK = true;
                }
            }
                        // Create a new file and suceed
            else{
                file.createNewFile();
                fileOK = true;
            }
        }
        catch(IOException e){
            System.out.println(formatLogLine(this, "File check failed: "+e.getMessage()));
        }
        
        return fileOK;
    }
    
        /**
         * The filename of the currently open, or last open, file.
         */
    private String filename;
        
        /**
         * A reference to the writer being used.
         */
    private BufferedWriter writer;
        
        /**
         * A boolean signifying whether a file is open or not.
         */
        private boolean open = false;
    
}
Revision:	1.1
Committed:	Mon Nov 6 21:28:53 2000 UTC (24 years, 1 month ago) by tdb
Branch:	MAIN
CVS Tags:	PROJECT_COMPLETION, HEAD
Error occurred while calculating annotation data.
Log Message:	File Logging implementation of the logging mechanism interface.
#	Content
1	import java.util.Date;
2	import java.text.DateFormat;
3	import java.util.Locale;
4	import java.io.BufferedWriter;
5	import java.io.File;
6	import java.io.FileWriter;
7	import java.io.IOException;
8
9	/**
10	* FileLog <br> <br>
11	*
12	* The FileLog class is an implementation of the Log interface, and as the
13	* name suggest writes all output to a file. The filename is specified
14	* during construction, and there is no default for a no-arg constructor.
15	* Various checks are carried out to check that writing will be possible and
16	* an IOException is thrown if for some reason it fails. If the file exists
17	* then the write() method will append to it. <br> <br>
18	*
19	* Revision History: <br>
20	* 1.8 - Added a fix to the write() method to ensure log is synchronised correctly [28/04/00] <br>
21	* 1.7 - Added suspend() and resume() methods [26/04/00] <br>
22	* 1.6 - Added open() method so that a new log file can be opened after a close() [26/04/00] <br>
23	* 1.5 - Made sure writing cannot be attempted when logfile not open [26/04/00] <br>
24	* 1.4 - Method of clearing the logfile improved [26/04/00] <br>
25	* 1.3 - Improved javadoc comments and tidied up [26/04/00] <br>
26	* 1.2 - Used the .newLine() method to write a new line, rather than \n [14/04/00] <br>
27	* 1.1 - Used an interface to create seperate File & Screen logs [15/03/00] <br>
28	* 1.0 - Original File-only version <br>
29	*
30	* @author T.D.Bishop [tdb1@ukc.ac.uk]
31	* @version 1.8, 28/04/2000
32	*/
33	public class FileLog implements Log {
34
35	/**
36	* This attribute is used by the Server class to print out versions
37	* of all class files that form the server on startup.
38	*/
39	public static String version = "1.8, 28/04/2000";
40
41	/**
42	* The constructor checks that writing will be ok, then sets up the
43	* writer. It makes use of the fileCheck() method found later on to
44	* ensure writing will be ok, and throws an IOException if there is
45	* a problem. Errors at this stage cannot be logged because the
46	* logging mechanism has not be setup completely, so any problems
47	* are printed to the screen in the same format used for logging.
48	*
49	* @param filename The filename to which logging should be written.
50	* @throws IOException if there is a problem with the file check.
51	*/
52	public FileLog(String filename) throws IOException{
53	this.filename = filename;
54	// Perform file check to make sure writing is ok
55	if(!fileCheck()){
56	// Have to system.out.println errors because logging mechanism failed !
57	System.out.println(formatLogLine(this, "File check failed, construction terminated"));
58	throw new IOException("File check failed, unable to create FileLog");
59	}
60	try{
61	// Setup the writer
62	writer = new BufferedWriter(new FileWriter(filename, true));
63	// File is now open
64	open = true;
65	}
66	catch(IOException e){
67	System.out.println(formatLogLine(this, "Attemp to setup writer failed: "+e.getMessage()));
68	}
69	// Put an initial line into the log
70	write(this, "Logging initialised");
71	}
72
73	/**
74	* The write() method writes a line of log to the file, prepending
75	* it with some information about where to line came from and the
76	* date. This formatting is handled by the formatLogLine() method.
77	* There is some synchronisation here due to problems with the logfiles
78	* 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.
81	*
82	* @param source A reference to the source of the message.
83	* @param input The message to be logged.
84	*/
85	public void write(Object source, String input){
86	// Check to make sure file is open
87	if(open){
88	// Produce a nicely formatted line for the logfile
89	String line = formatLogLine(source, input);
90	try{
91	// We have to synchronize here due to problems with two write()'s being called before a newLine()
92	synchronized(writer){
93	// Attempt to write the line
94	writer.write(line);
95	// Best to use newLine() as it will use the correct platform encoding
96	writer.newLine();
97	}
98	// Make sure the line is written immeidiately
99	writer.flush();
100	}
101	catch(IOException e){
102	// We'd best log the error
103	System.out.println(formatLogLine(this, "Writing to logfile failed: "+e.getMessage()));
104	// As it's an IOException we should suspend logging
105	open = false;
106	}
107	}
108	else{
109	// If file is not open we should print this to the screen
110	System.out.println(formatLogLine(this, "Write failed: file not open"));
111	}
112	}
113
114	/**
115	* This method generates a nicely formatted line for the logfile,
116	* including the date/time and the source of the message. The date
117	* and time are formatted using the DateFormat class, and the source
118	* class is formatted using the toString() method found in every
119	* source file for the server. This is then prepended to the message
120	* and returned.
121	*
122	* @param source A reference to the source of the message.
123	* @param input The message to be logged.
124	* @return The string to be written to the log.
125	*/
126	private String formatLogLine(Object source, String input){
127	// Construct the date string using the DateFormat class
128	String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(new Date());
129	// Return the date, the toString() of the source and the input
130	return "[" + date + "] " + source.toString() + ": " + input;
131	}
132
133	/**
134	* The toString() method returns the name of the Class for formatting
135	* when it writes to the logfile. <br>
136	*
137	* @return The formatted string identifying this Class.
138	*/
139	public String toString(){
140	return this.getClass().getName();
141	}
142
143	/**
144	* The clear() method erases the contents of the logfile. It does
145	* this in a very clumsy way - by closing the writer and opening a
146	* new one which is set not to append. This results in the logfile
147	* being overwritten, which effectively erases it.
148	*/
149	public void clear(){
150	// Check file is open
151	if(open){
152	write(this, "Attempting to clear logfile");
153	try{
154	// Close appending writer
155	open = false;
156	writer.close();
157	// Open a non-appending writer
158	writer = new BufferedWriter(new FileWriter(filename));
159	open = true;
160	}
161	catch(IOException e){
162	// We'd best log the error
163	write(this, "Attempt to clear logfile failed: "+e.getMessage());
164	// As it's an IOException we should suspend logging
165	open = false;
166	}
167	}
168	else{
169	// If file is not open we should print this to the screen
170	System.out.println(formatLogLine(this, "Clearing failed: file not open"));
171	}
172	}
173
174	/**
175	* The close() method closes the logfile and no more data can be written.
176	* If writing is attempted after close() has been called an error will be
177	* generated. The open() method can be used to reopen or open a new file.
178	*/
179	public void close(){
180	// Check to see if a file is open
181	if(open){
182	write(this, "Attempting to terminate logging");
183	try{
184	open = false;
185	writer.close();
186	}
187	catch(IOException e){
188	write(this, "Attempt to close logfile failed: "+e.getMessage());
189	// As it's an IOException we should suspend logging
190	open = false;
191	}
192	}
193	else{
194	// If file is not open we should print this to the screen
195	System.out.println(formatLogLine(this, "Close failed: file not open"));
196	}
197	}
198
199	/**
200	* The open() method opens a new file after the close() method has
201	* been called on the FileLog. This enables the user to easily change
202	* the file to which the log is being written. An error is generated
203	* if a file is already open.
204	*
205	* @param filename The new file to write to.
206	* @throws IOException if the file cannot be written to.
207	*/
208	public void open(String filename) throws IOException{
209	// Check to see if a file is open
210	if(open){
211	// If file is already open then we should log that this went wrong
212	write(this, "Open failed: a file is already open");
213	}
214	else{
215	this.filename = filename;
216	if(!fileCheck()) {
217	// Have to system.out.println errors because logging mechanism failed !
218	System.out.println(formatLogLine(this, "File check failed, construction terminated"));
219	throw new IOException("File check failed, unable to create FileLog");
220	}
221	try{
222	// Setup the writer
223	writer = new BufferedWriter(new FileWriter(filename, true));
224	// File is now open
225	open = true;
226	}
227	catch(IOException e){
228	System.out.println(formatLogLine(this, "Attempt to open writer failed: "+e.getMessage()));
229	}
230	}
231	}
232
233	/**
234	* The suspend() method halts writing to the file by setting the open
235	* boolean to false, and thus blocking the write() method. A line is
236	* written to the logfile beforehand to note that writing has been
237	* suspended.
238	*/
239	public void suspend(){
240	// Check to see if a file is open
241	if(open){
242	// Make a note of the fact that writing has been suspended
243	write(this, "Writing suspended");
244	// Make sure writing not permitted
245	open=false;
246	}
247	else{
248	// If file is not open we should print this to the screen
249	System.out.println(formatLogLine(this, "Suspend failed: file not open"));
250	}
251	}
252
253	/**
254	* The resume() method resumes writing to the file by setting the open
255	* boolean to true. A line is written to the logfile to signify this
256	* event occuring.
257	*/
258	public void resume(){
259	// Check to see if a file is open
260	if(open){
261	// If file is open we should print this to the screen
262	System.out.println(formatLogLine(this, "Resume failed: file open"));
263	}
264	else{
265	// Permit writing again
266	open=true;
267	// Make a note of the fact that writing has been resumed
268	write(this, "Writing resumed");
269	}
270	}
271
272	/**
273	* The fileCheck() method is used to ensure that writing is ok. It
274	* performs so basic checks to make sure that if the file exists
275	* it can be written to, and if not a new file is created. A boolean
276	* result is returned to signify success or failure.
277	*
278	* @return A boolean value signify whether the test was sucessful.
279	*/
280	private boolean fileCheck(){
281	boolean fileOK = false;
282	try{
283	File file = new File(filename);
284
285	// File already exists
286	if(file.exists()) {
287	/* Only want success if it is a file (not a directory)
288	* and can be written to.
289	*/
290	if(file.isFile() && file.canWrite()) {
291	fileOK = true;
292	}
293	}
294	// Create a new file and suceed
295	else{
296	file.createNewFile();
297	fileOK = true;
298	}
299	}
300	catch(IOException e){
301	System.out.println(formatLogLine(this, "File check failed: "+e.getMessage()));
302	}
303
304	return fileOK;
305	}
306
307	/**
308	* The filename of the currently open, or last open, file.
309	*/
310	private String filename;
311
312	/**
313	* A reference to the writer being used.
314	*/
315	private BufferedWriter writer;
316
317	/**
318	* A boolean signifying whether a file is open or not.
319	*/
320	private boolean open = false;
321
322	}