src/share/classes/com/sun/servicetag/RegistrationDocument.java - toolchain/jdk/jdk9_jdk - Git at Google

 /*
  * Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package com.sun.servicetag;

 import java.io.*;
 import java.net.URL;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Set;

 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;
 import org.xml.sax.InputSource;

 import javax.xml.XMLConstants;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.validation.Schema;
 import javax.xml.validation.SchemaFactory;
 import javax.xml.validation.Validator;

 // For write operation
 import javax.xml.transform.OutputKeys;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerException;
 import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.TransformerConfigurationException;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.stream.StreamResult;

 /**
  * XML Support Class for Product Registration.
  */
 class RegistrationDocument {

     private static final String REGISTRATION_DATA_SCHEMA =
             "/com/sun/servicetag/resources/product_registration.xsd";
     private static final String REGISTRATION_DATA_VERSION = "1.0";
     private static final String SERVICE_TAG_VERSION = "1.0";
     final static String ST_NODE_REGISTRATION_DATA = "registration_data";
     final static String ST_ATTR_REGISTRATION_VERSION = "version";
     final static String ST_NODE_ENVIRONMENT = "environment";
     final static String ST_NODE_HOSTNAME = "hostname";
     final static String ST_NODE_HOST_ID = "hostId";
     final static String ST_NODE_OS_NAME = "osName";
     final static String ST_NODE_OS_VERSION = "osVersion";
     final static String ST_NODE_OS_ARCH = "osArchitecture";
     final static String ST_NODE_SYSTEM_MODEL = "systemModel";
     final static String ST_NODE_SYSTEM_MANUFACTURER = "systemManufacturer";
     final static String ST_NODE_CPU_MANUFACTURER = "cpuManufacturer";
     final static String ST_NODE_SERIAL_NUMBER = "serialNumber";
     final static String ST_NODE_REGISTRY = "registry";
     final static String ST_ATTR_REGISTRY_URN = "urn";
     final static String ST_ATTR_REGISTRY_VERSION = "version";
     final static String ST_NODE_SERVICE_TAG = "service_tag";
     final static String ST_NODE_INSTANCE_URN = "instance_urn";
     final static String ST_NODE_PRODUCT_NAME = "product_name";
     final static String ST_NODE_PRODUCT_VERSION = "product_version";
     final static String ST_NODE_PRODUCT_URN = "product_urn";
     final static String ST_NODE_PRODUCT_PARENT_URN = "product_parent_urn";
     final static String ST_NODE_PRODUCT_PARENT = "product_parent";
     final static String ST_NODE_PRODUCT_DEFINED_INST_ID = "product_defined_inst_id";
     final static String ST_NODE_PRODUCT_VENDOR = "product_vendor";
     final static String ST_NODE_PLATFORM_ARCH = "platform_arch";
     final static String ST_NODE_TIMESTAMP = "timestamp";
     final static String ST_NODE_CONTAINER = "container";
     final static String ST_NODE_SOURCE = "source";
     final static String ST_NODE_INSTALLER_UID = "installer_uid";

     static RegistrationData load(InputStream in) throws IOException {
         Document document = initializeDocument(in);

         // Gets the registration URN
         Element root = getRegistrationDataRoot(document);
         Element registryRoot =
                 getSingletonElementFromRoot(root, ST_NODE_REGISTRY);
         String urn = registryRoot.getAttribute(ST_ATTR_REGISTRY_URN);

         // Construct a new RegistrationData object from the DOM tree
         // Initialize the environment map and service tags
         RegistrationData regData = new RegistrationData(urn);
         addServiceTags(registryRoot, regData);

         Element envRoot = getSingletonElementFromRoot(root, ST_NODE_ENVIRONMENT);
         buildEnvironmentMap(envRoot, regData);
         return regData;
     }

     static void store(OutputStream os, RegistrationData registration)
             throws IOException {
         // create a new document with the root node
         Document document = initializeDocument();

         // create the nodes for the environment map and the service tags
         // in the registration data
         addEnvironmentNodes(document,
                             registration.getEnvironmentMap());
         addServiceTagRegistry(document,
                               registration.getRegistrationURN(),
                               registration.getServiceTags());
         transform(document, os);
     }

     // initialize a document from an input stream
     private static Document initializeDocument(InputStream in) throws IOException {
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
         try {
             // XML schema for validation
             SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
             URL xsdUrl = RegistrationDocument.class.getResource(REGISTRATION_DATA_SCHEMA);
             Schema schema = sf.newSchema(xsdUrl);
             Validator validator = schema.newValidator();

             DocumentBuilder builder = factory.newDocumentBuilder();
             Document doc = builder.parse(new InputSource(in));
             validator.validate(new DOMSource(doc));
             return doc;
         } catch (SAXException sxe) {
             IllegalArgumentException e = new IllegalArgumentException("Error generated in parsing");
             e.initCause(sxe);
             throw e;
         } catch (ParserConfigurationException pce) {
             // Parser with specific options can't be built
             // should not reach here
             InternalError x = new InternalError("Error in creating the new document");
             x.initCause(pce);
             throw x;
         }
     }

     // initialize a new document for the registration data
     private static Document initializeDocument() throws IOException {
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
         try {
             DocumentBuilder builder = factory.newDocumentBuilder();
             Document doc = builder.newDocument();

             // initialize the document with the registration_data root
             Element root = doc.createElement(ST_NODE_REGISTRATION_DATA);
             doc.appendChild(root);
             root.setAttribute(ST_ATTR_REGISTRATION_VERSION, REGISTRATION_DATA_VERSION);

             return doc;
         } catch (ParserConfigurationException pce) {
             // Parser with specified options can't be built
             // should not reach here
             InternalError x = new InternalError("Error in creating the new document");
             x.initCause(pce);
             throw x;
         }
     }

     // Transform the current DOM tree with the given output stream.
     private static void transform(Document document, OutputStream os) {
         try {
             // Use a Transformer for output
             TransformerFactory tFactory = TransformerFactory.newInstance();
             tFactory.setAttribute("indent-number", new Integer(3));

             Transformer transformer = tFactory.newTransformer();

             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
             transformer.setOutputProperty(OutputKeys.METHOD, "xml");
             transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
             transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
             transformer.transform(new DOMSource(document),
                 new StreamResult(new BufferedWriter(new OutputStreamWriter(os, "UTF-8"))));
         } catch (UnsupportedEncodingException ue) {
             // Should not reach here
             InternalError x = new InternalError("Error generated during transformation");
             x.initCause(ue);
             throw x;
         } catch (TransformerConfigurationException tce) {
             // Error generated by the parser
             // Should not reach here
             InternalError x = new InternalError("Error in creating the new document");
             x.initCause(tce);
             throw x;
         } catch (TransformerException te) {
             // Error generated by the transformer
             InternalError x = new InternalError("Error generated during transformation");
             x.initCause(te);
             throw x;
         }
     }

     private static void addServiceTagRegistry(Document document,
                                               String registryURN,
                                               Set<ServiceTag> svcTags) {
         // add service tag registry node and its attributes
         Element reg = document.createElement(ST_NODE_REGISTRY);
         reg.setAttribute(ST_ATTR_REGISTRY_URN, registryURN);
         reg.setAttribute(ST_ATTR_REGISTRY_VERSION, SERVICE_TAG_VERSION);

         Element root = getRegistrationDataRoot(document);
         root.appendChild(reg);

         // adds the elements for the service tags
         for (ServiceTag st : svcTags) {
             addServiceTagElement(document, reg, st);
         }
     }

     private static void addServiceTagElement(Document document,
                                              Element registryRoot,
                                              ServiceTag st) {
         Element svcTag = document.createElement(ST_NODE_SERVICE_TAG);
         registryRoot.appendChild(svcTag);
         addChildElement(document, svcTag,
                         ST_NODE_INSTANCE_URN, st.getInstanceURN());
         addChildElement(document, svcTag,
                         ST_NODE_PRODUCT_NAME, st.getProductName());
         addChildElement(document, svcTag,
                         ST_NODE_PRODUCT_VERSION, st.getProductVersion());
         addChildElement(document, svcTag,
                         ST_NODE_PRODUCT_URN, st.getProductURN());
         addChildElement(document, svcTag,
                         ST_NODE_PRODUCT_PARENT_URN, st.getProductParentURN());
         addChildElement(document, svcTag,
                         ST_NODE_PRODUCT_PARENT, st.getProductParent());
         addChildElement(document, svcTag,
                         ST_NODE_PRODUCT_DEFINED_INST_ID,
                         st.getProductDefinedInstanceID());
         addChildElement(document, svcTag,
                         ST_NODE_PRODUCT_VENDOR, st.getProductVendor());
         addChildElement(document, svcTag,
                         ST_NODE_PLATFORM_ARCH, st.getPlatformArch());
         addChildElement(document, svcTag,
                         ST_NODE_TIMESTAMP, Util.formatTimestamp(st.getTimestamp()));
         addChildElement(document, svcTag,
                         ST_NODE_CONTAINER, st.getContainer());
         addChildElement(document, svcTag,
                         ST_NODE_SOURCE, st.getSource());
         addChildElement(document, svcTag,
                         ST_NODE_INSTALLER_UID,
                         String.valueOf(st.getInstallerUID()));
     }

     private static void addChildElement(Document document, Element root,
                                         String element, String text) {
         Element node = document.createElement(element);
         node.appendChild(document.createTextNode(text));
         root.appendChild(node);
     }

     // Constructs service tags from the document
     private static void addServiceTags(Element registryRoot,
                                        RegistrationData registration) {
         NodeList children = registryRoot.getElementsByTagName(ST_NODE_SERVICE_TAG);
         int length = (children == null ? 0 : children.getLength());
         for (int i = 0; i < length; i++) {
             Element svcTagElement = (Element) children.item(i);
             ServiceTag st = getServiceTag(svcTagElement);
             registration.addServiceTag(st);
         }
     }

     // build environment map from the document
     private static void buildEnvironmentMap(Element envRoot,
                                          RegistrationData registration) {
         registration.setEnvironment(ST_NODE_HOSTNAME, getTextValue(envRoot, ST_NODE_HOSTNAME));
         registration.setEnvironment(ST_NODE_HOST_ID, getTextValue(envRoot, ST_NODE_HOST_ID));
         registration.setEnvironment(ST_NODE_OS_NAME, getTextValue(envRoot, ST_NODE_OS_NAME));
         registration.setEnvironment(ST_NODE_OS_VERSION, getTextValue(envRoot, ST_NODE_OS_VERSION));
         registration.setEnvironment(ST_NODE_OS_ARCH, getTextValue(envRoot, ST_NODE_OS_ARCH));
         registration.setEnvironment(ST_NODE_SYSTEM_MODEL, getTextValue(envRoot, ST_NODE_SYSTEM_MODEL));
         registration.setEnvironment(ST_NODE_SYSTEM_MANUFACTURER, getTextValue(envRoot, ST_NODE_SYSTEM_MANUFACTURER));
         registration.setEnvironment(ST_NODE_CPU_MANUFACTURER, getTextValue(envRoot, ST_NODE_CPU_MANUFACTURER));
         registration.setEnvironment(ST_NODE_SERIAL_NUMBER, getTextValue(envRoot, ST_NODE_SERIAL_NUMBER));
     }

     // add the nodes representing the environment map in the document
     private static void addEnvironmentNodes(Document document,
                                             Map<String, String> envMap) {
         Element root = getRegistrationDataRoot(document);
         Element env = document.createElement(ST_NODE_ENVIRONMENT);
         root.appendChild(env);
         Set<Map.Entry<String, String>> keys = envMap.entrySet();
         for (Map.Entry<String, String> entry : keys) {
             addChildElement(document, env, entry.getKey(), entry.getValue());
         }
     }

     private static Element getRegistrationDataRoot(Document doc) {
         Element root = doc.getDocumentElement();
         if (!root.getNodeName().equals(ST_NODE_REGISTRATION_DATA)) {
             throw new IllegalArgumentException("Not a " +
                     ST_NODE_REGISTRATION_DATA +
                     " node \"" + root.getNodeName() + "\"");
         }
         return root;
     }

     private static Element getSingletonElementFromRoot(Element root, String name) {
         NodeList children = root.getElementsByTagName(name);
         int length = (children == null ? 0 : children.getLength());
         if (length != 1) {
             throw new IllegalArgumentException("Invalid number of " + name +
                     " nodes = " + length);
         }
         Element e = (Element) children.item(0);
         if (!e.getNodeName().equals(name)) {
             throw new IllegalArgumentException("Not a  " + name +
                     " node \"" + e.getNodeName() + "\"");
         }
         return e;
     }

     // Constructs one ServiceTag instance from a service tag element root
     private static ServiceTag getServiceTag(Element svcTagElement) {
         return new ServiceTag(
             getTextValue(svcTagElement, ST_NODE_INSTANCE_URN),
             getTextValue(svcTagElement, ST_NODE_PRODUCT_NAME),
             getTextValue(svcTagElement, ST_NODE_PRODUCT_VERSION),
             getTextValue(svcTagElement, ST_NODE_PRODUCT_URN),
             getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT),
             getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT_URN),
             getTextValue(svcTagElement, ST_NODE_PRODUCT_DEFINED_INST_ID),
             getTextValue(svcTagElement, ST_NODE_PRODUCT_VENDOR),
             getTextValue(svcTagElement, ST_NODE_PLATFORM_ARCH),
             getTextValue(svcTagElement, ST_NODE_CONTAINER),
             getTextValue(svcTagElement, ST_NODE_SOURCE),
             Util.getIntValue(getTextValue(svcTagElement, ST_NODE_INSTALLER_UID)),
             Util.parseTimestamp(getTextValue(svcTagElement, ST_NODE_TIMESTAMP))
         );
     }

     private static String getTextValue(Element e, String tagName) {
         String value = "";
         NodeList nl = e.getElementsByTagName(tagName);
         if (nl != null && nl.getLength() > 0) {
             Element el = (Element) nl.item(0);
             Node node = el.getFirstChild();
             if (node != null) {
                 value = node.getNodeValue();
             }
         }
         return value;
     }
 }
	/*
	* Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.servicetag;

	import java.io.*;
	import java.net.URL;
	import java.util.Collection;
	import java.util.Map;
	import java.util.Set;

	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;
	import org.xml.sax.InputSource;

	import javax.xml.XMLConstants;
	import javax.xml.parsers.DocumentBuilder;
	import javax.xml.parsers.DocumentBuilderFactory;

	import javax.xml.parsers.ParserConfigurationException;
	import javax.xml.validation.Schema;
	import javax.xml.validation.SchemaFactory;
	import javax.xml.validation.Validator;

	// For write operation
	import javax.xml.transform.OutputKeys;
	import javax.xml.transform.Transformer;
	import javax.xml.transform.TransformerException;
	import javax.xml.transform.TransformerFactory;
	import javax.xml.transform.TransformerConfigurationException;
	import javax.xml.transform.dom.DOMSource;
	import javax.xml.transform.stream.StreamResult;

	/**
	* XML Support Class for Product Registration.
	*/
	class RegistrationDocument {

	private static final String REGISTRATION_DATA_SCHEMA =
	"/com/sun/servicetag/resources/product_registration.xsd";
	private static final String REGISTRATION_DATA_VERSION = "1.0";
	private static final String SERVICE_TAG_VERSION = "1.0";
	final static String ST_NODE_REGISTRATION_DATA = "registration_data";
	final static String ST_ATTR_REGISTRATION_VERSION = "version";
	final static String ST_NODE_ENVIRONMENT = "environment";
	final static String ST_NODE_HOSTNAME = "hostname";
	final static String ST_NODE_HOST_ID = "hostId";
	final static String ST_NODE_OS_NAME = "osName";
	final static String ST_NODE_OS_VERSION = "osVersion";
	final static String ST_NODE_OS_ARCH = "osArchitecture";
	final static String ST_NODE_SYSTEM_MODEL = "systemModel";
	final static String ST_NODE_SYSTEM_MANUFACTURER = "systemManufacturer";
	final static String ST_NODE_CPU_MANUFACTURER = "cpuManufacturer";
	final static String ST_NODE_SERIAL_NUMBER = "serialNumber";
	final static String ST_NODE_REGISTRY = "registry";
	final static String ST_ATTR_REGISTRY_URN = "urn";
	final static String ST_ATTR_REGISTRY_VERSION = "version";
	final static String ST_NODE_SERVICE_TAG = "service_tag";
	final static String ST_NODE_INSTANCE_URN = "instance_urn";
	final static String ST_NODE_PRODUCT_NAME = "product_name";
	final static String ST_NODE_PRODUCT_VERSION = "product_version";
	final static String ST_NODE_PRODUCT_URN = "product_urn";
	final static String ST_NODE_PRODUCT_PARENT_URN = "product_parent_urn";
	final static String ST_NODE_PRODUCT_PARENT = "product_parent";
	final static String ST_NODE_PRODUCT_DEFINED_INST_ID = "product_defined_inst_id";
	final static String ST_NODE_PRODUCT_VENDOR = "product_vendor";
	final static String ST_NODE_PLATFORM_ARCH = "platform_arch";
	final static String ST_NODE_TIMESTAMP = "timestamp";
	final static String ST_NODE_CONTAINER = "container";
	final static String ST_NODE_SOURCE = "source";
	final static String ST_NODE_INSTALLER_UID = "installer_uid";

	static RegistrationData load(InputStream in) throws IOException {
	Document document = initializeDocument(in);

	// Gets the registration URN
	Element root = getRegistrationDataRoot(document);
	Element registryRoot =
	getSingletonElementFromRoot(root, ST_NODE_REGISTRY);
	String urn = registryRoot.getAttribute(ST_ATTR_REGISTRY_URN);

	// Construct a new RegistrationData object from the DOM tree
	// Initialize the environment map and service tags
	RegistrationData regData = new RegistrationData(urn);
	addServiceTags(registryRoot, regData);

	Element envRoot = getSingletonElementFromRoot(root, ST_NODE_ENVIRONMENT);
	buildEnvironmentMap(envRoot, regData);
	return regData;
	}

	static void store(OutputStream os, RegistrationData registration)
	throws IOException {
	// create a new document with the root node
	Document document = initializeDocument();

	// create the nodes for the environment map and the service tags
	// in the registration data
	addEnvironmentNodes(document,
	registration.getEnvironmentMap());
	addServiceTagRegistry(document,
	registration.getRegistrationURN(),
	registration.getServiceTags());
	transform(document, os);
	}

	// initialize a document from an input stream
	private static Document initializeDocument(InputStream in) throws IOException {
	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
	try {
	// XML schema for validation
	SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
	URL xsdUrl = RegistrationDocument.class.getResource(REGISTRATION_DATA_SCHEMA);
	Schema schema = sf.newSchema(xsdUrl);
	Validator validator = schema.newValidator();

	DocumentBuilder builder = factory.newDocumentBuilder();
	Document doc = builder.parse(new InputSource(in));
	validator.validate(new DOMSource(doc));
	return doc;
	} catch (SAXException sxe) {
	IllegalArgumentException e = new IllegalArgumentException("Error generated in parsing");
	e.initCause(sxe);
	throw e;
	} catch (ParserConfigurationException pce) {
	// Parser with specific options can't be built
	// should not reach here
	InternalError x = new InternalError("Error in creating the new document");
	x.initCause(pce);
	throw x;
	}
	}

	// initialize a new document for the registration data
	private static Document initializeDocument() throws IOException {
	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
	try {
	DocumentBuilder builder = factory.newDocumentBuilder();
	Document doc = builder.newDocument();

	// initialize the document with the registration_data root
	Element root = doc.createElement(ST_NODE_REGISTRATION_DATA);
	doc.appendChild(root);
	root.setAttribute(ST_ATTR_REGISTRATION_VERSION, REGISTRATION_DATA_VERSION);

	return doc;
	} catch (ParserConfigurationException pce) {
	// Parser with specified options can't be built
	// should not reach here
	InternalError x = new InternalError("Error in creating the new document");
	x.initCause(pce);
	throw x;
	}
	}

	// Transform the current DOM tree with the given output stream.
	private static void transform(Document document, OutputStream os) {
	try {
	// Use a Transformer for output
	TransformerFactory tFactory = TransformerFactory.newInstance();
	tFactory.setAttribute("indent-number", new Integer(3));

	Transformer transformer = tFactory.newTransformer();

	transformer.setOutputProperty(OutputKeys.INDENT, "yes");
	transformer.setOutputProperty(OutputKeys.METHOD, "xml");
	transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
	transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
	transformer.transform(new DOMSource(document),
	new StreamResult(new BufferedWriter(new OutputStreamWriter(os, "UTF-8"))));
	} catch (UnsupportedEncodingException ue) {
	// Should not reach here
	InternalError x = new InternalError("Error generated during transformation");
	x.initCause(ue);
	throw x;
	} catch (TransformerConfigurationException tce) {
	// Error generated by the parser
	// Should not reach here
	InternalError x = new InternalError("Error in creating the new document");
	x.initCause(tce);
	throw x;
	} catch (TransformerException te) {
	// Error generated by the transformer
	InternalError x = new InternalError("Error generated during transformation");
	x.initCause(te);
	throw x;
	}
	}

	private static void addServiceTagRegistry(Document document,
	String registryURN,
	Set<ServiceTag> svcTags) {
	// add service tag registry node and its attributes
	Element reg = document.createElement(ST_NODE_REGISTRY);
	reg.setAttribute(ST_ATTR_REGISTRY_URN, registryURN);
	reg.setAttribute(ST_ATTR_REGISTRY_VERSION, SERVICE_TAG_VERSION);

	Element root = getRegistrationDataRoot(document);
	root.appendChild(reg);

	// adds the elements for the service tags
	for (ServiceTag st : svcTags) {
	addServiceTagElement(document, reg, st);
	}
	}

	private static void addServiceTagElement(Document document,
	Element registryRoot,
	ServiceTag st) {
	Element svcTag = document.createElement(ST_NODE_SERVICE_TAG);
	registryRoot.appendChild(svcTag);
	addChildElement(document, svcTag,
	ST_NODE_INSTANCE_URN, st.getInstanceURN());
	addChildElement(document, svcTag,
	ST_NODE_PRODUCT_NAME, st.getProductName());
	addChildElement(document, svcTag,
	ST_NODE_PRODUCT_VERSION, st.getProductVersion());
	addChildElement(document, svcTag,
	ST_NODE_PRODUCT_URN, st.getProductURN());
	addChildElement(document, svcTag,
	ST_NODE_PRODUCT_PARENT_URN, st.getProductParentURN());
	addChildElement(document, svcTag,
	ST_NODE_PRODUCT_PARENT, st.getProductParent());
	addChildElement(document, svcTag,
	ST_NODE_PRODUCT_DEFINED_INST_ID,
	st.getProductDefinedInstanceID());
	addChildElement(document, svcTag,
	ST_NODE_PRODUCT_VENDOR, st.getProductVendor());
	addChildElement(document, svcTag,
	ST_NODE_PLATFORM_ARCH, st.getPlatformArch());
	addChildElement(document, svcTag,
	ST_NODE_TIMESTAMP, Util.formatTimestamp(st.getTimestamp()));
	addChildElement(document, svcTag,
	ST_NODE_CONTAINER, st.getContainer());
	addChildElement(document, svcTag,
	ST_NODE_SOURCE, st.getSource());
	addChildElement(document, svcTag,
	ST_NODE_INSTALLER_UID,
	String.valueOf(st.getInstallerUID()));
	}

	private static void addChildElement(Document document, Element root,
	String element, String text) {
	Element node = document.createElement(element);
	node.appendChild(document.createTextNode(text));
	root.appendChild(node);
	}

	// Constructs service tags from the document
	private static void addServiceTags(Element registryRoot,
	RegistrationData registration) {
	NodeList children = registryRoot.getElementsByTagName(ST_NODE_SERVICE_TAG);
	int length = (children == null ? 0 : children.getLength());
	for (int i = 0; i < length; i++) {
	Element svcTagElement = (Element) children.item(i);
	ServiceTag st = getServiceTag(svcTagElement);
	registration.addServiceTag(st);
	}
	}

	// build environment map from the document
	private static void buildEnvironmentMap(Element envRoot,
	RegistrationData registration) {
	registration.setEnvironment(ST_NODE_HOSTNAME, getTextValue(envRoot, ST_NODE_HOSTNAME));
	registration.setEnvironment(ST_NODE_HOST_ID, getTextValue(envRoot, ST_NODE_HOST_ID));
	registration.setEnvironment(ST_NODE_OS_NAME, getTextValue(envRoot, ST_NODE_OS_NAME));
	registration.setEnvironment(ST_NODE_OS_VERSION, getTextValue(envRoot, ST_NODE_OS_VERSION));
	registration.setEnvironment(ST_NODE_OS_ARCH, getTextValue(envRoot, ST_NODE_OS_ARCH));
	registration.setEnvironment(ST_NODE_SYSTEM_MODEL, getTextValue(envRoot, ST_NODE_SYSTEM_MODEL));
	registration.setEnvironment(ST_NODE_SYSTEM_MANUFACTURER, getTextValue(envRoot, ST_NODE_SYSTEM_MANUFACTURER));
	registration.setEnvironment(ST_NODE_CPU_MANUFACTURER, getTextValue(envRoot, ST_NODE_CPU_MANUFACTURER));
	registration.setEnvironment(ST_NODE_SERIAL_NUMBER, getTextValue(envRoot, ST_NODE_SERIAL_NUMBER));
	}

	// add the nodes representing the environment map in the document
	private static void addEnvironmentNodes(Document document,
	Map<String, String> envMap) {
	Element root = getRegistrationDataRoot(document);
	Element env = document.createElement(ST_NODE_ENVIRONMENT);
	root.appendChild(env);
	Set<Map.Entry<String, String>> keys = envMap.entrySet();
	for (Map.Entry<String, String> entry : keys) {
	addChildElement(document, env, entry.getKey(), entry.getValue());
	}
	}

	private static Element getRegistrationDataRoot(Document doc) {
	Element root = doc.getDocumentElement();
	if (!root.getNodeName().equals(ST_NODE_REGISTRATION_DATA)) {
	throw new IllegalArgumentException("Not a " +
	ST_NODE_REGISTRATION_DATA +
	" node \"" + root.getNodeName() + "\"");
	}
	return root;
	}

	private static Element getSingletonElementFromRoot(Element root, String name) {
	NodeList children = root.getElementsByTagName(name);
	int length = (children == null ? 0 : children.getLength());
	if (length != 1) {
	throw new IllegalArgumentException("Invalid number of " + name +
	" nodes = " + length);
	}
	Element e = (Element) children.item(0);
	if (!e.getNodeName().equals(name)) {
	throw new IllegalArgumentException("Not a " + name +
	" node \"" + e.getNodeName() + "\"");
	}
	return e;
	}

	// Constructs one ServiceTag instance from a service tag element root
	private static ServiceTag getServiceTag(Element svcTagElement) {
	return new ServiceTag(
	getTextValue(svcTagElement, ST_NODE_INSTANCE_URN),
	getTextValue(svcTagElement, ST_NODE_PRODUCT_NAME),
	getTextValue(svcTagElement, ST_NODE_PRODUCT_VERSION),
	getTextValue(svcTagElement, ST_NODE_PRODUCT_URN),
	getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT),
	getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT_URN),
	getTextValue(svcTagElement, ST_NODE_PRODUCT_DEFINED_INST_ID),
	getTextValue(svcTagElement, ST_NODE_PRODUCT_VENDOR),
	getTextValue(svcTagElement, ST_NODE_PLATFORM_ARCH),
	getTextValue(svcTagElement, ST_NODE_CONTAINER),
	getTextValue(svcTagElement, ST_NODE_SOURCE),
	Util.getIntValue(getTextValue(svcTagElement, ST_NODE_INSTALLER_UID)),
	Util.parseTimestamp(getTextValue(svcTagElement, ST_NODE_TIMESTAMP))
	);
	}

	private static String getTextValue(Element e, String tagName) {
	String value = "";
	NodeList nl = e.getElementsByTagName(tagName);
	if (nl != null && nl.getLength() > 0) {
	Element el = (Element) nl.item(0);
	Node node = el.getFirstChild();
	if (node != null) {
	value = node.getNodeValue();
	}
	}
	return value;
	}
	}