FCL/sftools/dev/build: comparison buildframework/helium/sf/java/logging/src/com/nokia/helium/logger/ant/listener/AntLoggingHandler.java

equal deleted inserted replaced

-:c7c26511138f
+:7c4a911dc066
 import java.io.File;
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.Date;
-import java.util.Enumeration;
+import java.util.HashMap;
 import java.util.Hashtable;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.Vector;
+import java.util.Map.Entry;
+import org.apache.log4j.Logger;
 import org.apache.tools.ant.BuildEvent;
+import org.apache.tools.ant.BuildException;
 import org.apache.tools.ant.Project;
 import org.apache.tools.ant.Target;
 import org.apache.tools.ant.Task;
 import org.apache.tools.ant.types.LogLevel;
-import org.apache.tools.ant.BuildException;
-import org.apache.log4j.Logger;
+import com.nokia.helium.core.ant.types.Stage;
 import com.nokia.helium.logger.ant.types.StageLogging;
-import com.nokia.helium.logger.ant.types.Stage;
 /**
 * Ant logging class for each Stage.
 *
 *
 antLogLevel = new VerbosityLevelChoices();
 stagesMapping = new HashMap<String, Stage>();
 stageRecordMap = new HashMap<String, StageLogging>();
 depStartTargetMap = new HashMap<String, Vector<Target>>();
 stageStartTargetMap = new HashMap<String, Target>();
-initStagesInformation(project);
+initialize(project);
 }
 /**
 * Return the project associated to this Handler.
 *
 /**
 * {@inheritDoc}
 */
 public void handleTargetFinished(BuildEvent event) {
 // log.debug("Finished target [" + event.getTarget().getName() + "]");
-if (isEndTarget(event.getTarget().getName())
+if (isEndTarget(event.getTarget().getName()) && getIsStageRecordingHappening()
-&& getIsStageRecordingHappening() && (getLoggingStarted())) {
+&& (getLoggingStarted())) {
-log.debug("Stopping stage logging for  [" + currentStageName
+log.debug("Stopping stage logging for  [" + currentStageName + "] for target ["
-+ "] for target [" + event.getTarget().getName() + "]");
++ event.getTarget().getName() + "]");
 stopLog(currentStageName, "default");
-if (!isDefaultStageStarted)
+if (!isDefaultStageStarted) {
-{
 startLog("default");
 isDefaultStageStarted = true;
 }
 currentStageName = null;
 }
 }
 if (currentStageName == null && !getIsStageRecordingHappening() && getLoggingStarted()) {
 String stageName = isStageValid(event.getTarget(), event.getProject());
 if (stageName != null) {
-log.debug("Started stage logging for  [" + stageName
+log.debug("Started stage logging for  [" + stageName + "] for target ["
-+ "] for target [" + event.getTarget().getName() + "]");
++ event.getTarget().getName() + "]");
-if (isDefaultStageStarted)
+if (isDefaultStageStarted) {
-{
 stopLog("default", stageName);
 isDefaultStageStarted = false;
 }
 startLog(stageName);
 currentStageName = stageName;
 * {@inheritDoc}
 */
 public void handleBuildFinished(BuildEvent event) {
 /*
-* If any stage logging is happening stop logging into stage log file
+* If any stage logging is happening stop logging into stage log file and switch to
-* and switch to main/default ant log file.
+* main/default ant log file.
 */
 if (getLoggingStarted() && getIsStageRecordingHappening()) {
 stopLog(currentStageName, "default");
-if (!isDefaultStageStarted)
+if (!isDefaultStageStarted) {
-{
 startLog("default");
 isDefaultStageStarted = true;
 }
 currentStageName = null;
 }
 /*
-* If default stage logging happening stop logging into default ant log
+* If default stage logging happening stop logging into default ant log file.
-* file.
 */
 if (isDefaultStageStarted && getLoggingStarted()) {
 stopLog("default", null, event);
 isDefaultStageStarted = false;
 }
 }
 /**
 * Sets the level to which this recorder entry should log to.
 *
-* @param level
+* @param level the level to set.
-*            the level to set.
 * @see VerbosityLevelChoices
 */
 public void setLoglevel(VerbosityLevelChoices level) {
 loglevel = level.getLevel();
 }
 /**
-* A list of possible values for the <code>setLoglevel()</code> method.
+* A list of possible values for the <code>setLoglevel()</code> method. Possible values include:
-* Possible values include: error, warn, info, verbose, debug.
+* error, warn, info, verbose, debug.
 */
 public static class VerbosityLevelChoices extends LogLevel {
 }
 /**
 * To get current date and time.
 *
 * @return
 */
 private String getDateTime() {
-DateFormat dateFormat = new SimpleDateFormat(
+DateFormat dateFormat = new SimpleDateFormat("EE yyyy/MM/dd HH:mm:ss:SS aaa");
-"EE yyyy/MM/dd HH:mm:ss:SS aaa");
 Date date = new Date();
 return dateFormat.format(date);
 }
 /**
 * @param stageName
 * @param action
 * @param message
 * @param task
 */
-public void doLoggingAction(String stageName, boolean action,
+public void doLoggingAction(String stageName, boolean action, String message, Task task,
-String message, Task task, Target target) {
+Target target) {
 String time = getDateTime();
 File fileName;
 if (stageName.equalsIgnoreCase("default")) {
-if (stageRecordMap.get("default") == null)
+if (stageRecordMap.get("default") == null) {
 throw new BuildException("stageRecordMap.get('default') is null");
+}
 fileName = stageRecordMap.get("default").getDefaultOutput();
 } else {
 fileName = stageRecordMap.get(stageName).getOutput();
 }
 if (fileName.exists()) {
-for (Map.Entry<File, RecorderEntry> entry : recorderEntries
+for (Map.Entry<File, RecorderEntry> entry : recorderEntries.entrySet()) {
-.entrySet()) {
+if (fileName.equals(entry.getKey()) && (getRecorderEntry(fileName) != null)
-if (fileName.equals(entry.getKey())
+&& (fileCreatedMap.get(fileName))) {
-&& (getRecorderEntry(fileName) != null)
-&& (fileCreatedMap.get(fileName))) {
 RecorderEntry recorderEntry = getRecorderEntry(fileName);
-recorderEntry.addLogMessage(message + " logging into "
+recorderEntry.addLogMessage(message + " logging into " + fileName + " from "
-+ fileName + " from " + task.getTaskName()
++ task.getTaskName() + " task at " + time);
-+ " task at " + time);
+log.debug(message + " logging into " + fileName + " from " + task.getTaskName()
-log.debug(message + " logging into " + fileName + " from "
++ " task at " + time);
-+ task.getTaskName() + " task at " + time);
 recorderEntry.setRecordState(action);
 break;
 }
 }
 }
 }
 /**
-* Called by LogReplace task to find and replace any property values which
+* Called by LogReplace task to find and replace any property values which are not updated.
-* are not updated.
 *
 * @param regExp
 */
 public void addRegExp(String regExp) {
 if (!regExp.equals("")) {
-for (Map.Entry<File, RecorderEntry> entry : recorderEntries
+for (Map.Entry<File, RecorderEntry> entry : recorderEntries.entrySet()) {
-.entrySet()) {
 RecorderEntry recorderEntry = entry.getValue();
 recorderEntry.addRegexp(regExp);
 }
 }
 }
 /**
-* To initialize stages information.
+* Initializing stage logging data.
-*
+* Gathering all stagerecord.
-* @param proj
+*
-*/
+* @param project
+*/
 @SuppressWarnings("unchecked")
-private void initStagesInformation(Project proj) {
+private void initialize(Project project) {
-log.debug("initStagesInformation: project: " + proj.getName());
+Map<String, Object> references = (Hashtable<String, Object>)project.getReferences();
-Hashtable<String, Object> references = proj.getReferences();
+//matchStageName(references, stageKey);
-Enumeration<String> keyEnum = references.keys();
+for (Entry<String, Object> entry : references.entrySet()) {
-validateDefaultStage(references);
+if (entry.getValue() instanceof StageLogging) {
-while (keyEnum.hasMoreElements()) {
+StageLogging tempStageLogging = (StageLogging)entry.getValue();
-String key = keyEnum.nextElement();
+// Is the stagerecord having a defaultoutput attribute,
-if (references.get(key) instanceof Stage) {
+// if yes, it is the default recorder.
-Stage tempStage = (Stage) references.get(key);
+if (tempStageLogging.getDefaultOutput() != null) {
-validateStageInformation(key, tempStage);
+stageRecordMap.put("default", tempStageLogging);
-log.debug("Found  stage [" + key + "] for recording");
+registerRecorderEntry(tempStageLogging.getDefaultOutput(), tempStageLogging, StatusAndLogListener.getStatusAndLogListener().getProject());
-stagesMapping.put(key, (Stage) references.get(key));
+} else if (tempStageLogging.getStageRefID() != null) {
-getStageRecordInformation(proj, key);
+if (references.containsKey(tempStageLogging.getStageRefID())) {
-initDependentTargetMap(proj, key, tempStage.getStartTarget(),
+if (references.get(tempStageLogging.getStageRefID()) instanceof Stage) {
-tempStage.getEndTarget());
+// Check the stage
-}
+Stage stage = (Stage)references.get(tempStageLogging.getStageRefID());
-}
+validateStageInformation(tempStageLogging.getStageRefID(), stage);
-}
+log.debug("Found  stage [" + tempStageLogging.getStageRefID() + "] for recording");
+stagesMapping.put(tempStageLogging.getStageRefID(), stage);
-/**
+//  check the stage logging.
-* To initialize stage record information.
+validateStageLogging(entry.getKey(), tempStageLogging);
-*
+stageRecordMap.put(tempStageLogging.getStageRefID(), tempStageLogging);
-* @param proj
+} else {
-* @param stageKey
+throw new BuildException("Invalid stagerecord stageRefId attribute value, " +
-*/
+"the '" + tempStageLogging.getStageRefID() + "' id doesn't refer to a stage type at " +
-@SuppressWarnings("unchecked")
+tempStageLogging.getLocation().toString());
-private void getStageRecordInformation(Project proj, String stageKey) {
-Hashtable<String, Object> references = proj.getReferences();
+}
-matchStageName(references, stageKey);
+} else {
-Enumeration<String> keyEnum = references.keys();
+throw new BuildException("Invalid stagerecord stageRefId attribute value, " +
-while (keyEnum.hasMoreElements()) {
+"the '" + tempStageLogging.getStageRefID() + "' id doesn't exist at " +
-String key = keyEnum.nextElement();
+tempStageLogging.getLocation().toString());
-if (references.get(key) instanceof StageLogging) {
+}
-StageLogging tempStageLogging = (StageLogging) references
+} else {
-.get(key);
+throw new BuildException("Invalid stagerecord configuration, " +
-if ((tempStageLogging.getStageRefID() != null)
+"the stageRefId attribute is not defined at " +
-&& (tempStageLogging.getStageRefID().equals(stageKey))) {
+tempStageLogging.getLocation().toString());
-validateStageLogging(key, tempStageLogging);
-stageRecordMap.put(stageKey, tempStageLogging);
-return;
 }
 }
 }
-}
+if (!stageRecordMap.containsKey("default")) {
+throw new BuildException("There must be one default stagerecord datatype.");
+}
+}
 /**
 * To start logging for respective stage.
 *
 * @param stageName
 */
 log.debug("Starting logging for [" + stageName + "]");
 if (stageName.equals("default")) {
 fileName = stageRecordMap.get("default").getDefaultOutput();
 stageLogging = stageRecordMap.get("default");
 message = "Starting logging into " + fileName + " at " + time;
-} else {
+}
+else {
 fileName = stageRecordMap.get(stageName).getOutput();
 stageLogging = stageRecordMap.get(stageName);
 this.isStageRecordingHappening = true;
-message = "Starting logging for " + stageName + " into " + fileName
+message = "Starting logging for " + stageName + " into " + fileName + " at " + time;
-+ " at " + time;
 }
 if (getRecorderEntry(fileName) != null) {
 RecorderEntry recorderEntry = getRecorderEntry(fileName);
 if (isFilePresent(recorderEntry, fileName, stageLogging)) {
 recorderEntry.setRecordState(true);
 * @param recorderEntry
 * @param fileName
 * @param stageLogging
 * @return
 */
-private boolean isFilePresent(RecorderEntry recorderEntry, File fileName, StageLogging stageLogging) {
+private boolean isFilePresent(RecorderEntry recorderEntry, File fileName,
+StageLogging stageLogging) {
 log.debug("isFilePresent? " + fileName);
 if (!fileCreatedMap.get(fileName)) {
 if (!fileName.getParentFile().exists()) {
 log.debug("Creating dir: " + fileName.getParentFile());
 fileName.getParentFile().mkdirs();
 }
 if (fileName.exists()) {
 long timestamp = System.currentTimeMillis();
-getProject().log("Backing up of " + fileName + " into " + fileName + "." + timestamp);
+getProject().log("Backing up of " + fileName + " into " + fileName + "."
++ timestamp);
 fileName.renameTo(new File(fileName.getAbsoluteFile() + "." + timestamp));
 }
 recorderEntry.openFile(stageLogging.getAppend());
 fileCreatedMap.put(fileName, true);
 return true;
-} else {
+}
+else {
 return true;
 }
 }
 *
 * @param stopStageName
 * @param startStageName
 * @param event
 */
-private void stopLog(String stopStageName, String startStageName,
+private void stopLog(String stopStageName, String startStageName, BuildEvent event) {
-BuildEvent event) {
 File fileName;
 String message;
 String time = getDateTime();
 log.debug("Stopping logging for [" + stopStageName + "]");
 if (stopStageName.equals("default")) {
 fileName = stageRecordMap.get("default").getDefaultOutput();
 message = "Stopping logging into " + fileName + " at " + time;
-if (startStageName != null)
+if (startStageName != null) {
 message = message + "\nStarting logging into "
 + stageRecordMap.get(startStageName).getOutput();
-} else {
+}
+}
+else {
 fileName = stageRecordMap.get(stopStageName).getOutput();
 this.isStageRecordingHappening = false;
-message = "Stopping logging for " + stopStageName + " into "
+message = "Stopping logging for " + stopStageName + " into " + fileName + " at " + time;
-+ fileName + " at " + time;
+if (startStageName != null) {
-if (startStageName != null)
 message = message + "\nResuming logging into "
 + stageRecordMap.get("default").getDefaultOutput();
+}
 }
 if (getRecorderEntry(fileName) != null) {
 RecorderEntry recorderEntry = getRecorderEntry(fileName);
 if (event != null) {
 recorderEntry.handleBuildFinished(event);
 *
 * @param fileName
 * @param stageLogging
 * @param proj
 */
-private void registerRecorderEntry(File fileName,
+private void registerRecorderEntry(File fileName, StageLogging stageLogging, Project proj) {
-StageLogging stageLogging, Project proj) {
 log.debug("Registering recorderentry for log file [" + fileName + "]");
 RecorderEntry recorderEntry = getRecorder(fileName);
 antLogLevel.setValue(stageLogging.getLogLevel());
 this.setLoglevel(antLogLevel);
 recorderEntry.setMessageOutputLevel(loglevel);
 recorderEntry.setEmacsMode(false);
 recorderEntry.setRecordState(false);
-if (fileCreatedMap.get(fileName) == null)
+if (fileCreatedMap.get(fileName) == null) {
 fileCreatedMap.put(fileName, false);
+}
 }
 /**
 * To check is the stage valid for given start and end targets.
 *
 * @param target
 * @param proj
 * @return
 */
 private String isStageValid(Target target, Project proj) {
-//if (!proj.getName().equals(StatusAndLogListener.getStatusAndLogListener().getProject().getName()) && (StatusAndLogListener.getStatusAndLogListener().getProject().getName() != null)) {
+// if
-initSubProjectDependentTarget(proj);
+// (!proj.getName().equals(StatusAndLogListener.getStatusAndLogListener().getProject().getName())
-//}
+// && (StatusAndLogListener.getStatusAndLogListener().getProject().getName() != null)) {
+initSubProjectDependentTarget(proj);
+// }
 for (Map.Entry<String, Stage> entry : stagesMapping.entrySet()) {
 Stage stage = entry.getValue();
 if (stage.getStartTarget().equals(target.getName())
-&& validateStageTargets(proj, stage.getStartTarget(), stage
+&& validateStageTargets(proj, stage.getStartTarget(), stage.getEndTarget())) {
-.getEndTarget())) {
+log.debug("Found stage [" + entry.getKey() + "] for target [" + target.getName()
-log.debug("Found stage [" + entry.getKey() + "] for target ["
++ "]");
+return entry.getKey();
+}
+if (stageStartTargetMap.get(entry.getKey()) != null) {
+if (stageStartTargetMap.get(entry.getKey()).getName().equals(target.getName())) {
+log.debug("Found stage [" + entry.getKey() + "] for dependent target ["
 + target.getName() + "]");
-return entry.getKey();
-}
-if (stageStartTargetMap.get(entry.getKey()) != null) {
-if (stageStartTargetMap.get(entry.getKey()).getName().equals(
-target.getName())) {
-log.debug("Found stage [" + entry.getKey()
-+ "] for dependent target [" + target.getName()
-+ "]");
 return entry.getKey();
 }
-} else if (isDependentTarget(target, entry.getKey())) {
+}
-log.debug("Found stage [" + entry.getKey()
+else if (isDependentTarget(target, entry.getKey())) {
-+ "] for dependent target [" + target.getName() + "]");
+log.debug("Found stage [" + entry.getKey() + "] for dependent target ["
++ target.getName() + "]");
 return entry.getKey();
 }
 }
 return null;
 }
 * @return
 */
 private boolean isEndTarget(String targetName) {
 if (stagesMapping.get(currentStageName) != null) {
-return stagesMapping.get(currentStageName).getEndTarget().equals(
+return stagesMapping.get(currentStageName).getEndTarget().equals(targetName);
-targetName);
 }
 return false;
 }
 /**
-* To validate is the endtarget and starttarget are present in the current
+* To validate is the endtarget and starttarget are present in the current project.
-* project.
 *
 * @param proj
 * @param startTarget
 * @param endTarget
 * @return
 */
 @SuppressWarnings("unchecked")
-private boolean validateStageTargets(Project proj, String startTarget,
+private boolean validateStageTargets(Project proj, String startTarget, String endTarget) {
-String endTarget) {
 Hashtable<String, String> antTargets = proj.getTargets();
-return antTargets.containsKey(startTarget)
+return antTargets.containsKey(startTarget) && antTargets.containsKey(endTarget);
-&& antTargets.containsKey(endTarget);
 }
 /**
 * To check is recording is happening for any stages.
 *
 * @param stageKey
 * @param startTarget
 * @param endTarget
 */
 @SuppressWarnings("unchecked")
-private void initDependentTargetMap(Project proj, String stageKey,
+private void initDependentTargetMap(Project proj, String stageKey, String startTarget,
-String startTarget, String endTarget) {
+String endTarget) {
 Vector<Target> arrayList = null;
 if (validateStageTargets(proj, startTarget, endTarget)) {
 arrayList = proj.topoSort(startTarget, proj.getTargets(), false);
 log.debug("Target dependency for " + startTarget);
 for (Target target : arrayList) {
 */
 private void initSubProjectDependentTarget(Project proj) {
 for (Map.Entry<String, Stage> entry : stagesMapping.entrySet()) {
 if (depStartTargetMap.get(entry.getKey()) == null) {
-initDependentTargetMap(proj, entry.getKey(), entry.getValue()
+initDependentTargetMap(proj, entry.getKey(), entry.getValue().getStartTarget(), entry.getValue().getEndTarget());
-.getStartTarget(), entry.getValue().getEndTarget());
 }
 }
 }
 /**
 */
 private void validateStageInformation(String stageKey, Stage stage) {
 if (stage.getStartTarget() == null) {
 throw new BuildException("'starttarget' for stage '" + stageKey
 + "' should not be null.");
 }
 if (stage.getEndTarget() == null) {
-throw new BuildException("'endtarget' for stage '" + stageKey
+throw new BuildException("'endtarget' for stage '" + stageKey + "' should not be null.");
-+ "' should not be null.");
 }
 }
 /**
 * To validate each stagelogging data type.
 *
 * @param stagerefid
 * @param stageLogging
 */
-private void validateStageLogging(String stagerefid,
+private void validateStageLogging(String stagerefid, StageLogging stageLogging) {
-StageLogging stageLogging) {
 if (stageLogging.getOutput() == null) {
-throw new BuildException("'output' attribute for stagelogging '"
+throw new BuildException("'output' attribute for stagelogging '" + stagerefid
-+ stagerefid + "' should not be null.");
++ "' should not be null.");
 }
-registerRecorderEntry(stageLogging.getOutput(), stageLogging,
+registerRecorderEntry(stageLogging.getOutput(), stageLogging, StatusAndLogListener.getStatusAndLogListener().getProject());
-StatusAndLogListener.getStatusAndLogListener().getProject());
-}
-/**
-* To validate default stage.
-*
-* @param stageRecord
-*/
-private void validateDefaultStage(Hashtable<String, Object> stageRecord) {
-Enumeration<String> keyEnum = stageRecord.keys();
-while (keyEnum.hasMoreElements()) {
-String key = keyEnum.nextElement();
-if (stageRecord.get(key) instanceof StageLogging) {
-StageLogging tempStageLogging = (StageLogging) stageRecord
-.get(key);
-if ((tempStageLogging.getStageRefID() == null)
-&& (tempStageLogging.getDefaultOutput() != null)) {
-stageRecordMap.put("default", tempStageLogging);
-registerRecorderEntry(tempStageLogging.getDefaultOutput(),
-tempStageLogging, StatusAndLogListener
-.getStatusAndLogListener().getProject());
-return;
-}
-}
-}
-throw new BuildException("There should be one default stagerecord datatype.");
-}
-/**
-* To validate respective stagelogging for stage datatype.
-*
-* @param stageRecord
-* @param stageKey
-*/
-private void matchStageName(Hashtable<String, Object> stageRecord,
-String stageKey) {
-Enumeration<String> keyEnum = stageRecord.keys();
-while (keyEnum.hasMoreElements()) {
-String key = keyEnum.nextElement();
-if (stageRecord.get(key) instanceof StageLogging) {
-StageLogging tempStageLogging = (StageLogging) stageRecord
-.get(key);
-if ((tempStageLogging.getStageRefID() != null)
-&& (tempStageLogging.getStageRefID().equals(stageKey))) {
-return;
-}
-}
-}
-throw new BuildException(
-"there is no stagelogging datatype matching for stage '"
-+ stageKey + "'");
 }
 /**
 * To retrun recorderEntry of respective file.
 *

changeset 628	7c4a911dc066
parent 588	c7c26511138f
child 645	b8d81fa19e7d