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
(Generate patch)

Comparing projects/cms/source/server/uk/org/iscream/cms/server/core/loggers/FileLogger.java (file contents):
Revision 1.4 by tdb, Mon Jan 22 12:01:46 2001 UTC vs.
Revision 1.9 by tdb, Tue May 29 17:02:35 2001 UTC

# Line 1 | Line 1
1   //---PACKAGE DECLARATION---
2 < package uk.ac.ukc.iscream.core.loggers;
2 > package uk.org.iscream.cms.server.core.loggers;
3  
4   //---IMPORTS---
5 < import uk.ac.ukc.iscream.util.*;
6 < import uk.ac.ukc.iscream.core.*;
5 > import uk.org.iscream.cms.server.util.*;
6 > import uk.org.iscream.cms.server.core.*;
7   import java.util.Date;
8   import java.text.DateFormat;
9   import java.util.Locale;
# Line 46 | Line 46 | public 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"));
50 <        filename = System.getProperty("uk.ac.ukc.iscream.LoggerClass.FileLogger.filename");
49 >        filename = System.getProperty("uk.org.iscream.cms.server.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 61 | Line 60 | public class FileLogger implements LoggerImpl {
60                          open = true;
61          }
62          catch(IOException e){
63 <            System.out.println(formatLogLine(toString(), "Attempt 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(toString(), Logger.SYSINIT, "started");
68 –        write(toString(), Logger.SYSMSG, "using verbosity " + _verbosityLevel);
67      }
68  
69   //---PUBLIC METHODS---
70      
71 <        /**
72 <         * The write() method writes a line of log to the file, prepending
73 <         * it with some information about where to line came from and the
74 <         * date. This formatting is handled by the formatLogLine() method.
75 <         * There is some synchronisation here due to problems with the logfiles
76 <         * 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.
71 >    /**
72 >         * The write() method takes a line of text, pre-formatted
73 >         * and outputs it using a method defined by the actual
74 >         * implementation. The verbosity is given in case the
75 >         * implementation wishes to utilise it in the layout -
76 >         * eg. a different colour or font.
77           *
78 <         * @param source A string representation of the calling object.
79 <         * @param message The message to be logged.
80 <         */
81 <    public synchronized void write(String source, int verbosity, String message) {
78 >         * This instance writes the line to a file.
79 >         *
80 >         * @param line A line of formatted text to be logged
81 >         * @param verbosity the verbosity of this message
82 >         */  
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
89 –                        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 100 | Line 97 | public 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 138 | Line 135 | public class FileLogger implements LoggerImpl {
135                  }
136                  else{
137                          // If file is not open we should print this to the screen
138 <                        System.out.println(formatLogLine(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 163 | Line 160 | public class FileLogger implements LoggerImpl {
160                  }
161                  else{
162                          // If file is not open we should print this to the screen
163 <                        System.out.println(formatLogLine(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 186 | Line 183 | public class FileLogger implements LoggerImpl {
183                          this.filename = filename;
184                          if(!fileCheck()) {
185                                  // Have to system.out.println errors because logging mechanism failed !
186 <                                System.out.println(formatLogLine(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 196 | Line 193 | public class FileLogger implements LoggerImpl {
193                                  open = true;
194                          }
195                          catch(IOException e){
196 <                                System.out.println(formatLogLine(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 217 | Line 214 | public class FileLogger implements LoggerImpl {
214                  }
215                  else{
216                          // If file is not open we should print this to the screen
217 <                        System.out.println(formatLogLine(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 230 | Line 227 | public 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(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
# Line 244 | Line 241 | public 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
244 >     * This uses the uk.org.iscream.cms.server.util.FormatName class
245       * to format the toString()
246       *
247       * @return the name of this class and its CVS revision
# Line 259 | Line 256 | public class FileLogger implements LoggerImpl {
256   //---PRIVATE METHODS---
257  
258          /**
262 –         * This method generates a nicely formatted line for the log,
263 –         * including the date/time and the source of the message. The date
264 –         * and time are formatted using the DateFormat class, and the source
265 –         * class is formatted using the toString() method found in every
266 –         * source file. This is then prepended to the message and returned.
267 –         *
268 –         * @param source A string representation of the calling object.
269 –         * @param message The message to be logged.
270 –         * @return The string to be written to the log.
271 –         */
272 –    private String formatLogLine(String source, String message){
273 –        String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM).format(new Date());
274 –        return "[" + date + "] " + source + ": " + message;
275 –    }
276 –
277 –        /**
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 303 | Line 284 | public class FileLogger implements LoggerImpl {
284              }
285          }
286          catch(IOException e){
287 <            System.out.println(formatLogLine(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 +    /**
294 +     * This method is provided if this class wishes to log
295 +     * a message itself.
296 +     *
297 +         * @param source A String representation of the source
298 +         * @param verbosity the verbosity of this message
299 +         * @param message The message to log
300 +         */  
301 +    private void write(String source, int verbosity, String message) {
302 +        write(FormatName.formatLogLine(source, verbosity, message), verbosity);
303 +    }
304 +
305   //---ACCESSOR/MUTATOR METHODS---
306  
307   //---ATTRIBUTES---
# Line 317 | Line 310 | public class FileLogger implements LoggerImpl {
310           * The filename of the currently open, or last open, file.
311           */
312      private String filename;
320 –        
321 –    /**
322 –         * The verbosity level of this instance
323 –         */
324 –        private int _verbosityLevel;
313          
314          /**
315           * A reference to the writer being used.

Diff Legend

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