import java.io.ByteArrayOutputStream;
import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
-import java.util.Date;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.ParserConfigurationException;
+import java.time.Instant;
+import java.time.OffsetDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.restconf.Draft18.MonitoringModule;
+import org.opendaylight.restconf.Rfc8040.MonitoringModule;
import org.opendaylight.restconf.handlers.SchemaContextHandler;
import org.opendaylight.restconf.handlers.TransactionChainHandler;
import org.opendaylight.restconf.parser.IdentifierCodec;
+import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.w3c.dom.Element;
/**
- * Abstract class for processing and preparing data
+ * Abstract class for processing and preparing data.
*
*/
abstract class AbstractNotificationsData {
-
private static final Logger LOG = LoggerFactory.getLogger(AbstractNotificationsData.class);
+ private static final TransformerFactory TF = TransformerFactory.newInstance();
private TransactionChainHandler transactionChainHandler;
private SchemaContextHandler schemaHandler;
private String localName;
/**
- * Transaction chain for delete data in DS on close()
+ * Transaction chain for delete data in DS on close().
*
* @param transactionChainHandler
- * - creating new write transaction for delete data on close
+ * creating new write transaction for delete data on close
* @param schemaHandler
- * - for getting schema to deserialize
+ * for getting schema to deserialize
* {@link MonitoringModule#PATH_TO_STREAM_WITHOUT_KEY} to
* {@link YangInstanceIdentifier}
*/
}
/**
- * Delete data in DS
+ * Delete data in DS.
*/
protected void deleteDataInDS() throws Exception {
final DOMDataWriteTransaction wTx = this.transactionChainHandler.get().newWriteOnlyTransaction();
}
/**
- * Set localName of last path element of specific listener
+ * Set localName of last path element of specific listener.
*
* @param localName
- * - local name
+ * local name
*/
protected void setLocalNameOfPath(final String localName) {
this.localName = localName;
/**
* Formats data specified by RFC3339.
*
- * @param d
- * Date
+ * @param now time stamp
* @return Data specified by RFC3339.
*/
- protected static String toRFC3339(final Date d) {
- return ListenersConstants.RFC3339_PATTERN.matcher(ListenersConstants.RFC3339.format(d)).replaceAll("$1:$2");
+ protected static String toRFC3339(final Instant now) {
+ return DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(OffsetDateTime.ofInstant(now, ZoneId.systemDefault()));
}
/**
* @return {@link Document} document.
*/
protected static Document createDocument() {
- final DocumentBuilder bob;
- try {
- bob = ListenersConstants.DBF.newDocumentBuilder();
- } catch (final ParserConfigurationException e) {
- return null;
- }
- return bob.newDocument();
+ return UntrustedXML.newDocumentBuilder().newDocument();
}
/**
- * Write normalized node to {@link DOMResult}
+ * Write normalized node to {@link DOMResult}.
*
* @param normalized
- * - data
+ * data
* @param context
- * - actual schema context
+ * actual schema context
* @param schemaPath
- * - schema path of data
+ * schema path of data
* @return {@link DOMResult}
*/
protected DOMResult writeNormalizedNode(final NormalizedNode<?, ?> normalized, final SchemaContext context,
final SchemaPath schemaPath) throws IOException, XMLStreamException {
- final XMLOutputFactory XML_FACTORY = XMLOutputFactory.newFactory();
+ final XMLOutputFactory xmlFactory = XMLOutputFactory.newFactory();
final Document doc = XmlDocumentUtils.getDocument();
final DOMResult result = new DOMResult(doc);
NormalizedNodeWriter normalizedNodeWriter = null;
XMLStreamWriter writer = null;
try {
- writer = XML_FACTORY.createXMLStreamWriter(result);
+ writer = xmlFactory.createXMLStreamWriter(result);
normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, context, schemaPath);
normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter);
}
/**
- * Generating base element of every notification
+ * Generating base element of every notification.
*
* @param doc
- * - base {@link Document}
+ * base {@link Document}
* @return element of {@link Document}
*/
protected Element basePartDoc(final Document doc) {
doc.appendChild(notificationElement);
final Element eventTimeElement = doc.createElement("eventTime");
- eventTimeElement.setTextContent(toRFC3339(new Date()));
+ eventTimeElement.setTextContent(toRFC3339(Instant.now()));
notificationElement.appendChild(eventTimeElement);
return notificationElement;
}
/**
- * Generating of {@link Document} transforming to string
+ * Generating of {@link Document} transforming to string.
*
* @param doc
- * - {@link Document} with data
+ * {@link Document} with data
* @return - string from {@link Document}
*/
protected String transformDoc(final Document doc) {
+ final ByteArrayOutputStream out = new ByteArrayOutputStream();
+
try {
- final ByteArrayOutputStream out = new ByteArrayOutputStream();
- final Transformer transformer = ListenersConstants.FACTORY.newTransformer();
+ final Transformer transformer = TF.newTransformer();
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
- transformer.transform(new DOMSource(doc),
- new StreamResult(new OutputStreamWriter(out, StandardCharsets.UTF_8)));
- final byte[] charData = out.toByteArray();
- return new String(charData, "UTF-8");
- } catch (TransformerException | UnsupportedEncodingException e) {
+ transformer.transform(new DOMSource(doc), new StreamResult(out));
+ } catch (TransformerException e) {
+ // FIXME: this should raise an exception
final String msg = "Error during transformation of Document into String";
LOG.error(msg, e);
return msg;
}
+
+ return new String(out.toByteArray(), StandardCharsets.UTF_8);
}
}