uimaj-cpe/src/main/java/org/apache/uima/collection/impl/cpm/Checkpoint.java - uima-uimaj - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package org.apache.uima.collection.impl.cpm;

 import java.io.EOFException;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.List;

 import org.apache.uima.UIMAFramework;
 import org.apache.uima.collection.base_cpm.SynchPoint;
 import org.apache.uima.collection.impl.cpm.utils.CPMUtils;
 import org.apache.uima.util.Level;
 import org.apache.uima.util.ProcessTrace;
 import org.apache.uima.util.ProcessTraceEvent;

 /**
  * Runing in a seperate thread creates a checkpoint file at predefined intervals.
  *
  */
 public class Checkpoint implements Runnable {
   private String fileName = null;

   private volatile boolean stop = false;  // volatile may be buggy in some JVMs apparently
                                           // consider changing to use synch

   private long checkpointFrequency = 3000;

   /**
    * @GuardedBy(lockForPause)
    */
   private boolean pause = false;

   private final Object lockForPause = new Object();

   // private boolean isRunning = false;
   private BaseCPMImpl cpm = null;

   private String synchPointFileName = null;

   /**
    * Initialize the checkpoint with a reference to controlling cpe, the file where the checkpoint is
    * to be stored, and the frequency of checkpoints.
    *
    * @param aCpm -
    * @param aFilename -
    * @param aCheckpointFrequency -
    */
   public Checkpoint(BaseCPMImpl aCpm, String aFilename, long aCheckpointFrequency) {
     fileName = aFilename;
     int fExtPos = fileName.indexOf('.');
     if (fExtPos > -1) {
       synchPointFileName = fileName.substring(0, fExtPos) + "_synchPoint.xml";
     }
     cpm = aCpm;
     checkpointFrequency = aCheckpointFrequency;
   }

   /**
    * Start the thread
    *
    */
   public void start() {
     new Thread(this).start();
   }

   /**
    * Stops the checkpoint thread
    *
    */
   public void stop() {
     stop = true;
     // isRunning = false;
     if (UIMAFramework.getLogger().isLoggable(Level.INFO)) {
       UIMAFramework.getLogger(this.getClass()).logrb(Level.INFO, this.getClass().getName(),
               "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_stop_checkpoint_thread__INFO",
               new Object[] { Thread.currentThread().getName() });

     }
   }

   /**
    * Starts the checkpoint thread and runs until the cpe tells it to stop
    */
   public void run() {
     Thread.currentThread().setName("CPM Checkpoint");

     // isRunning = true;
     while (!stop) {
       synchronized (lockForPause) {
         if (pause) {
           try {
             lockForPause.wait();
           } catch (InterruptedException e) {
           }
         }
       }
       if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
         UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
                 "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_checkpoint__FINEST",
                 new Object[] { Thread.currentThread().getName() });
       }
       doCheckpoint();

       try {
         if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
           UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
                   "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_sleep__FINEST",
                   new Object[] { Thread.currentThread().getName() });
         }
         Thread.sleep(checkpointFrequency);
         if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
           UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
                   "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_wakeup__FINEST",
                   new Object[] { Thread.currentThread().getName() });
         }
       } catch (Exception e) {
       }
     }
   }

   /**
    * Deletes checkpoint file from the filesystem
    *
    */
   public void delete() {
     try {
       File checkpointFile = new File(fileName);
       checkpointFile.delete();
     } catch (Exception e) {
       e.printStackTrace();
     }

   }

   /**
    * Pauses checkpoint thread
    *
    */
   public void pause() {
     synchronized (lockForPause) {
       pause = true;
     }
   }

   /**
    * Resumes checkpoint thread
    *
    */
   public void resume() {
     synchronized (lockForPause) {
       if (pause) {
         lockForPause.notifyAll();
         pause = false;
       }
     }
   }

   /**
    * Serializes checkpoint information to disk. It retrieves data to checkpoint from the CPEEngine.
    *
    */
   public void doCheckpoint() {
     try {
       if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
         UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
                 "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_checkpoint__FINEST",
                 new Object[] { Thread.currentThread().getName() });
       }
       // 02/08/05 Checkpoint has been broken up into two files. One containing the
       // ProcessTrace saved as binary object, and second containing the SynchPoint
       // saved as xml.
       rename(fileName);
       rename(synchPointFileName);
       // This stream is for the ProcessTrace part of the Checkppoint
       FileOutputStream out = null;
       // This stream is for the SynchPoint part of the Checkpoint
       FileOutputStream synchPointOut = null;
       ObjectOutputStream s = null;

       try {
         out = new FileOutputStream(fileName);
         synchPointOut = new FileOutputStream(synchPointFileName);
         s = new ObjectOutputStream(out);
         SynchPoint synchPoint = cpm.getSynchPoint();

         ProcessTrace pTrace = cpm.getPerformanceReport();
         CheckpointData targetToSave = null;
         if (pTrace != null) {
           if (synchPoint != null) {
             if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
               UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST,
                       this.getClass().getName(), "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
                       "UIMA_CPM_checkpoint_with_synchpoint__FINEST",
                       new Object[] { Thread.currentThread().getName() });
             }
             targetToSave = new CheckpointData(pTrace, synchPoint);
           } else {
             if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
               UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST,
                       this.getClass().getName(), "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
                       "UIMA_CPM_checkpoint_with_pt__FINEST",
                       new Object[] { Thread.currentThread().getName() });
             }
             targetToSave = new CheckpointData(pTrace);
           }
           synchronized (targetToSave) {
             s.writeObject(targetToSave);
             s.flush();
             if (synchPoint != null) {
               String xmlSynchPoint = synchPoint.serializeToXML();
               synchPointOut.write(xmlSynchPoint.getBytes());
               synchPointOut.flush();
             }
           }
         }
       } catch (Exception e) {
         UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
                 "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
                 "UIMA_CPM_exception_when_checkpointing__FINEST",
                 new Object[] { Thread.currentThread().getName(), e.getMessage() });
       } finally {
         if (out != null) {
           try {
             out.close();
             s.close();

           } catch (Exception e) {
           }
         }
         if (synchPointOut != null) {
           try {
             synchPointOut.close();
           } catch (Exception e) {
           }
         }
       }

     } catch (Exception e) {
       UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
               "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
               "UIMA_CPM_exception_when_checkpointing__FINEST",
               new Object[] { Thread.currentThread().getName(), e.getMessage() });
     }
   }

   /**
    * Renames previous checkpoint file.
    *
    * @param aFilename -
    *          checkpoint file to rename
    */
   public void rename(String aFilename) {
     File currentFile = new File(aFilename);
     File backupFile = new File(aFilename + ".prev");
     currentFile.renameTo(backupFile);
   }

   public static void printStats(ProcessTrace prT) {
     if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
       UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST,
               "\n\t\t\t----------------------------------------");
       UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST, "\t\t\t\t PERFORMANCE REPORT ");
       UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST,
               "\t\t\t----------------------------------------\n");
     }
     // get the list of events from the processTrace
     List eveList = prT.getEvents();
     printEveList(eveList, 0);
     if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
       UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST,
               "_________________________________________________________________\n");
     }
   }

   /**
    * Prints the list of Process Events in the order that they were produced.
    *
    * @param lst
    *          List of ProcessEvent
    * @param tCnt
    *          depth of this List in the Process Trace hierarchy
    */
   public static void printEveList(List lst, int tCnt) {
     String compNameS;
     String typeS;
     int dur;
     int totDur;
     List subEveList;
     String tabS = "";
     int tabCnt = tCnt;
     for (int j = 0; j < tabCnt; j++) {
       tabS = tabS + "\t";
     }
     for (int i = 0; i < lst.size(); i++) {
       ProcessTraceEvent prEvent = (ProcessTraceEvent) lst.get(i);
       compNameS = prEvent.getComponentName();
       typeS = prEvent.getType();
       dur = prEvent.getDurationExcludingSubEvents();
       totDur = prEvent.getDuration();
       subEveList = prEvent.getSubEvents();
       if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
         UIMAFramework.getLogger(Checkpoint.class).log(
                 Level.FINEST,
                 tabS + "COMPONENT : " + compNameS + "\tTYPE : " + typeS + "\tDescription : "
                         + prEvent.getDescription());
         UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST,
                 tabS + "TOTAL_TIME : " + totDur + "\tTIME_EXCLUDING_SUBEVENTS : " + dur);
       }
       if (subEveList != null) {
         printEveList(subEveList, (tabCnt + 1));
       }
       if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
         UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST, " ");
       }
     }
   }

   /**
    * Returns true if configured checkpoinjt file exists on disk
    *
    * @return - true if file exists, false otherwise
    */
   public boolean exists() {
     try {
       return new File(fileName).exists();
     } catch (Exception e) {
     }
     return false;
   }

   /**
    * Retrieves the checkpoint from the filesystem.
    *
    * @return - desirialized object containing recovery information.
    * @throws IOException -
    */
   public synchronized Object restoreFromCheckpoint() throws IOException {
     ObjectInputStream stream = null;
     FileInputStream synchPointStream = null;
     try {
       File file = new File(fileName);
       Object anObject = null;
       // The checkpoint consists of two seperate files. One that holds a binary representation of
       // checkpoint and the other as xml representation. The xml representation consists of only
       // part of the checkpoint, namely the SynchPoint. This data needed to be exposed as text to
       // a human administrator to manually change it. Requirement from the WF project.
       if (file.exists()) {

         if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
           UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
                   "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
                   "UIMA_CPM_restoring_from_checkpoint__FINEST",
                   new Object[] { Thread.currentThread().getName() });
         }
         FileInputStream in = new FileInputStream(file);
         stream = new ObjectInputStream(in);
         if (stream != null) {
           anObject = stream.readObject();
           if (anObject != null && anObject instanceof CheckpointData) {
             ProcessTrace processTrace = ((CheckpointData) anObject).getProcessTrace();
             printStats(processTrace);
           }
         }
       }
       file = new File(synchPointFileName);
       // Read the synchpoint from the filesystem.
       SynchPoint synchPoint = null;
       if (file.exists()) {
         if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
           UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
                   "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
                   "UIMA_CPM_synchpoint_from_file__FINEST",
                   new Object[] { Thread.currentThread().getName(), synchPointFileName });
         }
         synchPointStream = new FileInputStream(file);
         if (synchPointStream != null) {
           // Use the SynchPoint object retrieved above. Its internal data should be
           // overwritten during deserialization done below. Its just a convenience to
           // reuse the same object that was saved as part of a checkpoint.
           if (anObject != null && anObject instanceof CheckpointData) {
             synchPoint = ((CheckpointData) anObject).getSynchPoint();
             if (synchPoint != null) {
               synchPoint.deserialize(synchPointStream);
             }
           }
         }
       }

       return anObject;
     } catch (EOFException e) {
     } catch (Exception e) {
       e.printStackTrace();
     } finally {
       if (stream != null) {
         stream.close();
       }
       if (synchPointStream != null) {
         synchPointStream.close();
       }
     }
     return null;
   }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package org.apache.uima.collection.impl.cpm;

	import java.io.EOFException;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.ObjectInputStream;
	import java.io.ObjectOutputStream;
	import java.util.List;

	import org.apache.uima.UIMAFramework;
	import org.apache.uima.collection.base_cpm.SynchPoint;
	import org.apache.uima.collection.impl.cpm.utils.CPMUtils;
	import org.apache.uima.util.Level;
	import org.apache.uima.util.ProcessTrace;
	import org.apache.uima.util.ProcessTraceEvent;

	/**
	* Runing in a seperate thread creates a checkpoint file at predefined intervals.
	*
	*/
	public class Checkpoint implements Runnable {
	private String fileName = null;

	private volatile boolean stop = false; // volatile may be buggy in some JVMs apparently
	// consider changing to use synch

	private long checkpointFrequency = 3000;

	/**
	* @GuardedBy(lockForPause)
	*/
	private boolean pause = false;

	private final Object lockForPause = new Object();

	// private boolean isRunning = false;
	private BaseCPMImpl cpm = null;

	private String synchPointFileName = null;

	/**
	* Initialize the checkpoint with a reference to controlling cpe, the file where the checkpoint is
	* to be stored, and the frequency of checkpoints.
	*
	* @param aCpm -
	* @param aFilename -
	* @param aCheckpointFrequency -
	*/
	public Checkpoint(BaseCPMImpl aCpm, String aFilename, long aCheckpointFrequency) {
	fileName = aFilename;
	int fExtPos = fileName.indexOf('.');
	if (fExtPos > -1) {
	synchPointFileName = fileName.substring(0, fExtPos) + "_synchPoint.xml";
	}
	cpm = aCpm;
	checkpointFrequency = aCheckpointFrequency;
	}

	/**
	* Start the thread
	*
	*/
	public void start() {
	new Thread(this).start();
	}

	/**
	* Stops the checkpoint thread
	*
	*/
	public void stop() {
	stop = true;
	// isRunning = false;
	if (UIMAFramework.getLogger().isLoggable(Level.INFO)) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.INFO, this.getClass().getName(),
	"process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_stop_checkpoint_thread__INFO",
	new Object[] { Thread.currentThread().getName() });

	}
	}

	/**
	* Starts the checkpoint thread and runs until the cpe tells it to stop
	*/
	public void run() {
	Thread.currentThread().setName("CPM Checkpoint");

	// isRunning = true;
	while (!stop) {
	synchronized (lockForPause) {
	if (pause) {
	try {
	lockForPause.wait();
	} catch (InterruptedException e) {
	}
	}
	}
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
	"process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_checkpoint__FINEST",
	new Object[] { Thread.currentThread().getName() });
	}
	doCheckpoint();

	try {
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
	"process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_sleep__FINEST",
	new Object[] { Thread.currentThread().getName() });
	}
	Thread.sleep(checkpointFrequency);
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
	"process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_wakeup__FINEST",
	new Object[] { Thread.currentThread().getName() });
	}
	} catch (Exception e) {
	}
	}
	}

	/**
	* Deletes checkpoint file from the filesystem
	*
	*/
	public void delete() {
	try {
	File checkpointFile = new File(fileName);
	checkpointFile.delete();
	} catch (Exception e) {
	e.printStackTrace();
	}

	}

	/**
	* Pauses checkpoint thread
	*
	*/
	public void pause() {
	synchronized (lockForPause) {
	pause = true;
	}
	}

	/**
	* Resumes checkpoint thread
	*
	*/
	public void resume() {
	synchronized (lockForPause) {
	if (pause) {
	lockForPause.notifyAll();
	pause = false;
	}
	}
	}

	/**
	* Serializes checkpoint information to disk. It retrieves data to checkpoint from the CPEEngine.
	*
	*/
	public void doCheckpoint() {
	try {
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
	"process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE, "UIMA_CPM_checkpoint__FINEST",
	new Object[] { Thread.currentThread().getName() });
	}
	// 02/08/05 Checkpoint has been broken up into two files. One containing the
	// ProcessTrace saved as binary object, and second containing the SynchPoint
	// saved as xml.
	rename(fileName);
	rename(synchPointFileName);
	// This stream is for the ProcessTrace part of the Checkppoint
	FileOutputStream out = null;
	// This stream is for the SynchPoint part of the Checkpoint
	FileOutputStream synchPointOut = null;
	ObjectOutputStream s = null;

	try {
	out = new FileOutputStream(fileName);
	synchPointOut = new FileOutputStream(synchPointFileName);
	s = new ObjectOutputStream(out);
	SynchPoint synchPoint = cpm.getSynchPoint();

	ProcessTrace pTrace = cpm.getPerformanceReport();
	CheckpointData targetToSave = null;
	if (pTrace != null) {
	if (synchPoint != null) {
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST,
	this.getClass().getName(), "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
	"UIMA_CPM_checkpoint_with_synchpoint__FINEST",
	new Object[] { Thread.currentThread().getName() });
	}
	targetToSave = new CheckpointData(pTrace, synchPoint);
	} else {
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST,
	this.getClass().getName(), "process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
	"UIMA_CPM_checkpoint_with_pt__FINEST",
	new Object[] { Thread.currentThread().getName() });
	}
	targetToSave = new CheckpointData(pTrace);
	}
	synchronized (targetToSave) {
	s.writeObject(targetToSave);
	s.flush();
	if (synchPoint != null) {
	String xmlSynchPoint = synchPoint.serializeToXML();
	synchPointOut.write(xmlSynchPoint.getBytes());
	synchPointOut.flush();
	}
	}
	}
	} catch (Exception e) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
	"process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
	"UIMA_CPM_exception_when_checkpointing__FINEST",
	new Object[] { Thread.currentThread().getName(), e.getMessage() });
	} finally {
	if (out != null) {
	try {
	out.close();
	s.close();

	} catch (Exception e) {
	}
	}
	if (synchPointOut != null) {
	try {
	synchPointOut.close();
	} catch (Exception e) {
	}
	}
	}

	} catch (Exception e) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
	"process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
	"UIMA_CPM_exception_when_checkpointing__FINEST",
	new Object[] { Thread.currentThread().getName(), e.getMessage() });
	}
	}

	/**
	* Renames previous checkpoint file.
	*
	* @param aFilename -
	* checkpoint file to rename
	*/
	public void rename(String aFilename) {
	File currentFile = new File(aFilename);
	File backupFile = new File(aFilename + ".prev");
	currentFile.renameTo(backupFile);
	}

	public static void printStats(ProcessTrace prT) {
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST,
	"\n\t\t\t----------------------------------------");
	UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST, "\t\t\t\t PERFORMANCE REPORT ");
	UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST,
	"\t\t\t----------------------------------------\n");
	}
	// get the list of events from the processTrace
	List eveList = prT.getEvents();
	printEveList(eveList, 0);
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST,
	"_________________________________________________________________\n");
	}
	}

	/**
	* Prints the list of Process Events in the order that they were produced.
	*
	* @param lst
	* List of ProcessEvent
	* @param tCnt
	* depth of this List in the Process Trace hierarchy
	*/
	public static void printEveList(List lst, int tCnt) {
	String compNameS;
	String typeS;
	int dur;
	int totDur;
	List subEveList;
	String tabS = "";
	int tabCnt = tCnt;
	for (int j = 0; j < tabCnt; j++) {
	tabS = tabS + "\t";
	}
	for (int i = 0; i < lst.size(); i++) {
	ProcessTraceEvent prEvent = (ProcessTraceEvent) lst.get(i);
	compNameS = prEvent.getComponentName();
	typeS = prEvent.getType();
	dur = prEvent.getDurationExcludingSubEvents();
	totDur = prEvent.getDuration();
	subEveList = prEvent.getSubEvents();
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(Checkpoint.class).log(
	Level.FINEST,
	tabS + "COMPONENT : " + compNameS + "\tTYPE : " + typeS + "\tDescription : "
	+ prEvent.getDescription());
	UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST,
	tabS + "TOTAL_TIME : " + totDur + "\tTIME_EXCLUDING_SUBEVENTS : " + dur);
	}
	if (subEveList != null) {
	printEveList(subEveList, (tabCnt + 1));
	}
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(Checkpoint.class).log(Level.FINEST, " ");
	}
	}
	}

	/**
	* Returns true if configured checkpoinjt file exists on disk
	*
	* @return - true if file exists, false otherwise
	*/
	public boolean exists() {
	try {
	return new File(fileName).exists();
	} catch (Exception e) {
	}
	return false;
	}

	/**
	* Retrieves the checkpoint from the filesystem.
	*
	* @return - desirialized object containing recovery information.
	* @throws IOException -
	*/
	public synchronized Object restoreFromCheckpoint() throws IOException {
	ObjectInputStream stream = null;
	FileInputStream synchPointStream = null;
	try {
	File file = new File(fileName);
	Object anObject = null;
	// The checkpoint consists of two seperate files. One that holds a binary representation of
	// checkpoint and the other as xml representation. The xml representation consists of only
	// part of the checkpoint, namely the SynchPoint. This data needed to be exposed as text to
	// a human administrator to manually change it. Requirement from the WF project.
	if (file.exists()) {

	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
	"process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
	"UIMA_CPM_restoring_from_checkpoint__FINEST",
	new Object[] { Thread.currentThread().getName() });
	}
	FileInputStream in = new FileInputStream(file);
	stream = new ObjectInputStream(in);
	if (stream != null) {
	anObject = stream.readObject();
	if (anObject != null && anObject instanceof CheckpointData) {
	ProcessTrace processTrace = ((CheckpointData) anObject).getProcessTrace();
	printStats(processTrace);
	}
	}
	}
	file = new File(synchPointFileName);
	// Read the synchpoint from the filesystem.
	SynchPoint synchPoint = null;
	if (file.exists()) {
	if (UIMAFramework.getLogger().isLoggable(Level.FINEST)) {
	UIMAFramework.getLogger(this.getClass()).logrb(Level.FINEST, this.getClass().getName(),
	"process", CPMUtils.CPM_LOG_RESOURCE_BUNDLE,
	"UIMA_CPM_synchpoint_from_file__FINEST",
	new Object[] { Thread.currentThread().getName(), synchPointFileName });
	}
	synchPointStream = new FileInputStream(file);
	if (synchPointStream != null) {
	// Use the SynchPoint object retrieved above. Its internal data should be
	// overwritten during deserialization done below. Its just a convenience to
	// reuse the same object that was saved as part of a checkpoint.
	if (anObject != null && anObject instanceof CheckpointData) {
	synchPoint = ((CheckpointData) anObject).getSynchPoint();
	if (synchPoint != null) {
	synchPoint.deserialize(synchPointStream);
	}
	}
	}
	}

	return anObject;
	} catch (EOFException e) {
	} catch (Exception e) {
	e.printStackTrace();
	} finally {
	if (stream != null) {
	stream.close();
	}
	if (synchPointStream != null) {
	synchPointStream.close();
	}
	}
	return null;
	}
	}