*/
package org.opendaylight.controller.blueprint.ext;
-import com.google.common.base.Optional;
-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.IOException;
+import java.net.URISyntaxException;
import java.util.Collection;
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.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.blueprint.ext.DataStoreAppConfigDefaultXMLReader.ConfigURLProvider;
-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.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.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
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.transform.dom.parser.DomToNormalizedNodeParserFactory;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaTreeInference;
import org.osgi.service.blueprint.container.ComponentDefinitionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
/**
* Factory metadata corresponding to the "clustered-app-config" element that obtains an application's
// project are still used - conversion to the mdsal binding classes hasn't occurred yet.
private volatile BindingNormalizedNodeSerializer bindingSerializer;
- public DataStoreAppConfigMetadata(@Nonnull final String id, @Nonnull final String appConfigBindingClassName,
- @Nullable final String appConfigListKeyValue, @Nullable final String defaultAppConfigFileName,
- @Nonnull final UpdateStrategy updateStrategyValue, @Nullable final Element defaultAppConfigElement) {
+ public DataStoreAppConfigMetadata(final String id, final @NonNull String appConfigBindingClassName,
+ final @Nullable String appConfigListKeyValue, final @Nullable String defaultAppConfigFileName,
+ final @NonNull UpdateStrategy updateStrategyValue, final @Nullable Element defaultAppConfigElement) {
super(id);
this.defaultAppConfigElement = defaultAppConfigElement;
this.defaultAppConfigFileName = defaultAppConfigFileName;
this.appConfigBindingClassName = appConfigBindingClassName;
this.appConfigListKeyValue = appConfigListKeyValue;
- this.appConfigUpdateStrategy = updateStrategyValue;
+ appConfigUpdateStrategy = updateStrategyValue;
}
@Override
Class<DataObject> appConfigBindingClass;
try {
Class<?> bindingClass = container.getBundleContext().getBundle().loadClass(appConfigBindingClassName);
- if (!DataObject.class.isAssignableFrom(bindingClass)) {
+ if (!ChildOf.class.isAssignableFrom(bindingClass)) {
throw new ComponentDefinitionException(String.format(
"%s: Specified app config binding class %s does not extend %s",
- logName(), appConfigBindingClassName, DataObject.class.getName()));
+ logName(), appConfigBindingClassName, ChildOf.class.getName()));
}
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);
}
// 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 ReadOnlyTransaction readOnlyTx = dataBroker.newReadOnlyTransaction();
- CheckedFuture<Optional<DataObject>, ReadFailedException> future = readOnlyTx.read(
- LogicalDatastoreType.CONFIGURATION, bindingContext.appConfigPath);
- Futures.addCallback(future, new FutureCallback<Optional<DataObject>>() {
+ final FluentFuture<Optional<DataObject>> future;
+ try (ReadTransaction readOnlyTx = dataBroker.newReadOnlyTransaction()) {
+ future = readOnlyTx.read(LogicalDatastoreType.CONFIGURATION, bindingContext.appConfigPath);
+ }
+
+ 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() {
try {
- @SuppressWarnings("resource")
ConfigURLProvider inputStreamProvider = appConfigFileName -> {
File appConfigFile = new File(DEFAULT_APP_CONFIG_FILE_PATH, appConfigFileName);
LOG.debug("{}: parsePossibleDefaultAppConfigXMLFile looking for file {}", logName(),
appConfigFile.getAbsolutePath());
if (!appConfigFile.exists()) {
- return Optional.absent();
+ return Optional.empty();
}
LOG.debug("{}: Found file {}", logName(), appConfigFile.getAbsolutePath());
return Optional.of(appConfigFile.toURI().toURL());
};
- DataStoreAppConfigDefaultXMLReader<?> reader = new DataStoreAppConfigDefaultXMLReader(logName(),
- defaultAppConfigFileName, getOSGiService(SchemaService.class), bindingSerializer, bindingContext,
+ DataStoreAppConfigDefaultXMLReader<?> reader = new DataStoreAppConfigDefaultXMLReader<>(logName(),
+ defaultAppConfigFileName, getOSGiService(DOMSchemaService.class), bindingSerializer, bindingContext,
inputStreamProvider);
- return reader.createDefaultInstance((schemaContext, dataSchema) -> {
+ return reader.createDefaultInstance(dataSchema -> {
// Fallback if file cannot be read, try XML from Config
- NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigElement(schemaContext, dataSchema);
+ NormalizedNode dataNode = parsePossibleDefaultAppConfigElement(dataSchema);
if (dataNode == null) {
// or, as last resort, defaults from the model
return bindingContext.newDefaultNode(dataSchema);
}
});
- } catch (ConfigXMLReaderException e) {
+ } catch (final ConfigXMLReaderException | IOException | SAXException | XMLStreamException
+ | ParserConfigurationException | URISyntaxException e) {
if (e.getCause() == null) {
setFailureMessage(e.getMessage());
} else {
}
}
- @Nullable
- private NormalizedNode<?, ?> parsePossibleDefaultAppConfigElement(final SchemaContext schemaContext,
- final DataSchemaNode dataSchema) {
+ private @Nullable NormalizedNode parsePossibleDefaultAppConfigElement(final SchemaTreeInference 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);
+ NormalizedNode dataNode = bindingContext.parseDataElement(defaultAppConfigElement, dataSchema);
LOG.debug("{}: Parsed data node: {}", logName(), dataNode);
Code Review / controller.git / blobdiff