| /******************************************************************************* |
| * Copyright (c) 2000, 2016 IBM Corporation and others. All rights reserved. |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v1.0 which accompanies this distribution, |
| * and is available at http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.releng.generators; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.TreeSet; |
| import java.util.Vector; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.SAXException; |
| |
| /** |
| * @version 1.0 |
| * @author |
| */ |
| public class ErrorTracker { |
| |
| public static void main(final String[] args) { |
| |
| // For testing only. Should not be invoked |
| |
| final ErrorTracker anInstance = new ErrorTracker(); |
| anInstance.loadFile("C:\\junk\\testManifest.xml"); |
| final String[] theTypes = anInstance.getTypes(); |
| for (int i = 0; i < theTypes.length; i++) { |
| // System.out.println("Type: " + theTypes[i]); |
| final PlatformStatus[] thePlatforms = anInstance.getPlatforms(theTypes[i]); |
| for (int j = 0; j < thePlatforms.length; j++) { |
| // System.out.println("Out ID: " + thePlatforms[j].getId()); |
| } |
| } |
| } |
| |
| |
| private Set<String> testLogsSet = Collections.checkedSortedSet(new TreeSet<>(),String.class); |
| // Platforms keyed on |
| private final Hashtable<String, PlatformStatus> platforms = new Hashtable<>(); |
| private final Hashtable<String, Vector<PlatformStatus>> logFiles = new Hashtable<>(); |
| private final Hashtable<String, Vector<String>> typesMap = new Hashtable<>(); |
| |
| private final Vector<String> typesList = new Vector<>(); |
| private String convertPathDelimiters(final String path) { |
| return new File(path).getPath(); |
| } |
| |
| public PlatformStatus[] getPlatforms(final String type) { |
| final Vector<String> platformIDs = typesMap.get(type); |
| final PlatformStatus[] result = new PlatformStatus[platformIDs.size()]; |
| for (int i = 0; i < platformIDs.size(); i++) { |
| result[i] = platforms.get(platformIDs.elementAt(i)); |
| } |
| return result; |
| } |
| |
| /** |
| * Returns the testLogs. |
| * |
| * @return Vector |
| */ |
| public List<String> getTestLogs(ArrayList<String> foundConfigs) { |
| // List of test logs expected at end of build |
| // We depend on both test logs and configs being sorted |
| ArrayList<String> testLogs = new ArrayList<>(); |
| for (String initialLogName : testLogsSet) { |
| for (String config : foundConfigs) { |
| testLogs.add(initialLogName + "_" + config + ".xml"); |
| } |
| } |
| return testLogs; |
| } |
| |
| // Answer a string array of the zip type names in the order they appear in |
| // the .xml file. |
| public String[] getTypes() { |
| return typesList.toArray(new String[typesList.size()]); |
| } |
| |
| // Answer an array of PlatformStatus objects for a given type. |
| |
| public boolean hasErrors(final String id) { |
| return platforms.get(id).hasErrors(); |
| } |
| |
| public void loadFile(final String fileName) { |
| final DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance(); |
| DocumentBuilder parser = null; |
| try { |
| parser = docBuilderFactory.newDocumentBuilder(); |
| } |
| catch (final ParserConfigurationException e1) { |
| e1.printStackTrace(); |
| } |
| try { |
| |
| final Document document = parser.parse(fileName); |
| final NodeList elements = document.getElementsByTagName("platform"); |
| final int elementCount = elements.getLength(); |
| for (int i = 0; i < elementCount; i++) { |
| final PlatformStatus aPlatform = new PlatformStatus((Element) elements.item(i)); |
| // System.out.println("ID: " + aPlatform.getId()); |
| platforms.put(aPlatform.getId(), aPlatform); |
| |
| final Node zipType = elements.item(i).getParentNode(); |
| final String zipTypeName = zipType.getAttributes().getNamedItem("name").getNodeValue(); |
| |
| Vector<String> aVector = typesMap.get(zipTypeName); |
| if (aVector == null) { |
| typesList.add(zipTypeName); |
| aVector = new Vector<>(); |
| typesMap.put(zipTypeName, aVector); |
| } |
| aVector.add(aPlatform.getId()); |
| |
| } |
| |
| final NodeList effectedFiles = document.getElementsByTagName("effectedFile"); |
| final int effectedFilesCount = effectedFiles.getLength(); |
| for (int i = 0; i < effectedFilesCount; i++) { |
| final Node anEffectedFile = effectedFiles.item(i); |
| final Node logFile = anEffectedFile.getParentNode(); |
| String logFileName = logFile.getAttributes().getNamedItem("name").getNodeValue(); |
| logFileName = convertPathDelimiters(logFileName); |
| final String effectedFileID = anEffectedFile.getAttributes().getNamedItem("id").getNodeValue(); |
| // System.out.println(logFileName); |
| Vector<PlatformStatus> aVector = logFiles.get(logFileName); |
| if (aVector == null) { |
| aVector = new Vector<>(); |
| logFiles.put(logFileName, aVector); |
| |
| } |
| final PlatformStatus ps = platforms.get(effectedFileID); |
| if (ps != null) { |
| aVector.addElement(ps); |
| } |
| } |
| |
| // store a list of the test logs expected after testing |
| final NodeList testLogList = document.getElementsByTagName("logFile"); |
| final int testLogCount = testLogList.getLength(); |
| for (int i = 0; i < testLogCount; i++) { |
| |
| final Node testLog = testLogList.item(i); |
| final String testLogName = testLog.getAttributes().getNamedItem("name").getNodeValue(); |
| final Node typeNode = testLog.getAttributes().getNamedItem("type"); |
| //String type = "test"; |
| //if (typeNode != null) { |
| // type = typeNode.getNodeValue(); |
| //} |
| //if (testLogName.endsWith(".xml") && type.equals("test")) { |
| // above is how it used to be checked, prior to 4/4/2016, but |
| // test logs are only log file in testManifest.xml without a "type" attribute |
| // -- I test for either/or, so that new versions of testManifest.xml |
| // can more correctly use "test" attribute, if desired. |
| if (typeNode == null || typeNode.getNodeValue().equals("test")) { |
| int firstUnderscore = testLogName.indexOf('_'); |
| String initialTestName = null; |
| if (firstUnderscore == -1) { |
| // no underscore found. Assume testManifest xml has been updated |
| // to mention minimal name. |
| initialTestName = testLogName; |
| } else { |
| initialTestName = testLogName.substring(0, firstUnderscore); |
| } |
| testLogsSet.add(initialTestName); |
| //System.out.println("Debug: initialTestName: " + initialTestName); |
| } |
| |
| } |
| |
| } |
| catch (final IOException e) { |
| System.out.println("IOException: " + fileName); |
| // e.printStackTrace(); |
| |
| } |
| catch (final SAXException e) { |
| System.out.println("SAXException: " + fileName); |
| e.printStackTrace(); |
| |
| } |
| } |
| |
| public void registerError(final String fileName) { |
| // System.out.println("Found an error in: " + fileName); |
| if (logFiles.containsKey(fileName)) { |
| final Vector<PlatformStatus> aVector = logFiles.get(fileName); |
| for (int i = 0; i < aVector.size(); i++) { |
| aVector.elementAt(i).registerError(); |
| } |
| } else { |
| |
| // If a log file is not specified explicitly it effects |
| // all "platforms" except JDT |
| |
| final Enumeration<PlatformStatus> values = platforms.elements(); |
| while (values.hasMoreElements()) { |
| final PlatformStatus aValue = values.nextElement(); |
| if (!aValue.getId().equals("JA") && !aValue.getId().equals("EW") && !aValue.getId().equals("EA")) { |
| aValue.registerError(); |
| } |
| } |
| } |
| } |
| |
| } |