*/
package org.opendaylight.controller.blueprint.ext;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.MoreExecutors;
import java.io.File;
-import java.io.FileInputStream;
import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
+import java.net.URISyntaxException;
import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLStreamException;
import org.apache.aries.blueprint.services.ExtendedBlueprintContainer;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.sal.core.api.model.SchemaService;
+import org.opendaylight.controller.blueprint.ext.DataStoreAppConfigDefaultXMLReader.ConfigURLProvider;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlUtils;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser.DomToNormalizedNodeParserFactory;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.osgi.service.blueprint.container.ComponentDefinitionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;
}
appConfigBindingClass = (Class<DataObject>) bindingClass;
- } catch (ClassNotFoundException e) {
+ } catch (final ClassNotFoundException e) {
throw new ComponentDefinitionException(String.format("%s: Error loading app config binding class %s",
logName(), appConfigBindingClassName), e);
}
- if (Identifiable.class.isAssignableFrom(appConfigBindingClass)) {
- // The binding class corresponds to a yang list.
- if (Strings.isNullOrEmpty(appConfigListKeyValue)) {
- throw new ComponentDefinitionException(String.format(
- "%s: App config binding class %s represents a yang list therefore \"%s\" must be specified",
- logName(), appConfigBindingClassName, LIST_KEY_VALUE));
- }
-
- try {
- bindingContext = ListBindingContext.newInstance(appConfigBindingClass, appConfigListKeyValue);
- } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
- | InvocationTargetException | NoSuchMethodException | SecurityException e) {
- throw new ComponentDefinitionException(String.format(
- "%s: Error initializing for app config list binding class %s",
- logName(), appConfigBindingClassName), e);
- }
-
- } else {
- bindingContext = new ContainerBindingContext(appConfigBindingClass);
- }
+ bindingContext = BindingContext.create(logName(), appConfigBindingClass, appConfigListKeyValue);
}
@Override
private void retrieveDataBrokerService() {
LOG.debug("{}: In retrieveDataBrokerService", logName());
-
// Get the binding DataBroker OSGi service.
-
retrieveService("data-broker", DataBroker.class, service -> retrieveInitialAppConfig((DataBroker)service));
}
// the data isn't present, we won't get an initial DTCN update so the read will indicate the data
// isn't present.
- DataTreeIdentifier<DataObject> dataTreeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ DataTreeIdentifier<DataObject> dataTreeId = DataTreeIdentifier.create(LogicalDatastoreType.CONFIGURATION,
bindingContext.appConfigPath);
appConfigChangeListenerReg = dataBroker.registerDataTreeChangeListener(dataTreeId,
- (ClusteredDataTreeChangeListener<DataObject>) changes -> onAppConfigChanged(changes));
+ (ClusteredDataTreeChangeListener<DataObject>) this::onAppConfigChanged);
readInitialAppConfig(dataBroker);
}
private void readInitialAppConfig(final DataBroker dataBroker) {
+ final FluentFuture<Optional<DataObject>> future;
+ try (ReadTransaction readOnlyTx = dataBroker.newReadOnlyTransaction()) {
+ future = readOnlyTx.read(LogicalDatastoreType.CONFIGURATION, bindingContext.appConfigPath);
+ }
- final ReadOnlyTransaction readOnlyTx = dataBroker.newReadOnlyTransaction();
- CheckedFuture<Optional<DataObject>, ReadFailedException> future = readOnlyTx.read(
- LogicalDatastoreType.CONFIGURATION, bindingContext.appConfigPath);
- Futures.addCallback(future, new FutureCallback<Optional<DataObject>>() {
+ future.addCallback(new FutureCallback<Optional<DataObject>>() {
@Override
public void onSuccess(final Optional<DataObject> possibleAppConfig) {
LOG.debug("{}: Read of app config {} succeeded: {}", logName(), bindingContext
.appConfigBindingClass.getName(), possibleAppConfig);
- readOnlyTx.close();
setInitialAppConfig(possibleAppConfig);
}
@Override
public void onFailure(final Throwable failure) {
- readOnlyTx.close();
-
// We may have gotten the app config via the data tree change listener so only retry if not.
if (readingInitialAppConfig.get()) {
LOG.warn("{}: Read of app config {} failed - retrying", logName(),
readInitialAppConfig(dataBroker);
}
}
- });
+ }, MoreExecutors.directExecutor());
}
private void onAppConfigChanged(final Collection<DataTreeModification<DataObject>> changes) {
}
private DataObject createDefaultInstance() {
- YangInstanceIdentifier yangPath = bindingSerializer.toYangInstanceIdentifier(bindingContext.appConfigPath);
-
- LOG.debug("{}: Creating app config instance from path {}, Qname: {}", logName(), yangPath,
- bindingContext.bindingQName);
-
- SchemaService schemaService = getOSGiService(SchemaService.class);
- if (schemaService == null) {
- setFailureMessage(String.format("%s: Could not obtain the SchemaService OSGi service", logName()));
- return null;
- }
-
- SchemaContext schemaContext = schemaService.getGlobalContext();
-
- Module module = schemaContext.findModuleByNamespaceAndRevision(bindingContext.bindingQName.getNamespace(),
- bindingContext.bindingQName.getRevision());
- if (module == null) {
- setFailureMessage(String.format("%s: Could not obtain the module schema for namespace %s, revision %s",
- logName(), bindingContext.bindingQName.getNamespace(), bindingContext.bindingQName.getRevision()));
- return null;
- }
-
- DataSchemaNode dataSchema = module.getDataChildByName(bindingContext.bindingQName);
- if (dataSchema == null) {
- setFailureMessage(String.format("%s: Could not obtain the schema for %s", logName(),
- bindingContext.bindingQName));
- return null;
- }
-
- if (!bindingContext.schemaType.isAssignableFrom(dataSchema.getClass())) {
- setFailureMessage(String.format("%s: Expected schema type %s for %s but actual type is %s", logName(),
- bindingContext.schemaType, bindingContext.bindingQName, dataSchema.getClass()));
- return null;
- }
-
- NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigXMLFile(schemaContext, dataSchema);
- if (dataNode == null) {
- dataNode = parsePossibleDefaultAppConfigElement(schemaContext, dataSchema);
- }
-
- if (dataNode == null) {
- dataNode = bindingContext.newDefaultNode(dataSchema);
- }
-
- DataObject appConfig = bindingSerializer.fromNormalizedNode(yangPath, dataNode).getValue();
-
- if (appConfig == null) {
- // This shouldn't happen but need to handle it in case...
- setFailureMessage(String.format("%s: Could not create instance for app config binding %s",
- logName(), bindingContext.appConfigBindingClass));
- }
+ try {
+ ConfigURLProvider inputStreamProvider = appConfigFileName -> {
+ File appConfigFile = new File(DEFAULT_APP_CONFIG_FILE_PATH, appConfigFileName);
+ LOG.debug("{}: parsePossibleDefaultAppConfigXMLFile looking for file {}", logName(),
+ appConfigFile.getAbsolutePath());
- return appConfig;
- }
+ if (!appConfigFile.exists()) {
+ return Optional.empty();
+ }
- private NormalizedNode<?, ?> parsePossibleDefaultAppConfigXMLFile(final SchemaContext schemaContext,
- final DataSchemaNode dataSchema) {
+ LOG.debug("{}: Found file {}", logName(), appConfigFile.getAbsolutePath());
+
+ return Optional.of(appConfigFile.toURI().toURL());
+ };
+
+ DataStoreAppConfigDefaultXMLReader<?> reader = new DataStoreAppConfigDefaultXMLReader<>(logName(),
+ defaultAppConfigFileName, getOSGiService(DOMSchemaService.class), bindingSerializer, bindingContext,
+ inputStreamProvider);
+ return reader.createDefaultInstance((schemaContext, dataSchema) -> {
+ // Fallback if file cannot be read, try XML from Config
+ NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigElement(schemaContext, dataSchema);
+ if (dataNode == null) {
+ // or, as last resort, defaults from the model
+ return bindingContext.newDefaultNode(dataSchema);
+ } else {
+ return dataNode;
+ }
+ });
- String appConfigFileName = defaultAppConfigFileName;
- if (Strings.isNullOrEmpty(appConfigFileName)) {
- String moduleName = findYangModuleName(bindingContext.bindingQName, schemaContext);
- if (moduleName == null) {
- return null;
+ } catch (final ConfigXMLReaderException | IOException | SAXException | XMLStreamException
+ | ParserConfigurationException | URISyntaxException e) {
+ if (e.getCause() == null) {
+ setFailureMessage(e.getMessage());
+ } else {
+ setFailure(e.getMessage(), e);
}
-
- appConfigFileName = moduleName + "_" + bindingContext.bindingQName.getLocalName() + ".xml";
- }
-
- File appConfigFile = new File(DEFAULT_APP_CONFIG_FILE_PATH, appConfigFileName);
-
- LOG.debug("{}: parsePossibleDefaultAppConfigXMLFile looking for file {}", logName(),
- appConfigFile.getAbsolutePath());
-
- if (!appConfigFile.exists()) {
return null;
}
-
- LOG.debug("{}: Found file {}", logName(), appConfigFile.getAbsolutePath());
-
- DomToNormalizedNodeParserFactory parserFactory = DomToNormalizedNodeParserFactory.getInstance(
- XmlUtils.DEFAULT_XML_CODEC_PROVIDER, schemaContext);
-
- try (FileInputStream fis = new FileInputStream(appConfigFile)) {
- Document root = UntrustedXML.newDocumentBuilder().parse(fis);
- NormalizedNode<?, ?> dataNode = bindingContext.parseDataElement(root.getDocumentElement(), dataSchema,
- parserFactory);
-
- LOG.debug("{}: Parsed data node: {}", logName(), dataNode);
-
- return dataNode;
- } catch (SAXException | IOException e) {
- String msg = String.format("%s: Could not read/parse app config file %s", logName(), appConfigFile);
- LOG.error(msg, e);
- setFailureMessage(msg);
- }
-
- return null;
- }
-
- private String findYangModuleName(final QName qname, final SchemaContext schemaContext) {
- for (Module m : schemaContext.getModules()) {
- if (qname.getModule().equals(m.getQNameModule())) {
- return m.getName();
- }
- }
-
- setFailureMessage(String.format("%s: Could not find yang module for QName %s", logName(), qname));
- return null;
}
@Nullable
private NormalizedNode<?, ?> parsePossibleDefaultAppConfigElement(final SchemaContext schemaContext,
- final DataSchemaNode dataSchema) {
+ final DataSchemaNode dataSchema) throws URISyntaxException, IOException, ParserConfigurationException,
+ SAXException, XMLStreamException {
if (defaultAppConfigElement == null) {
return null;
}
LOG.debug("{}: parsePossibleDefaultAppConfigElement for {}", logName(), bindingContext.bindingQName);
- DomToNormalizedNodeParserFactory parserFactory = DomToNormalizedNodeParserFactory.getInstance(
- XmlUtils.DEFAULT_XML_CODEC_PROVIDER, schemaContext);
-
-
LOG.debug("{}: Got app config schema: {}", logName(), dataSchema);
NormalizedNode<?, ?> dataNode = bindingContext.parseDataElement(defaultAppConfigElement, dataSchema,
- parserFactory);
+ schemaContext);
LOG.debug("{}: Parsed data node: {}", logName(), dataNode);
return dataNode;
}
-
@Override
public void destroy(final Object instance) {
super.destroy(instance);
}
}
- /**
- * Internal base class to abstract binding type-specific behavior.
- */
- private abstract static class BindingContext {
- final InstanceIdentifier<DataObject> appConfigPath;
- final Class<DataObject> appConfigBindingClass;
- final Class<? extends DataSchemaNode> schemaType;
- final QName bindingQName;
-
- protected BindingContext(final Class<DataObject> appConfigBindingClass,
- final InstanceIdentifier<DataObject> appConfigPath, final Class<? extends DataSchemaNode> schemaType) {
- this.appConfigBindingClass = appConfigBindingClass;
- this.appConfigPath = appConfigPath;
- this.schemaType = schemaType;
-
- bindingQName = BindingReflections.findQName(appConfigBindingClass);
- }
-
- abstract NormalizedNode<?, ?> parseDataElement(Element element, DataSchemaNode dataSchema,
- DomToNormalizedNodeParserFactory parserFactory);
-
- abstract NormalizedNode<?, ?> newDefaultNode(DataSchemaNode dataSchema);
- }
-
- /**
- * BindingContext implementation for a container binding.
- */
- private static class ContainerBindingContext extends BindingContext {
- ContainerBindingContext(final Class<DataObject> appConfigBindingClass) {
- super(appConfigBindingClass, InstanceIdentifier.create(appConfigBindingClass), ContainerSchemaNode.class);
- }
-
- @Override
- NormalizedNode<?, ?> newDefaultNode(final DataSchemaNode dataSchema) {
- return ImmutableNodes.containerNode(bindingQName);
- }
-
- @Override
- NormalizedNode<?, ?> parseDataElement(final Element element, final DataSchemaNode dataSchema,
- final DomToNormalizedNodeParserFactory parserFactory) {
- return parserFactory.getContainerNodeParser().parse(Collections.singletonList(element),
- (ContainerSchemaNode)dataSchema);
- }
- }
-
- /**
- * BindingContext implementation for a list binding.
- */
- private static class ListBindingContext extends BindingContext {
- final String appConfigListKeyValue;
-
- ListBindingContext(final Class<DataObject> appConfigBindingClass,
- final InstanceIdentifier<DataObject> appConfigPath, final String appConfigListKeyValue) {
- super(appConfigBindingClass, appConfigPath, ListSchemaNode.class);
- this.appConfigListKeyValue = appConfigListKeyValue;
- }
-
- @SuppressWarnings({ "rawtypes", "unchecked" })
- private static ListBindingContext newInstance(final Class<DataObject> bindingClass, final String listKeyValue)
- throws InstantiationException, IllegalAccessException, IllegalArgumentException,
- InvocationTargetException, NoSuchMethodException, SecurityException {
- // We assume the yang list key type is string.
- Identifier keyInstance = (Identifier) bindingClass.getMethod("getKey").getReturnType()
- .getConstructor(String.class).newInstance(listKeyValue);
- InstanceIdentifier appConfigPath = InstanceIdentifier.builder((Class)bindingClass, keyInstance).build();
- return new ListBindingContext(bindingClass, appConfigPath, listKeyValue);
- }
-
- @Override
- NormalizedNode<?, ?> newDefaultNode(final DataSchemaNode dataSchema) {
- // We assume there's only one key for the list.
- List<QName> keys = ((ListSchemaNode)dataSchema).getKeyDefinition();
- Preconditions.checkArgument(keys.size() == 1, "Expected only 1 key for list %s", appConfigBindingClass);
- QName listKeyQName = keys.iterator().next();
- return ImmutableNodes.mapEntryBuilder(bindingQName, listKeyQName, appConfigListKeyValue).build();
- }
-
- @Override
- NormalizedNode<?, ?> parseDataElement(final Element element, final DataSchemaNode dataSchema,
- final DomToNormalizedNodeParserFactory parserFactory) {
- return parserFactory.getMapEntryNodeParser().parse(Collections.singletonList(element),
- (ListSchemaNode)dataSchema);
- }
- }
}
Code Review / controller.git / blobdiff