darwin-x86/sample/jmx/jmx-scandir/src/com/sun/jmx/examples/scandir/ResultLogManager.java - platform/prebuilts/jdk/jdk8 - Git at Google

 /*
  * Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  *   - Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *
  *   - Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  *
  *   - Neither the name of Oracle nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 /*
  * This source code is provided to illustrate the usage of a given feature
  * or technique and has been deliberately simplified. Additional steps
  * required for a production-quality application, such as security checks,
  * input validation and proper error handling, might not be present in
  * this sample code.
  */


 package com.sun.jmx.examples.scandir;

 import static com.sun.jmx.examples.scandir.ScanManager.getNextSeqNumber;
 import com.sun.jmx.examples.scandir.config.ResultLogConfig;
 import com.sun.jmx.examples.scandir.config.XmlConfigUtils;
 import com.sun.jmx.examples.scandir.config.ResultRecord;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.logging.Logger;
 import javax.management.MBeanNotificationInfo;
 import javax.management.MBeanRegistration;
 import javax.management.MBeanServer;
 import javax.management.Notification;
 import javax.management.NotificationBroadcasterSupport;
 import javax.management.ObjectName;
 import javax.xml.bind.JAXBException;

 /**
  * The <code>ResultLogManager</code> is in charge of managing result logs.
  * {@link DirectoryScanner DirectoryScanners} can be configured to log a
  * {@link ResultRecord} whenever they take action upon a file that
  * matches their set of matching criteria.
  * The <code>ResultLogManagerMXBean</code> is responsible for storing these
  * results in its result logs.
  * <p>The <code>ResultLogManagerMXBean</code> can be configured to log
  * these records to a flat file, or into a log held in memory, or both.
  * Both logs (file and memory) can be configured with a maximum capacity.
  * <br>When the maximum capacity of the memory log is reached - its first
  * entry (i.e. its eldest entry) is removed to make place for the latest.
  * <br>When the maximum capacity of the file log is reached, the file is
  * renamed by appending a tilde '~' to its name and a new result log is created.
  *
  *
  * @author Sun Microsystems, 2006 - All rights reserved.
  */
 public class ResultLogManager extends NotificationBroadcasterSupport
         implements ResultLogManagerMXBean, MBeanRegistration {

     /**
      * The default singleton name of the {@link ResultLogManagerMXBean}.
      **/
     public static final ObjectName RESULT_LOG_MANAGER_NAME =
             ScanManager.makeSingletonName(ResultLogManagerMXBean.class);

     /**
      * A logger for this class.
      **/
     private static final Logger LOG =
             Logger.getLogger(ResultLogManager.class.getName());

     // The memory log
     //
     private final List<ResultRecord> memoryLog;

     // Whether the memory log capacity was reached. In that case every
     // new entry triggers the deletion of the eldest one.
     //
     private volatile boolean memCapacityReached = false;

     // The maximum number of record that the memory log can
     // contain.
     //
     private volatile int memCapacity;

     // The maximum number of record that the ResultLogManager can
     // log in the log file before creating a new file.
     //
     private volatile long fileCapacity;

     // The current log file.
     //
     private volatile File logFile;

     // The OutputStream of the current log file.
     //
     private volatile OutputStream logStream = null;

     // number of record that this object has logged in the log file
     // since the log file was created. Creating a new file or clearing
     // the log file reset this value to '0'
     //
     private volatile long logCount = 0;

     // The ResultLogManager config - modified whenever
     // ScanManager.applyConfiguration is called.
     //
     private volatile ResultLogConfig config;

     /**
      * Create a new ResultLogManagerMXBean. This constructor is package
      * protected: only the {@link ScanManager} can create a
      * <code>ResultLogManager</code>.
      **/
     ResultLogManager() {
         // Instantiate the memory log - override the add() method so that
         // it removes the head of the list when the maximum capacity is
         // reached. Note that add() is the only method we will be calling,
         // otherwise we would have to override all the other flavors
         // of adding methods. Note also that this implies that the memoryLog
         // will *always* remain encapsulated in this object and is *never*
         // handed over (otherwise we wouldn't be able to ensure that
         // add() is the only method ever called to add a record).
         //
         memoryLog =
                 Collections.synchronizedList(new LinkedList<ResultRecord>() {
             public synchronized boolean add(ResultRecord e) {
                 final int max = getMemoryLogCapacity();
                 while (max > 0 && size() >= max) {
                     memCapacityReached = true;
                     removeFirst();
                 }
                 return super.add(e);
             }
         });

         // default memory capacity
         memCapacity = 2048;

         // default file capacity: 0 means infinite ;-)
         fileCapacity = 0;

         // by default logging to file is disabled.
         logFile = null;

         // Until the ScanManager apply a new configuration, we're going to
         // work with a default ResultLogConfig object.
         config = new ResultLogConfig();
         config.setMemoryMaxRecords(memCapacity);
         config.setLogFileName(getLogFileName(false));
         config.setLogFileMaxRecords(fileCapacity);
     }


     /**
      * Allows the MBean to perform any operations it needs before being
      * registered in the MBean server.
      * <p>If the name of the MBean is not
      * specified, the MBean can provide a name for its registration. If
      * any exception is raised, the MBean will not be registered in the
      * MBean server.</p>
      * <p>The {@code ResultLogManager} uses this method to supply its own
      * default singleton ObjectName (if <var>name</var> parameter is null).
      * @param server The MBean server in which the MBean will be registered.
      * @param name The object name of the MBean. This name is null if the
      * name parameter to one of the createMBean or registerMBean methods in
      * the MBeanServer interface is null. In that case, this method must
      * return a non-null ObjectName for the new MBean.
      * @return The name under which the MBean is to be registered. This value
      * must not be null. If the name parameter is not null, it will usually
      * but not necessarily be the returned value.
      * @throws Exception This exception will be caught by the MBean server and
      * re-thrown as an MBeanRegistrationException.
      */
     public ObjectName preRegister(MBeanServer server, ObjectName name)
     throws Exception {
         if (name == null)
             name = RESULT_LOG_MANAGER_NAME;
         objectName = name;
         mbeanServer = server;
         return name;
     }

     /**
      * Allows the MBean to perform any operations needed after having
      * been registered in the MBean server or after the registration has
      * failed.
      * <p>This implementation does nothing.</p>
      * @param registrationDone Indicates whether or not the MBean has been
      * successfully registered in the MBean server. The value false means
      * that the registration has failed.
      */
     public void postRegister(Boolean registrationDone) {
         // Don't need to do anything here.
     }

     /**
      * Allows the MBean to perform any operations it needs before being
      * unregistered by the MBean server.
      * <p>This implementation does nothing.</p>
      * @throws Exception This exception will be caught by the MBean server and
      * re-thrown as an MBeanRegistrationException.
      */
     public void preDeregister() throws Exception {
         // Don't need to do anything here.
     }

     /**
      * Allows the MBean to perform any operations needed after having been
      * unregistered in the MBean server.
      * <p>Closes the log file stream, if it is still open.</p>
      */
     public void postDeregister() {
         try {
             if (logStream != null) {
                 synchronized(this)  {
                     logStream.flush();
                     logStream.close();
                     logFile = null;
                     logStream = null;
                 }
             }
         } catch (Exception x) {
             LOG.finest("Failed to close log properly: "+x);
         }
     }

     /**
      * Create a new empty log file from the given basename, renaming
      * previously existing file by appending '~' to its name.
      **/
     private File createNewLogFile(String basename) throws IOException {
         return XmlConfigUtils.createNewXmlFile(basename);
     }

     /**
      * Check whether a new log file should be created.
      * If a new file needs to be created, creates it, renaming
      * previously existing file by appending '~' to its name.
      * Also reset the log count and file capacity.
      * Sends a notification indicating that the log file was changed.
      * Returns the new log stream;
      * Creation of a new file can be forced by passing force=true.
      **/
     private OutputStream checkLogFile(String basename, long maxRecords,
                                       boolean force)
     throws IOException {
         final OutputStream newStream;
         synchronized(this) {
             if ((force==false) && (logCount < maxRecords))
                 return logStream;
             final OutputStream oldStream = logStream;

             // First close the stream. On some platforms you cannot rename
             // a file that has open streams...
             //
             if (oldStream != null) {
                 oldStream.flush();
                 oldStream.close();
             }
             final File newFile = (basename==null)?null:createNewLogFile(basename);

             newStream = (newFile==null)?null:new FileOutputStream(newFile,true);
             logStream = newStream;
             logFile = newFile;
             fileCapacity = maxRecords;
             logCount = 0;
         }
         sendNotification(new Notification(LOG_FILE_CHANGED,objectName,
                 getNextSeqNumber(),
                 basename));
         return newStream;
     }

     // see ResultLogManagerMXBean
     public void log(ResultRecord record)
     throws IOException {
         if (memCapacity > 0) logToMemory(record);
         if (logFile != null) logToFile(record);
     }

     // see ResultLogManagerMXBean
     public ResultRecord[] getMemoryLog() {
         return memoryLog.toArray(new ResultRecord[0]);
     }

     // see ResultLogManagerMXBean
     public int getMemoryLogCapacity() {
         return memCapacity;
     }

     // see ResultLogManagerMXBean
     public void setMemoryLogCapacity(int maxRecords)  {
         synchronized(this) {
             memCapacity = maxRecords;
             if (memoryLog.size() < memCapacity)
                 memCapacityReached = false;
             config.setMemoryMaxRecords(maxRecords);
         }
     }

     // see ResultLogManagerMXBean
     public void setLogFileCapacity(long maxRecords)
     throws IOException {
         synchronized (this) {
             fileCapacity = maxRecords;
             config.setLogFileMaxRecords(maxRecords);
         }
         checkLogFile(getLogFileName(),fileCapacity,false);
     }

     // see ResultLogManagerMXBean
     public long getLogFileCapacity()  {
         return fileCapacity;
     }

     // see ResultLogManagerMXBean
     public long getLoggedCount() {
         return logCount;
     }

     // see ResultLogManagerMXBean
     public void newLogFile(String logname, long maxRecord)
     throws IOException {
         checkLogFile(logname,maxRecord,true);
         config.setLogFileName(getLogFileName(false));
         config.setLogFileMaxRecords(getLogFileCapacity());
     }

     // see ResultLogManagerMXBean
     public String getLogFileName() {
         return getLogFileName(true);
     }

     // see ResultLogManagerMXBean
     public void clearLogs() throws IOException {
         clearMemoryLog();
         clearLogFile();
     }

     // Clear the memory log, sends a notification indicating that
     // the memory log was cleared.
     //
     private void clearMemoryLog()throws IOException {
         synchronized(this) {
             memoryLog.clear();
             memCapacityReached = false;
         }
         sendNotification(new Notification(MEMORY_LOG_CLEARED,
                 objectName,
                 getNextSeqNumber(),"memory log cleared"));
     }

     // Clears the log file.
     //
     private void clearLogFile() throws IOException {
         // simply force the creation of a new log file.
         checkLogFile(getLogFileName(),fileCapacity,true);
     }

     // Log a record to the memory log. Send a notification if the
     // maximum capacity of the memory log is reached.
     //
     private void logToMemory(ResultRecord record) {

         final boolean before = memCapacityReached;
         final boolean after;
         synchronized(this) {
             memoryLog.add(record);
             after = memCapacityReached;
         }
         if (before==false && after==true)
             sendNotification(new Notification(MEMORY_LOG_MAX_CAPACITY,
                     objectName,
                     getNextSeqNumber(),"memory log capacity reached"));
     }


     // Log a record to the memory log. Send a notification if the
     // maximum capacity of the memory log is reached.
     //
     private void logToFile(ResultRecord record) throws IOException {
         final String basename;
         final long   maxRecords;
         synchronized (this) {
             if (logFile == null) return;
             basename = getLogFileName(false);
             maxRecords = fileCapacity;
         }

         // Get the stream into which we should log.
         final OutputStream stream =
                 checkLogFile(basename,maxRecords,false);

         // logging to file now disabled - too bad.
         if (stream == null) return;

         synchronized (this) {
             try {
                 XmlConfigUtils.write(record,stream,true);
                 stream.flush();
                 // don't increment logCount if we were not logging in logStream.
                 if (stream == logStream) logCount++;
             } catch (JAXBException x) {
                 final IllegalArgumentException iae =
                         new IllegalArgumentException("bad record",x);
                 LOG.finest("Failed to log record: "+x);
                 throw iae;
             }
         }
     }

     /**
      * The notification type which indicates that the log file was switched:
      * <i>com.sun.jmx.examples.scandir.log.file.switched</i>.
      * The message contains the name of the new file (or null if log to file
      * is now disabled).
      **/
     public final static String LOG_FILE_CHANGED =
             "com.sun.jmx.examples.scandir.log.file.switched";

     /**
      * The notification type which indicates that the memory log capacity has
      * been reached:
      * <i>com.sun.jmx.examples.scandir.log.memory.full</i>.
      **/
     public final static String MEMORY_LOG_MAX_CAPACITY =
             "com.sun.jmx.examples.scandir.log.memory.full";

     /**
      * The notification type which indicates that the memory log was
      * cleared:
      * <i>com.sun.jmx.examples.scandir.log.memory.cleared</i>.
      **/
     public final static String MEMORY_LOG_CLEARED =
             "com.sun.jmx.examples.scandir.log.memory.cleared";

     /**
      * This MBean emits three kind of notifications:
      * <pre>
      *    <i>com.sun.jmx.examples.scandir.log.file.switched</i>
      *    <i>com.sun.jmx.examples.scandir.log.memory.full</i>
      *    <i>com.sun.jmx.examples.scandir.log.memory.cleared</i>
      * </pre>
      **/
     public MBeanNotificationInfo[] getNotificationInfo() {
         return new MBeanNotificationInfo[] {
             new MBeanNotificationInfo(new String[] {
                 LOG_FILE_CHANGED},
                     Notification.class.getName(),
                     "Emitted when the log file is switched")
                     ,
             new MBeanNotificationInfo(new String[] {
                 MEMORY_LOG_MAX_CAPACITY},
                     Notification.class.getName(),
                     "Emitted when the memory log capacity is reached")
                     ,
             new MBeanNotificationInfo(new String[] {
                 MEMORY_LOG_CLEARED},
                     Notification.class.getName(),
                     "Emitted when the memory log is cleared")
         };
     }

     // Return the name of the log file, or null if logging to file is
     // disabled.
     private String getLogFileName(boolean absolute) {
         synchronized (this) {
             if (logFile == null) return null;
             if (absolute) return logFile.getAbsolutePath();
             return logFile.getPath();
         }
     }

     // This method is be called by the ScanManagerMXBean when a configuration
     // is applied.
     //
     void setConfig(ResultLogConfig logConfigBean) throws IOException {
         if (logConfigBean == null)
             throw new IllegalArgumentException("logConfigBean is null");
         synchronized (this) {
             config = logConfigBean;
             setMemoryLogCapacity(config.getMemoryMaxRecords());
         }
         final String filename = config.getLogFileName();
         final String logname  = getLogFileName(false);
         if ((filename != null && !filename.equals(logname))
         || (filename == null && logname != null)) {
             newLogFile(config.getLogFileName(),
                     config.getLogFileMaxRecords());
         } else {
             setLogFileCapacity(config.getLogFileMaxRecords());
         }
     }

     // This method is called by the ScanManagerMXBean when
     // applyCurrentResultLogConfig() is called.
     //
     ResultLogConfig getConfig() {
         return config;
     }


     // Set by preRegister().
     private MBeanServer mbeanServer;
     private ObjectName objectName;


 }
	/*
	* Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	*
	* - Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* - Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* - Neither the name of Oracle nor the names of its
	* contributors may be used to endorse or promote products derived
	* from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
	* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	/*
	* This source code is provided to illustrate the usage of a given feature
	* or technique and has been deliberately simplified. Additional steps
	* required for a production-quality application, such as security checks,
	* input validation and proper error handling, might not be present in
	* this sample code.
	*/


	package com.sun.jmx.examples.scandir;

	import static com.sun.jmx.examples.scandir.ScanManager.getNextSeqNumber;
	import com.sun.jmx.examples.scandir.config.ResultLogConfig;
	import com.sun.jmx.examples.scandir.config.XmlConfigUtils;
	import com.sun.jmx.examples.scandir.config.ResultRecord;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.util.Collections;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.logging.Logger;
	import javax.management.MBeanNotificationInfo;
	import javax.management.MBeanRegistration;
	import javax.management.MBeanServer;
	import javax.management.Notification;
	import javax.management.NotificationBroadcasterSupport;
	import javax.management.ObjectName;
	import javax.xml.bind.JAXBException;

	/**
	* The <code>ResultLogManager</code> is in charge of managing result logs.
	* {@link DirectoryScanner DirectoryScanners} can be configured to log a
	* {@link ResultRecord} whenever they take action upon a file that
	* matches their set of matching criteria.
	* The <code>ResultLogManagerMXBean</code> is responsible for storing these
	* results in its result logs.
	* <p>The <code>ResultLogManagerMXBean</code> can be configured to log
	* these records to a flat file, or into a log held in memory, or both.
	* Both logs (file and memory) can be configured with a maximum capacity.
	* <br>When the maximum capacity of the memory log is reached - its first
	* entry (i.e. its eldest entry) is removed to make place for the latest.
	* <br>When the maximum capacity of the file log is reached, the file is
	* renamed by appending a tilde '~' to its name and a new result log is created.
	*
	*
	* @author Sun Microsystems, 2006 - All rights reserved.
	*/
	public class ResultLogManager extends NotificationBroadcasterSupport
	implements ResultLogManagerMXBean, MBeanRegistration {

	/**
	* The default singleton name of the {@link ResultLogManagerMXBean}.
	**/
	public static final ObjectName RESULT_LOG_MANAGER_NAME =
	ScanManager.makeSingletonName(ResultLogManagerMXBean.class);

	/**
	* A logger for this class.
	**/
	private static final Logger LOG =
	Logger.getLogger(ResultLogManager.class.getName());

	// The memory log
	//
	private final List<ResultRecord> memoryLog;

	// Whether the memory log capacity was reached. In that case every
	// new entry triggers the deletion of the eldest one.
	//
	private volatile boolean memCapacityReached = false;

	// The maximum number of record that the memory log can
	// contain.
	//
	private volatile int memCapacity;

	// The maximum number of record that the ResultLogManager can
	// log in the log file before creating a new file.
	//
	private volatile long fileCapacity;

	// The current log file.
	//
	private volatile File logFile;

	// The OutputStream of the current log file.
	//
	private volatile OutputStream logStream = null;

	// number of record that this object has logged in the log file
	// since the log file was created. Creating a new file or clearing
	// the log file reset this value to '0'
	//
	private volatile long logCount = 0;

	// The ResultLogManager config - modified whenever
	// ScanManager.applyConfiguration is called.
	//
	private volatile ResultLogConfig config;

	/**
	* Create a new ResultLogManagerMXBean. This constructor is package
	* protected: only the {@link ScanManager} can create a
	* <code>ResultLogManager</code>.
	**/
	ResultLogManager() {
	// Instantiate the memory log - override the add() method so that
	// it removes the head of the list when the maximum capacity is
	// reached. Note that add() is the only method we will be calling,
	// otherwise we would have to override all the other flavors
	// of adding methods. Note also that this implies that the memoryLog
	// will always remain encapsulated in this object and is never
	// handed over (otherwise we wouldn't be able to ensure that
	// add() is the only method ever called to add a record).
	//
	memoryLog =
	Collections.synchronizedList(new LinkedList<ResultRecord>() {
	public synchronized boolean add(ResultRecord e) {
	final int max = getMemoryLogCapacity();
	while (max > 0 && size() >= max) {
	memCapacityReached = true;
	removeFirst();
	}
	return super.add(e);
	}
	});

	// default memory capacity
	memCapacity = 2048;

	// default file capacity: 0 means infinite ;-)
	fileCapacity = 0;

	// by default logging to file is disabled.
	logFile = null;

	// Until the ScanManager apply a new configuration, we're going to
	// work with a default ResultLogConfig object.
	config = new ResultLogConfig();
	config.setMemoryMaxRecords(memCapacity);
	config.setLogFileName(getLogFileName(false));
	config.setLogFileMaxRecords(fileCapacity);
	}


	/**
	* Allows the MBean to perform any operations it needs before being
	* registered in the MBean server.
	* <p>If the name of the MBean is not
	* specified, the MBean can provide a name for its registration. If
	* any exception is raised, the MBean will not be registered in the
	* MBean server.</p>
	* <p>The {@code ResultLogManager} uses this method to supply its own
	* default singleton ObjectName (if <var>name</var> parameter is null).
	* @param server The MBean server in which the MBean will be registered.
	* @param name The object name of the MBean. This name is null if the
	* name parameter to one of the createMBean or registerMBean methods in
	* the MBeanServer interface is null. In that case, this method must
	* return a non-null ObjectName for the new MBean.
	* @return The name under which the MBean is to be registered. This value
	* must not be null. If the name parameter is not null, it will usually
	* but not necessarily be the returned value.
	* @throws Exception This exception will be caught by the MBean server and
	* re-thrown as an MBeanRegistrationException.
	*/
	public ObjectName preRegister(MBeanServer server, ObjectName name)
	throws Exception {
	if (name == null)
	name = RESULT_LOG_MANAGER_NAME;
	objectName = name;
	mbeanServer = server;
	return name;
	}

	/**
	* Allows the MBean to perform any operations needed after having
	* been registered in the MBean server or after the registration has
	* failed.
	* <p>This implementation does nothing.</p>
	* @param registrationDone Indicates whether or not the MBean has been
	* successfully registered in the MBean server. The value false means
	* that the registration has failed.
	*/
	public void postRegister(Boolean registrationDone) {
	// Don't need to do anything here.
	}

	/**
	* Allows the MBean to perform any operations it needs before being
	* unregistered by the MBean server.
	* <p>This implementation does nothing.</p>
	* @throws Exception This exception will be caught by the MBean server and
	* re-thrown as an MBeanRegistrationException.
	*/
	public void preDeregister() throws Exception {
	// Don't need to do anything here.
	}

	/**
	* Allows the MBean to perform any operations needed after having been
	* unregistered in the MBean server.
	* <p>Closes the log file stream, if it is still open.</p>
	*/
	public void postDeregister() {
	try {
	if (logStream != null) {
	synchronized(this) {
	logStream.flush();
	logStream.close();
	logFile = null;
	logStream = null;
	}
	}
	} catch (Exception x) {
	LOG.finest("Failed to close log properly: "+x);
	}
	}

	/**
	* Create a new empty log file from the given basename, renaming
	* previously existing file by appending '~' to its name.
	**/
	private File createNewLogFile(String basename) throws IOException {
	return XmlConfigUtils.createNewXmlFile(basename);
	}

	/**
	* Check whether a new log file should be created.
	* If a new file needs to be created, creates it, renaming
	* previously existing file by appending '~' to its name.
	* Also reset the log count and file capacity.
	* Sends a notification indicating that the log file was changed.
	* Returns the new log stream;
	* Creation of a new file can be forced by passing force=true.
	**/
	private OutputStream checkLogFile(String basename, long maxRecords,
	boolean force)
	throws IOException {
	final OutputStream newStream;
	synchronized(this) {
	if ((force==false) && (logCount < maxRecords))
	return logStream;
	final OutputStream oldStream = logStream;

	// First close the stream. On some platforms you cannot rename
	// a file that has open streams...
	//
	if (oldStream != null) {
	oldStream.flush();
	oldStream.close();
	}
	final File newFile = (basename==null)?null:createNewLogFile(basename);

	newStream = (newFile==null)?null:new FileOutputStream(newFile,true);
	logStream = newStream;
	logFile = newFile;
	fileCapacity = maxRecords;
	logCount = 0;
	}
	sendNotification(new Notification(LOG_FILE_CHANGED,objectName,
	getNextSeqNumber(),
	basename));
	return newStream;
	}

	// see ResultLogManagerMXBean
	public void log(ResultRecord record)
	throws IOException {
	if (memCapacity > 0) logToMemory(record);
	if (logFile != null) logToFile(record);
	}

	// see ResultLogManagerMXBean
	public ResultRecord[] getMemoryLog() {
	return memoryLog.toArray(new ResultRecord[0]);
	}

	// see ResultLogManagerMXBean
	public int getMemoryLogCapacity() {
	return memCapacity;
	}

	// see ResultLogManagerMXBean
	public void setMemoryLogCapacity(int maxRecords) {
	synchronized(this) {
	memCapacity = maxRecords;
	if (memoryLog.size() < memCapacity)
	memCapacityReached = false;
	config.setMemoryMaxRecords(maxRecords);
	}
	}

	// see ResultLogManagerMXBean
	public void setLogFileCapacity(long maxRecords)
	throws IOException {
	synchronized (this) {
	fileCapacity = maxRecords;
	config.setLogFileMaxRecords(maxRecords);
	}
	checkLogFile(getLogFileName(),fileCapacity,false);
	}

	// see ResultLogManagerMXBean
	public long getLogFileCapacity() {
	return fileCapacity;
	}

	// see ResultLogManagerMXBean
	public long getLoggedCount() {
	return logCount;
	}

	// see ResultLogManagerMXBean
	public void newLogFile(String logname, long maxRecord)
	throws IOException {
	checkLogFile(logname,maxRecord,true);
	config.setLogFileName(getLogFileName(false));
	config.setLogFileMaxRecords(getLogFileCapacity());
	}

	// see ResultLogManagerMXBean
	public String getLogFileName() {
	return getLogFileName(true);
	}

	// see ResultLogManagerMXBean
	public void clearLogs() throws IOException {
	clearMemoryLog();
	clearLogFile();
	}

	// Clear the memory log, sends a notification indicating that
	// the memory log was cleared.
	//
	private void clearMemoryLog()throws IOException {
	synchronized(this) {
	memoryLog.clear();
	memCapacityReached = false;
	}
	sendNotification(new Notification(MEMORY_LOG_CLEARED,
	objectName,
	getNextSeqNumber(),"memory log cleared"));
	}

	// Clears the log file.
	//
	private void clearLogFile() throws IOException {
	// simply force the creation of a new log file.
	checkLogFile(getLogFileName(),fileCapacity,true);
	}

	// Log a record to the memory log. Send a notification if the
	// maximum capacity of the memory log is reached.
	//
	private void logToMemory(ResultRecord record) {

	final boolean before = memCapacityReached;
	final boolean after;
	synchronized(this) {
	memoryLog.add(record);
	after = memCapacityReached;
	}
	if (before==false && after==true)
	sendNotification(new Notification(MEMORY_LOG_MAX_CAPACITY,
	objectName,
	getNextSeqNumber(),"memory log capacity reached"));
	}


	// Log a record to the memory log. Send a notification if the
	// maximum capacity of the memory log is reached.
	//
	private void logToFile(ResultRecord record) throws IOException {
	final String basename;
	final long maxRecords;
	synchronized (this) {
	if (logFile == null) return;
	basename = getLogFileName(false);
	maxRecords = fileCapacity;
	}

	// Get the stream into which we should log.
	final OutputStream stream =
	checkLogFile(basename,maxRecords,false);

	// logging to file now disabled - too bad.
	if (stream == null) return;

	synchronized (this) {
	try {
	XmlConfigUtils.write(record,stream,true);
	stream.flush();
	// don't increment logCount if we were not logging in logStream.
	if (stream == logStream) logCount++;
	} catch (JAXBException x) {
	final IllegalArgumentException iae =
	new IllegalArgumentException("bad record",x);
	LOG.finest("Failed to log record: "+x);
	throw iae;
	}
	}
	}

	/**
	* The notification type which indicates that the log file was switched:
	* <i>com.sun.jmx.examples.scandir.log.file.switched</i>.
	* The message contains the name of the new file (or null if log to file
	* is now disabled).
	**/
	public final static String LOG_FILE_CHANGED =
	"com.sun.jmx.examples.scandir.log.file.switched";

	/**
	* The notification type which indicates that the memory log capacity has
	* been reached:
	* <i>com.sun.jmx.examples.scandir.log.memory.full</i>.
	**/
	public final static String MEMORY_LOG_MAX_CAPACITY =
	"com.sun.jmx.examples.scandir.log.memory.full";

	/**
	* The notification type which indicates that the memory log was
	* cleared:
	* <i>com.sun.jmx.examples.scandir.log.memory.cleared</i>.
	**/
	public final static String MEMORY_LOG_CLEARED =
	"com.sun.jmx.examples.scandir.log.memory.cleared";

	/**
	* This MBean emits three kind of notifications:
	* <pre>
	* <i>com.sun.jmx.examples.scandir.log.file.switched</i>
	* <i>com.sun.jmx.examples.scandir.log.memory.full</i>
	* <i>com.sun.jmx.examples.scandir.log.memory.cleared</i>
	* </pre>
	**/
	public MBeanNotificationInfo[] getNotificationInfo() {
	return new MBeanNotificationInfo[] {
	new MBeanNotificationInfo(new String[] {
	LOG_FILE_CHANGED},
	Notification.class.getName(),
	"Emitted when the log file is switched")
	,
	new MBeanNotificationInfo(new String[] {
	MEMORY_LOG_MAX_CAPACITY},
	Notification.class.getName(),
	"Emitted when the memory log capacity is reached")
	,
	new MBeanNotificationInfo(new String[] {
	MEMORY_LOG_CLEARED},
	Notification.class.getName(),
	"Emitted when the memory log is cleared")
	};
	}

	// Return the name of the log file, or null if logging to file is
	// disabled.
	private String getLogFileName(boolean absolute) {
	synchronized (this) {
	if (logFile == null) return null;
	if (absolute) return logFile.getAbsolutePath();
	return logFile.getPath();
	}
	}

	// This method is be called by the ScanManagerMXBean when a configuration
	// is applied.
	//
	void setConfig(ResultLogConfig logConfigBean) throws IOException {
	if (logConfigBean == null)
	throw new IllegalArgumentException("logConfigBean is null");
	synchronized (this) {
	config = logConfigBean;
	setMemoryLogCapacity(config.getMemoryMaxRecords());
	}
	final String filename = config.getLogFileName();
	final String logname = getLogFileName(false);
	if ((filename != null && !filename.equals(logname))
	\|\| (filename == null && logname != null)) {
	newLogFile(config.getLogFileName(),
	config.getLogFileMaxRecords());
	} else {
	setLogFileCapacity(config.getLogFileMaxRecords());
	}
	}

	// This method is called by the ScanManagerMXBean when
	// applyCurrentResultLogConfig() is called.
	//
	ResultLogConfig getConfig() {
	return config;
	}


	// Set by preRegister().
	private MBeanServer mbeanServer;
	private ObjectName objectName;



	}