[deliverable/tracecompass.git] / tmf / org.eclipse.tracecompass.tmf.ui / src / org / eclipse / tracecompass / internal / tmf / ui / project / wizards / tracepkg / importexport / ManifestReader.java

/*******************************************************************************
 * Copyright (c) 2013, 2014 Ericsson
 *
 * 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:
 *     Marc-Andre Laperle - Initial API and implementation
 *******************************************************************************/

package org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.importexport;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.tracecompass.internal.tmf.ui.Activator;
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.ITracePackageConstants;
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageBookmarkElement;
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageElement;
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageFilesElement;
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageSupplFileElement;
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageSupplFilesElement;
import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageTraceElement;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * Reads a manifest from an input stream
 *
 * @author Marc-Andre Laperle
 */
public class ManifestReader {

    private static final String SCHEMA_FOLDER_NAME = "schema"; //$NON-NLS-1$
    private static final String EXPORT_MANIFEST_SCHEMA_FILE_NAME = "export-manifest.xsd"; //$NON-NLS-1$
    private static final @NonNull TracePackageElement @NonNull [] EMPTY_ARRAY =
            new @NonNull TracePackageElement[0];

    /**
     * Validate the content of a manifest from an input stream
     *
     * @param input the input stream to validate from
     * @throws IOException on error
     */
    public static void validateManifest(InputStream input) throws IOException
    {
        URL schemaFileUrl = FileLocator.find(Activator.getDefault().getBundle(), new Path(SCHEMA_FOLDER_NAME).append(EXPORT_MANIFEST_SCHEMA_FILE_NAME), null);
        if (schemaFileUrl == null) {
            throw new IOException(MessageFormat.format(Messages.TracePackageExtractManifestOperation_SchemaFileNotFound, EXPORT_MANIFEST_SCHEMA_FILE_NAME));
        }

        try {
            SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
            Schema schema = factory.newSchema(new StreamSource(schemaFileUrl.openStream()));
            Validator validator = schema.newValidator();
            validator.validate(new StreamSource(input));
        } catch (SAXException e) {
            throw new IOException(Messages.TracePackageExtractManifestOperation_ErrorManifestNotValid, e);
        } catch (IOException e) {
            throw new IOException(Messages.TracePackageExtractManifestOperation_ErrorManifestNotValid, e);
        }
    }

    /**
     * Load package elements from a manifest (input stream)
     *
     * The manifest looks like this:
     *
     * <?xml version="1.0" encoding="UTF-8" standalone="no"?>
     * <tmf-export>
     *     <trace name="trace2" type="org.eclipse.linuxtools.lttng2.kernel.tracetype">
     *         <file name="Traces/trace2"/> <supplementary-file name=".tracing/trace2/stateHistory.ht"/>
     *         <bookmarks>
     *             <bookmark location="4" message= "15:50:47.314 069 885, channel0_0, sys_recvmsg, fd=16, msg=0x7faada7d1ae0, flags=256" />
     *         </bookmarks>
     *     </trace>
     * </tmf-export>
     *
     * See schema/export-manifest.xsd for details.
     *
     * @param inputStream
     *            the input stream that contains the manifest
     * @return the loaded elements
     * @throws IOException
     *             when an error occurs when parsing
     * @throws SAXException
     *             when an error occurs when parsing
     * @throws ParserConfigurationException
     *             when an error occurs when parsing
     */
    public static TracePackageElement[] loadElementsFromManifest(InputStream inputStream) throws IOException, SAXException, ParserConfigurationException {
        Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream);
        Element rootElement = doc.getDocumentElement();
        return loadElementsFromNode(rootElement);
    }

    /**
     * Load package elements from a manifest (XML element)
     *
     * @param rootElement
     *            the root element to start loading from
     * @return the loaded elements
     */
    public static TracePackageElement[] loadElementsFromNode(Element rootElement) {
        List<TracePackageElement> packageElements = new ArrayList<>();
        NodeList traceElements = rootElement.getElementsByTagName(ITracePackageConstants.TRACE_ELEMENT);
        for (int i = 0; i < traceElements.getLength(); i++) {
            Node traceNode = traceElements.item(i);
            if (traceNode.getNodeType() == Node.ELEMENT_NODE) {
                Element traceElement = (Element) traceNode;
                String traceName = traceElement.getAttribute(ITracePackageConstants.TRACE_NAME_ATTRIB);
                String traceType = traceElement.getAttribute(ITracePackageConstants.TRACE_TYPE_ATTRIB);
                TracePackageElement element = new TracePackageTraceElement(null, traceName, traceType);
                NodeList fileElements = traceElement.getElementsByTagName(ITracePackageConstants.TRACE_FILE_ELEMENT);
                for (int j = 0; j < fileElements.getLength(); j++) {
                    Node fileNode = fileElements.item(j);
                    if (fileNode.getNodeType() == Node.ELEMENT_NODE) {
                        Element fileElement = (Element) fileNode;
                        String fileName = fileElement.getAttribute(ITracePackageConstants.TRACE_FILE_NAME_ATTRIB);
                        new TracePackageFilesElement(element, fileName);
                    }
                }

                // Supplementary files
                NodeList suppFilesElements = traceElement.getElementsByTagName(ITracePackageConstants.SUPPLEMENTARY_FILE_ELEMENT);
                if (suppFilesElements.getLength() > 0) {
                    TracePackageSupplFilesElement supplFilesElement = new TracePackageSupplFilesElement(element);
                    for (int j = 0; j < suppFilesElements.getLength(); j++) {
                        Node suppFileNode = suppFilesElements.item(j);
                        if (suppFileNode.getNodeType() == Node.ELEMENT_NODE) {
                            Element suppFileElement = (Element) suppFileNode;
                            String fileName = suppFileElement.getAttribute(ITracePackageConstants.SUPPLEMENTARY_FILE_NAME_ATTRIB);
                            new TracePackageSupplFileElement(fileName, supplFilesElement);
                        }
                    }
                }

                // bookmarks
                List<Map<String, String>> bookmarkAttribs = new ArrayList<>();
                NodeList bookmarksElements = traceElement.getElementsByTagName(ITracePackageConstants.BOOKMARKS_ELEMENT);
                for (int j = 0; j < bookmarksElements.getLength(); j++) {
                    Node bookmarksNode = bookmarksElements.item(j);
                    if (bookmarksNode.getNodeType() == Node.ELEMENT_NODE) {
                        NodeList bookmarkElements = traceElement.getElementsByTagName(ITracePackageConstants.BOOKMARK_ELEMENT);
                        for (int k = 0; k < bookmarkElements.getLength(); k++) {
                            Node bookmarkNode = bookmarkElements.item(k);
                            if (bookmarkNode.getNodeType() == Node.ELEMENT_NODE) {
                                Element bookmarkElement = (Element) bookmarkNode;
                                NamedNodeMap attributesMap = bookmarkElement.getAttributes();
                                Map<String, String> attribs = new HashMap<>();
                                for (int l = 0; l < attributesMap.getLength(); l++) {
                                    Node item = attributesMap.item(l);
                                    attribs.put(item.getNodeName(), item.getNodeValue());
                                }
                                bookmarkAttribs.add(attribs);
                            }
                        }
                    }
                }
                if (!bookmarkAttribs.isEmpty()) {
                    new TracePackageBookmarkElement(element, bookmarkAttribs);
                }

                packageElements.add(element);
            }
        }
        return packageElements.toArray(EMPTY_ARRAY);
    }

}
Commit	Line	Data
30bf6b07 MAL	1	/*******************************************************************************
	2	* Copyright (c) 2013, 2014 Ericsson
	3	*
	4	* All rights reserved. This program and the accompanying materials are
	5	* made available under the terms of the Eclipse Public License v1.0 which
	6	* accompanies this distribution, and is available at
	7	* http://www.eclipse.org/legal/epl-v10.html
	8	*
	9	* Contributors:
	10	* Marc-Andre Laperle - Initial API and implementation
	11	*******************************************************************************/
	12
2bdf0193	13	package org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.importexport;
30bf6b07 MAL	14
	15	import java.io.IOException;
	16	import java.io.InputStream;
	17	import java.net.URL;
	18	import java.text.MessageFormat;
	19	import java.util.ArrayList;
	20	import java.util.HashMap;
	21	import java.util.List;
	22	import java.util.Map;
	23
	24	import javax.xml.XMLConstants;
	25	import javax.xml.parsers.DocumentBuilderFactory;
	26	import javax.xml.parsers.ParserConfigurationException;
	27	import javax.xml.transform.stream.StreamSource;
	28	import javax.xml.validation.Schema;
	29	import javax.xml.validation.SchemaFactory;
	30	import javax.xml.validation.Validator;
	31
	32	import org.eclipse.core.runtime.FileLocator;
	33	import org.eclipse.core.runtime.Path;
aa353506	34	import org.eclipse.jdt.annotation.NonNull;
2bdf0193 AM	35	import org.eclipse.tracecompass.internal.tmf.ui.Activator;
	36	import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.ITracePackageConstants;
	37	import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageBookmarkElement;
	38	import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageElement;
	39	import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageFilesElement;
	40	import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageSupplFileElement;
	41	import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageSupplFilesElement;
	42	import org.eclipse.tracecompass.internal.tmf.ui.project.wizards.tracepkg.TracePackageTraceElement;
30bf6b07 MAL	43	import org.w3c.dom.Document;
	44	import org.w3c.dom.Element;
	45	import org.w3c.dom.NamedNodeMap;
	46	import org.w3c.dom.Node;
	47	import org.w3c.dom.NodeList;
	48	import org.xml.sax.SAXException;
	49
	50	/**
	51	* Reads a manifest from an input stream
	52	*
	53	* @author Marc-Andre Laperle
	54	*/
	55	public class ManifestReader {
	56
	57	private static final String SCHEMA_FOLDER_NAME = "schema"; //$NON-NLS-1$
	58	private static final String EXPORT_MANIFEST_SCHEMA_FILE_NAME = "export-manifest.xsd"; //$NON-NLS-1$
aa353506 AM	59	private static final @NonNull TracePackageElement @NonNull [] EMPTY_ARRAY =
aa353506 AM	60	new @NonNull TracePackageElement[0];
30bf6b07 MAL	61
	62	/**
	63	* Validate the content of a manifest from an input stream
	64	*
	65	* @param input the input stream to validate from
	66	* @throws IOException on error
	67	*/
	68	public static void validateManifest(InputStream input) throws IOException
	69	{
	70	URL schemaFileUrl = FileLocator.find(Activator.getDefault().getBundle(), new Path(SCHEMA_FOLDER_NAME).append(EXPORT_MANIFEST_SCHEMA_FILE_NAME), null);
	71	if (schemaFileUrl == null) {
	72	throw new IOException(MessageFormat.format(Messages.TracePackageExtractManifestOperation_SchemaFileNotFound, EXPORT_MANIFEST_SCHEMA_FILE_NAME));
	73	}
	74
	75	try {
	76	SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
	77	Schema schema = factory.newSchema(new StreamSource(schemaFileUrl.openStream()));
	78	Validator validator = schema.newValidator();
	79	validator.validate(new StreamSource(input));
	80	} catch (SAXException e) {
	81	throw new IOException(Messages.TracePackageExtractManifestOperation_ErrorManifestNotValid, e);
	82	} catch (IOException e) {
	83	throw new IOException(Messages.TracePackageExtractManifestOperation_ErrorManifestNotValid, e);
	84	}
	85	}
	86
	87	/**
	88	* Load package elements from a manifest (input stream)
	89	*
	90	* The manifest looks like this:
	91	*
	92	* <?xml version="1.0" encoding="UTF-8" standalone="no"?>
	93	* <tmf-export>
	94	* <trace name="trace2" type="org.eclipse.linuxtools.lttng2.kernel.tracetype">
	95	* <file name="Traces/trace2"/> <supplementary-file name=".tracing/trace2/stateHistory.ht"/>
	96	* <bookmarks>
	97	* <bookmark location="4" message= "15:50:47.314 069 885, channel0_0, sys_recvmsg, fd=16, msg=0x7faada7d1ae0, flags=256" />
	98	* </bookmarks>
	99	* </trace>
	100	* </tmf-export>
	101	*
	102	* See schema/export-manifest.xsd for details.
	103	*
	104	* @param inputStream
	105	* the input stream that contains the manifest
	106	* @return the loaded elements
	107	* @throws IOException
	108	* when an error occurs when parsing
	109	* @throws SAXException
	110	* when an error occurs when parsing
	111	* @throws ParserConfigurationException
	112	* when an error occurs when parsing
	113	*/
	114	public static TracePackageElement[] loadElementsFromManifest(InputStream inputStream) throws IOException, SAXException, ParserConfigurationException {
30bf6b07	115	Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputStream);
49ab632e MAL	116	Element rootElement = doc.getDocumentElement();
	117	return loadElementsFromNode(rootElement);
	118	}
30bf6b07	119
49ab632e MAL	120	/**
	121	* Load package elements from a manifest (XML element)
	122	*
	123	* @param rootElement
	124	* the root element to start loading from
	125	* @return the loaded elements
	126	*/
	127	public static TracePackageElement[] loadElementsFromNode(Element rootElement) {
	128	List<TracePackageElement> packageElements = new ArrayList<>();
49ab632e	129	NodeList traceElements = rootElement.getElementsByTagName(ITracePackageConstants.TRACE_ELEMENT);
30bf6b07 MAL	130	for (int i = 0; i < traceElements.getLength(); i++) {
	131	Node traceNode = traceElements.item(i);
	132	if (traceNode.getNodeType() == Node.ELEMENT_NODE) {
	133	Element traceElement = (Element) traceNode;
	134	String traceName = traceElement.getAttribute(ITracePackageConstants.TRACE_NAME_ATTRIB);
	135	String traceType = traceElement.getAttribute(ITracePackageConstants.TRACE_TYPE_ATTRIB);
a2f3a454	136	TracePackageElement element = new TracePackageTraceElement(null, traceName, traceType);
30bf6b07 MAL	137	NodeList fileElements = traceElement.getElementsByTagName(ITracePackageConstants.TRACE_FILE_ELEMENT);
	138	for (int j = 0; j < fileElements.getLength(); j++) {
	139	Node fileNode = fileElements.item(j);
	140	if (fileNode.getNodeType() == Node.ELEMENT_NODE) {
	141	Element fileElement = (Element) fileNode;
	142	String fileName = fileElement.getAttribute(ITracePackageConstants.TRACE_FILE_NAME_ATTRIB);
a2f3a454	143	new TracePackageFilesElement(element, fileName);
30bf6b07 MAL	144	}
	145	}
	146
30bf6b07	147	// Supplementary files
30bf6b07	148	NodeList suppFilesElements = traceElement.getElementsByTagName(ITracePackageConstants.SUPPLEMENTARY_FILE_ELEMENT);
a2f3a454 MAL	149	if (suppFilesElements.getLength() > 0) {
	150	TracePackageSupplFilesElement supplFilesElement = new TracePackageSupplFilesElement(element);
	151	for (int j = 0; j < suppFilesElements.getLength(); j++) {
	152	Node suppFileNode = suppFilesElements.item(j);
	153	if (suppFileNode.getNodeType() == Node.ELEMENT_NODE) {
	154	Element suppFileElement = (Element) suppFileNode;
	155	String fileName = suppFileElement.getAttribute(ITracePackageConstants.SUPPLEMENTARY_FILE_NAME_ATTRIB);
	156	new TracePackageSupplFileElement(fileName, supplFilesElement);
	157	}
30bf6b07 MAL	158	}
	159	}
	160
30bf6b07 MAL	161	// bookmarks
	162	List<Map<String, String>> bookmarkAttribs = new ArrayList<>();
	163	NodeList bookmarksElements = traceElement.getElementsByTagName(ITracePackageConstants.BOOKMARKS_ELEMENT);
	164	for (int j = 0; j < bookmarksElements.getLength(); j++) {
	165	Node bookmarksNode = bookmarksElements.item(j);
	166	if (bookmarksNode.getNodeType() == Node.ELEMENT_NODE) {
	167	NodeList bookmarkElements = traceElement.getElementsByTagName(ITracePackageConstants.BOOKMARK_ELEMENT);
	168	for (int k = 0; k < bookmarkElements.getLength(); k++) {
	169	Node bookmarkNode = bookmarkElements.item(k);
	170	if (bookmarkNode.getNodeType() == Node.ELEMENT_NODE) {
	171	Element bookmarkElement = (Element) bookmarkNode;
	172	NamedNodeMap attributesMap = bookmarkElement.getAttributes();
	173	Map<String, String> attribs = new HashMap<>();
	174	for (int l = 0; l < attributesMap.getLength(); l++) {
	175	Node item = attributesMap.item(l);
	176	attribs.put(item.getNodeName(), item.getNodeValue());
	177	}
	178	bookmarkAttribs.add(attribs);
	179	}
	180	}
	181	}
	182	}
	183	if (!bookmarkAttribs.isEmpty()) {
a2f3a454	184	new TracePackageBookmarkElement(element, bookmarkAttribs);
30bf6b07 MAL	185	}
30bf6b07 MAL	186
30bf6b07 MAL	187	packageElements.add(element);
	188	}
	189	}
	190	return packageElements.toArray(EMPTY_ARRAY);
	191	}
	192
	193	}