1 /*
   2  * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.servicetag;
  27 
  28 import java.io.*;
  29 import java.net.URL;
  30 import java.util.Collection;
  31 import java.util.Map;
  32 import java.util.Set;
  33 
  34 import org.w3c.dom.Document;
  35 import org.w3c.dom.Element;
  36 import org.w3c.dom.Node;
  37 import org.w3c.dom.NodeList;
  38 import org.xml.sax.SAXException;
  39 import org.xml.sax.InputSource;
  40 
  41 import javax.xml.XMLConstants;
  42 import javax.xml.parsers.DocumentBuilder;
  43 import javax.xml.parsers.DocumentBuilderFactory;
  44 
  45 import javax.xml.parsers.ParserConfigurationException;
  46 import javax.xml.validation.Schema;
  47 import javax.xml.validation.SchemaFactory;
  48 import javax.xml.validation.Validator;
  49 
  50 // For write operation
  51 import javax.xml.transform.OutputKeys;
  52 import javax.xml.transform.Transformer;
  53 import javax.xml.transform.TransformerException;
  54 import javax.xml.transform.TransformerFactory;
  55 import javax.xml.transform.TransformerConfigurationException;
  56 import javax.xml.transform.dom.DOMSource;
  57 import javax.xml.transform.stream.StreamResult;
  58 
  59 /**
  60  * XML Support Class for Product Registration.
  61  */
  62 class RegistrationDocument {
  63 
  64     private static final String REGISTRATION_DATA_SCHEMA =
  65             "/com/sun/servicetag/resources/product_registration.xsd";
  66     private static final String REGISTRATION_DATA_VERSION = "1.0";
  67     private static final String SERVICE_TAG_VERSION = "1.0";
  68     final static String ST_NODE_REGISTRATION_DATA = "registration_data";
  69     final static String ST_ATTR_REGISTRATION_VERSION = "version";
  70     final static String ST_NODE_ENVIRONMENT = "environment";
  71     final static String ST_NODE_HOSTNAME = "hostname";
  72     final static String ST_NODE_HOST_ID = "hostId";
  73     final static String ST_NODE_OS_NAME = "osName";
  74     final static String ST_NODE_OS_VERSION = "osVersion";
  75     final static String ST_NODE_OS_ARCH = "osArchitecture";
  76     final static String ST_NODE_SYSTEM_MODEL = "systemModel";
  77     final static String ST_NODE_SYSTEM_MANUFACTURER = "systemManufacturer";
  78     final static String ST_NODE_CPU_MANUFACTURER = "cpuManufacturer";
  79     final static String ST_NODE_SERIAL_NUMBER = "serialNumber";
  80     final static String ST_NODE_REGISTRY = "registry";
  81     final static String ST_ATTR_REGISTRY_URN = "urn";
  82     final static String ST_ATTR_REGISTRY_VERSION = "version";
  83     final static String ST_NODE_SERVICE_TAG = "service_tag";
  84     final static String ST_NODE_INSTANCE_URN = "instance_urn";
  85     final static String ST_NODE_PRODUCT_NAME = "product_name";
  86     final static String ST_NODE_PRODUCT_VERSION = "product_version";
  87     final static String ST_NODE_PRODUCT_URN = "product_urn";
  88     final static String ST_NODE_PRODUCT_PARENT_URN = "product_parent_urn";
  89     final static String ST_NODE_PRODUCT_PARENT = "product_parent";
  90     final static String ST_NODE_PRODUCT_DEFINED_INST_ID = "product_defined_inst_id";
  91     final static String ST_NODE_PRODUCT_VENDOR = "product_vendor";
  92     final static String ST_NODE_PLATFORM_ARCH = "platform_arch";
  93     final static String ST_NODE_TIMESTAMP = "timestamp";
  94     final static String ST_NODE_CONTAINER = "container";
  95     final static String ST_NODE_SOURCE = "source";
  96     final static String ST_NODE_INSTALLER_UID = "installer_uid";
  97 
  98     static RegistrationData load(InputStream in) throws IOException {
  99         Document document = initializeDocument(in);
 100 
 101         // Gets the registration URN
 102         Element root = getRegistrationDataRoot(document);
 103         Element registryRoot =
 104                 getSingletonElementFromRoot(root, ST_NODE_REGISTRY);
 105         String urn = registryRoot.getAttribute(ST_ATTR_REGISTRY_URN);
 106 
 107         // Construct a new RegistrationData object from the DOM tree
 108         // Initialize the environment map and service tags
 109         RegistrationData regData = new RegistrationData(urn);
 110         addServiceTags(registryRoot, regData);
 111 
 112         Element envRoot = getSingletonElementFromRoot(root, ST_NODE_ENVIRONMENT);
 113         buildEnvironmentMap(envRoot, regData);
 114         return regData;
 115     }
 116 
 117     static void store(OutputStream os, RegistrationData registration)
 118             throws IOException {
 119         // create a new document with the root node
 120         Document document = initializeDocument();
 121 
 122         // create the nodes for the environment map and the service tags
 123         // in the registration data
 124         addEnvironmentNodes(document,
 125                             registration.getEnvironmentMap());
 126         addServiceTagRegistry(document,
 127                               registration.getRegistrationURN(),
 128                               registration.getServiceTags());
 129         transform(document, os);
 130     }
 131 
 132     // initialize a document from an input stream
 133     private static Document initializeDocument(InputStream in) throws IOException {
 134         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 135         try {
 136             // XML schema for validation
 137             SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
 138             URL xsdUrl = RegistrationDocument.class.getResource(REGISTRATION_DATA_SCHEMA);
 139             Schema schema = sf.newSchema(xsdUrl);
 140             Validator validator = schema.newValidator();
 141 
 142             DocumentBuilder builder = factory.newDocumentBuilder();
 143             Document doc = builder.parse(new InputSource(in));
 144             validator.validate(new DOMSource(doc));
 145             return doc;
 146         } catch (SAXException sxe) {
 147             IllegalArgumentException e = new IllegalArgumentException("Error generated in parsing");
 148             e.initCause(sxe);
 149             throw e;
 150         } catch (ParserConfigurationException pce) {
 151             // Parser with specific options can't be built
 152             // should not reach here
 153             throw new InternalError("Error in creating the new document", pce);
 154         }
 155     }
 156 
 157     // initialize a new document for the registration data
 158     private static Document initializeDocument() throws IOException {
 159         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 160         try {
 161             DocumentBuilder builder = factory.newDocumentBuilder();
 162             Document doc = builder.newDocument();
 163 
 164             // initialize the document with the registration_data root
 165             Element root = doc.createElement(ST_NODE_REGISTRATION_DATA);
 166             doc.appendChild(root);
 167             root.setAttribute(ST_ATTR_REGISTRATION_VERSION, REGISTRATION_DATA_VERSION);
 168 
 169             return doc;
 170         } catch (ParserConfigurationException pce) {
 171             // Parser with specified options can't be built
 172             // should not reach here
 173             throw new InternalError("Error in creating the new document", pce);
 174         }
 175     }
 176 
 177     // Transform the current DOM tree with the given output stream.
 178     private static void transform(Document document, OutputStream os) {
 179         try {
 180             // Use a Transformer for output
 181             TransformerFactory tFactory = TransformerFactory.newInstance();
 182             tFactory.setAttribute("indent-number", new Integer(3));
 183 
 184             Transformer transformer = tFactory.newTransformer();
 185 
 186             transformer.setOutputProperty(OutputKeys.INDENT, "yes");
 187             transformer.setOutputProperty(OutputKeys.METHOD, "xml");
 188             transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
 189             transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");
 190             transformer.transform(new DOMSource(document),
 191                 new StreamResult(new BufferedWriter(new OutputStreamWriter(os, "UTF-8"))));
 192         } catch (UnsupportedEncodingException ue) {
 193             // Should not reach here
 194             throw new InternalError("Error generated during transformation", ue);
 195         } catch (TransformerConfigurationException tce) {
 196             // Error generated by the parser
 197             // Should not reach here
 198             throw new InternalError("Error in creating the new document", tce);
 199         } catch (TransformerException te) {
 200             // Error generated by the transformer
 201             throw new InternalError("Error generated during transformation", te);
 202         }
 203     }
 204 
 205     private static void addServiceTagRegistry(Document document,
 206                                               String registryURN,
 207                                               Set<ServiceTag> svcTags) {
 208         // add service tag registry node and its attributes
 209         Element reg = document.createElement(ST_NODE_REGISTRY);
 210         reg.setAttribute(ST_ATTR_REGISTRY_URN, registryURN);
 211         reg.setAttribute(ST_ATTR_REGISTRY_VERSION, SERVICE_TAG_VERSION);
 212 
 213         Element root = getRegistrationDataRoot(document);
 214         root.appendChild(reg);
 215 
 216         // adds the elements for the service tags
 217         for (ServiceTag st : svcTags) {
 218             addServiceTagElement(document, reg, st);
 219         }
 220     }
 221 
 222     private static void addServiceTagElement(Document document,
 223                                              Element registryRoot,
 224                                              ServiceTag st) {
 225         Element svcTag = document.createElement(ST_NODE_SERVICE_TAG);
 226         registryRoot.appendChild(svcTag);
 227         addChildElement(document, svcTag,
 228                         ST_NODE_INSTANCE_URN, st.getInstanceURN());
 229         addChildElement(document, svcTag,
 230                         ST_NODE_PRODUCT_NAME, st.getProductName());
 231         addChildElement(document, svcTag,
 232                         ST_NODE_PRODUCT_VERSION, st.getProductVersion());
 233         addChildElement(document, svcTag,
 234                         ST_NODE_PRODUCT_URN, st.getProductURN());
 235         addChildElement(document, svcTag,
 236                         ST_NODE_PRODUCT_PARENT_URN, st.getProductParentURN());
 237         addChildElement(document, svcTag,
 238                         ST_NODE_PRODUCT_PARENT, st.getProductParent());
 239         addChildElement(document, svcTag,
 240                         ST_NODE_PRODUCT_DEFINED_INST_ID,
 241                         st.getProductDefinedInstanceID());
 242         addChildElement(document, svcTag,
 243                         ST_NODE_PRODUCT_VENDOR, st.getProductVendor());
 244         addChildElement(document, svcTag,
 245                         ST_NODE_PLATFORM_ARCH, st.getPlatformArch());
 246         addChildElement(document, svcTag,
 247                         ST_NODE_TIMESTAMP, Util.formatTimestamp(st.getTimestamp()));
 248         addChildElement(document, svcTag,
 249                         ST_NODE_CONTAINER, st.getContainer());
 250         addChildElement(document, svcTag,
 251                         ST_NODE_SOURCE, st.getSource());
 252         addChildElement(document, svcTag,
 253                         ST_NODE_INSTALLER_UID,
 254                         String.valueOf(st.getInstallerUID()));
 255     }
 256 
 257     private static void addChildElement(Document document, Element root,
 258                                         String element, String text) {
 259         Element node = document.createElement(element);
 260         node.appendChild(document.createTextNode(text));
 261         root.appendChild(node);
 262     }
 263 
 264     // Constructs service tags from the document
 265     private static void addServiceTags(Element registryRoot,
 266                                        RegistrationData registration) {
 267         NodeList children = registryRoot.getElementsByTagName(ST_NODE_SERVICE_TAG);
 268         int length = (children == null ? 0 : children.getLength());
 269         for (int i = 0; i < length; i++) {
 270             Element svcTagElement = (Element) children.item(i);
 271             ServiceTag st = getServiceTag(svcTagElement);
 272             registration.addServiceTag(st);
 273         }
 274     }
 275 
 276     // build environment map from the document
 277     private static void buildEnvironmentMap(Element envRoot,
 278                                          RegistrationData registration) {
 279         registration.setEnvironment(ST_NODE_HOSTNAME, getTextValue(envRoot, ST_NODE_HOSTNAME));
 280         registration.setEnvironment(ST_NODE_HOST_ID, getTextValue(envRoot, ST_NODE_HOST_ID));
 281         registration.setEnvironment(ST_NODE_OS_NAME, getTextValue(envRoot, ST_NODE_OS_NAME));
 282         registration.setEnvironment(ST_NODE_OS_VERSION, getTextValue(envRoot, ST_NODE_OS_VERSION));
 283         registration.setEnvironment(ST_NODE_OS_ARCH, getTextValue(envRoot, ST_NODE_OS_ARCH));
 284         registration.setEnvironment(ST_NODE_SYSTEM_MODEL, getTextValue(envRoot, ST_NODE_SYSTEM_MODEL));
 285         registration.setEnvironment(ST_NODE_SYSTEM_MANUFACTURER, getTextValue(envRoot, ST_NODE_SYSTEM_MANUFACTURER));
 286         registration.setEnvironment(ST_NODE_CPU_MANUFACTURER, getTextValue(envRoot, ST_NODE_CPU_MANUFACTURER));
 287         registration.setEnvironment(ST_NODE_SERIAL_NUMBER, getTextValue(envRoot, ST_NODE_SERIAL_NUMBER));
 288     }
 289 
 290     // add the nodes representing the environment map in the document
 291     private static void addEnvironmentNodes(Document document,
 292                                             Map<String, String> envMap) {
 293         Element root = getRegistrationDataRoot(document);
 294         Element env = document.createElement(ST_NODE_ENVIRONMENT);
 295         root.appendChild(env);
 296         Set<Map.Entry<String, String>> keys = envMap.entrySet();
 297         for (Map.Entry<String, String> entry : keys) {
 298             addChildElement(document, env, entry.getKey(), entry.getValue());
 299         }
 300     }
 301 
 302     private static Element getRegistrationDataRoot(Document doc) {
 303         Element root = doc.getDocumentElement();
 304         if (!root.getNodeName().equals(ST_NODE_REGISTRATION_DATA)) {
 305             throw new IllegalArgumentException("Not a " +
 306                     ST_NODE_REGISTRATION_DATA +
 307                     " node \"" + root.getNodeName() + "\"");
 308         }
 309         return root;
 310     }
 311 
 312     private static Element getSingletonElementFromRoot(Element root, String name) {
 313         NodeList children = root.getElementsByTagName(name);
 314         int length = (children == null ? 0 : children.getLength());
 315         if (length != 1) {
 316             throw new IllegalArgumentException("Invalid number of " + name +
 317                     " nodes = " + length);
 318         }
 319         Element e = (Element) children.item(0);
 320         if (!e.getNodeName().equals(name)) {
 321             throw new IllegalArgumentException("Not a  " + name +
 322                     " node \"" + e.getNodeName() + "\"");
 323         }
 324         return e;
 325     }
 326 
 327     // Constructs one ServiceTag instance from a service tag element root
 328     private static ServiceTag getServiceTag(Element svcTagElement) {
 329         return new ServiceTag(
 330             getTextValue(svcTagElement, ST_NODE_INSTANCE_URN),
 331             getTextValue(svcTagElement, ST_NODE_PRODUCT_NAME),
 332             getTextValue(svcTagElement, ST_NODE_PRODUCT_VERSION),
 333             getTextValue(svcTagElement, ST_NODE_PRODUCT_URN),
 334             getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT),
 335             getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT_URN),
 336             getTextValue(svcTagElement, ST_NODE_PRODUCT_DEFINED_INST_ID),
 337             getTextValue(svcTagElement, ST_NODE_PRODUCT_VENDOR),
 338             getTextValue(svcTagElement, ST_NODE_PLATFORM_ARCH),
 339             getTextValue(svcTagElement, ST_NODE_CONTAINER),
 340             getTextValue(svcTagElement, ST_NODE_SOURCE),
 341             Util.getIntValue(getTextValue(svcTagElement, ST_NODE_INSTALLER_UID)),
 342             Util.parseTimestamp(getTextValue(svcTagElement, ST_NODE_TIMESTAMP))
 343         );
 344     }
 345 
 346     private static String getTextValue(Element e, String tagName) {
 347         String value = "";
 348         NodeList nl = e.getElementsByTagName(tagName);
 349         if (nl != null && nl.getLength() > 0) {
 350             Element el = (Element) nl.item(0);
 351             Node node = el.getFirstChild();
 352             if (node != null) {
 353                 value = node.getNodeValue();
 354             }
 355         }
 356         return value;
 357     }
 358 }