opendaylight/blueprint/src/main/java/org/opendaylight/controller/blueprint/ext/DataStoreAppConfigDefaultXMLReader.java

   1 /*
   2  * Copyright (c) 2016 Brocade Communications Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.blueprint.ext;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.base.Strings;
  12 import com.google.common.io.Resources;
  13 import java.io.IOException;
  14 import java.io.InputStream;
  15 import java.net.URL;
  16 import org.opendaylight.controller.sal.core.api.model.SchemaService;
  17 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
  18 import org.opendaylight.yangtools.util.xml.UntrustedXML;
  19 import org.opendaylight.yangtools.yang.binding.DataObject;
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  22 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  23 import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlUtils;
  24 import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser.DomToNormalizedNodeParserFactory;
  25 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  26 import org.opendaylight.yangtools.yang.model.api.Module;
  27 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  28 import org.slf4j.Logger;
  29 import org.slf4j.LoggerFactory;
  30 import org.w3c.dom.Document;
  31 import org.xml.sax.SAXException;
  32
  33 /**
  34  * DataObject XML file reader used by {@link DataStoreAppConfigMetadata}.
  35  * Available as a standalone class to make it easy to write unit tests which can
  36  * catch malformed default "clustered-app-conf" config data XML files in
  37  * downstream projects.
  38  *
  39  * @author Thomas Pantelis (originally; re-factored by Michael Vorburger.ch)
  40  */
  41 public class DataStoreAppConfigDefaultXMLReader<T extends DataObject> {
  42
  43     private static final Logger LOG = LoggerFactory.getLogger(DataStoreAppConfigDefaultXMLReader.class);
  44
  45     private final String logName;
  46     private final String defaultAppConfigFileName;
  47     private final SchemaService schemaService;
  48     private final BindingNormalizedNodeSerializer bindingSerializer;
  49     private final BindingContext bindingContext;
  50     private final ConfigURLProvider inputStreamProvider;
  51
  52     @FunctionalInterface
  53     public interface FallbackConfigProvider {
  54         NormalizedNode<?,?> get(SchemaContext schemaContext, DataSchemaNode dataSchema);
  55     }
  56
  57     @FunctionalInterface
  58     public interface ConfigURLProvider {
  59         Optional<URL> getURL(String appConfigFileName) throws IOException;
  60     }
  61
  62     public DataStoreAppConfigDefaultXMLReader(
  63             final String logName,
  64             final String defaultAppConfigFileName,
  65             final SchemaService schemaService,
  66             final BindingNormalizedNodeSerializer bindingSerializer,
  67             final BindingContext bindingContext,
  68             final ConfigURLProvider inputStreamProvider) {
  69
  70         this.logName = logName;
  71         this.defaultAppConfigFileName = defaultAppConfigFileName;
  72         this.schemaService = schemaService;
  73         this.bindingSerializer = bindingSerializer;
  74         this.bindingContext = bindingContext;
  75         this.inputStreamProvider = inputStreamProvider;
  76     }
  77
  78     public DataStoreAppConfigDefaultXMLReader(
  79             final Class<?> testClass,
  80             final String defaultAppConfigFileName,
  81             final SchemaService schemaService,
  82             final BindingNormalizedNodeSerializer bindingSerializer,
  83             final Class<T> klass) {
  84         this(testClass.getName(), defaultAppConfigFileName, schemaService, bindingSerializer,
  85             BindingContext.create(testClass.getName(), klass, null),
  86             appConfigFileName -> Optional.of(getURL(testClass, defaultAppConfigFileName)));
  87     }
  88
  89     private static URL getURL(final Class<?> testClass, final String defaultAppConfigFileName) {
  90         return Resources.getResource(testClass, defaultAppConfigFileName);
  91     }
  92
  93     public T createDefaultInstance() throws ConfigXMLReaderException {
  94         return createDefaultInstance((schemaContext, dataSchema) -> {
  95             throw new IllegalArgumentException("Failed to read XML "
  96                     + "(not creating model from defaults as runtime would, for better clarity in tests)");
  97         });
  98     }
  99
 100     @SuppressWarnings("unchecked")
 101     public T createDefaultInstance(final FallbackConfigProvider fallback) throws ConfigXMLReaderException {
 102         YangInstanceIdentifier yangPath = bindingSerializer.toYangInstanceIdentifier(bindingContext.appConfigPath);
 103
 104         LOG.debug("{}: Creating app config instance from path {}, Qname: {}", logName, yangPath,
 105                 bindingContext.bindingQName);
 106
 107         if (schemaService == null) {
 108             throw new ConfigXMLReaderException(
 109                     String.format("%s: Could not obtain the SchemaService OSGi service", logName));
 110         }
 111
 112         SchemaContext schemaContext = schemaService.getGlobalContext();
 113
 114         Module module = schemaContext.findModuleByNamespaceAndRevision(bindingContext.bindingQName.getNamespace(),
 115                 bindingContext.bindingQName.getRevision());
 116         if (module == null) {
 117             throw new ConfigXMLReaderException(
 118                     String.format("%s: Could not obtain the module schema for namespace %s, revision %s",
 119                     logName, bindingContext.bindingQName.getNamespace(), bindingContext.bindingQName.getRevision()));
 120         }
 121
 122         DataSchemaNode dataSchema = module.getDataChildByName(bindingContext.bindingQName);
 123         if (dataSchema == null) {
 124             throw new ConfigXMLReaderException(
 125                     String.format("%s: Could not obtain the schema for %s", logName,
 126                     bindingContext.bindingQName));
 127         }
 128
 129         if (!bindingContext.schemaType.isAssignableFrom(dataSchema.getClass())) {
 130             throw new ConfigXMLReaderException(
 131                     String.format("%s: Expected schema type %s for %s but actual type is %s", logName,
 132                     bindingContext.schemaType, bindingContext.bindingQName, dataSchema.getClass()));
 133         }
 134
 135         NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigXMLFile(schemaContext, dataSchema);
 136         if (dataNode == null) {
 137             dataNode = fallback.get(schemaService.getGlobalContext(), dataSchema);
 138         }
 139
 140         DataObject appConfig = bindingSerializer.fromNormalizedNode(yangPath, dataNode).getValue();
 141         if (appConfig == null) {
 142             // This shouldn't happen but need to handle it in case...
 143             throw new ConfigXMLReaderException(
 144                     String.format("%s: Could not create instance for app config binding %s",
 145                     logName, bindingContext.appConfigBindingClass));
 146         } else {
 147             return (T) appConfig;
 148         }
 149     }
 150
 151     private NormalizedNode<?, ?> parsePossibleDefaultAppConfigXMLFile(final SchemaContext schemaContext,
 152             final DataSchemaNode dataSchema) throws ConfigXMLReaderException {
 153
 154         String appConfigFileName = defaultAppConfigFileName;
 155         if (Strings.isNullOrEmpty(appConfigFileName)) {
 156             String moduleName = findYangModuleName(bindingContext.bindingQName, schemaContext);
 157             appConfigFileName = moduleName + "_" + bindingContext.bindingQName.getLocalName() + ".xml";
 158         }
 159
 160         final DomToNormalizedNodeParserFactory parserFactory = DomToNormalizedNodeParserFactory.getInstance(
 161                 XmlUtils.DEFAULT_XML_CODEC_PROVIDER, schemaContext);
 162
 163         Optional<URL> optionalURL;
 164         try {
 165             optionalURL = inputStreamProvider.getURL(appConfigFileName);
 166         } catch (final IOException e) {
 167             String msg = String.format("%s: Could not getURL()", logName);
 168             LOG.error(msg, e);
 169             throw new ConfigXMLReaderException(msg, e);
 170         }
 171         if (!optionalURL.isPresent()) {
 172             return null;
 173         }
 174         URL url = optionalURL.get();
 175         try (InputStream is = url.openStream()) {
 176             Document root = UntrustedXML.newDocumentBuilder().parse(is);
 177             NormalizedNode<?, ?> dataNode = bindingContext.parseDataElement(root.getDocumentElement(), dataSchema,
 178                     parserFactory);
 179
 180             LOG.debug("{}: Parsed data node: {}", logName, dataNode);
 181
 182             return dataNode;
 183         } catch (SAXException | IOException e) {
 184             String msg = String.format("%s: Could not read/parse app config %s", logName, url);
 185             LOG.error(msg, e);
 186             throw new ConfigXMLReaderException(msg, e);
 187         }
 188     }
 189
 190     private String findYangModuleName(final QName qname, final SchemaContext schemaContext)
 191             throws ConfigXMLReaderException {
 192         for (Module m : schemaContext.getModules()) {
 193             if (qname.getModule().equals(m.getQNameModule())) {
 194                 return m.getName();
 195             }
 196         }
 197         throw new ConfigXMLReaderException(
 198                 String.format("%s: Could not find yang module for QName %s", logName, qname));
 199     }
 200
 201 }