<property name="tokens" value="LITERAL_TRY, LITERAL_CATCH, LITERAL_FINALLY, LITERAL_IF, LITERAL_ELSE, LITERAL_SWITCH"/>
</module>
<module name="NeedBraces"/>
- <module name="LeftCurly">
- <property name="maxLineLength" value="100"/>
- </module>
- <module name="RightCurly"/>
+ <module name="LeftCurly"/>
<module name="RightCurly">
<property name="option" value="alone"/>
<property name="tokens" value="CLASS_DEF, METHOD_DEF, CTOR_DEF, LITERAL_FOR, LITERAL_WHILE, LITERAL_DO, STATIC_INIT, INSTANCE_INIT"/>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!-- ODL dependencies -->
- <odl.yangtools.version>2.0.11</odl.yangtools.version>
- <odl.mdsal.version>2.5.0</odl.mdsal.version>
- <odl.mdsal.controller.version>1.8.0</odl.mdsal.controller.version>
- <odl.mdsalmodel.version>0.13.0</odl.mdsalmodel.version>
- <odl.netconf.version>1.5.0</odl.netconf.version>
- <odl.restconf.version>1.8.0</odl.restconf.version>
- <odl.salGenerator.version>0.13.0</odl.salGenerator.version>
- <odl.bgpcep.version>0.10.0</odl.bgpcep.version>
+ <odl.yangtools.version>2.1.8</odl.yangtools.version>
+ <odl.mdsal.version>3.0.6</odl.mdsal.version>
+ <odl.mdsal.controller.version>1.9.0</odl.mdsal.controller.version>
+ <odl.mdsalmodel.version>0.13.2</odl.mdsalmodel.version>
+ <odl.netconf.version>1.6.0</odl.netconf.version>
+ <odl.restconf.version>1.9.0</odl.restconf.version>
+ <odl.salGenerator.version>0.13.2</odl.salGenerator.version>
+ <odl.bgpcep.version>0.11.0</odl.bgpcep.version>
<salGeneratorPath>target/generated-sources/mdsal-binding</salGeneratorPath>
<!-- common dependencies -->
<jdt.version>2.1.150</jdt.version>
<!-- plugins -->
- <checkstyle.plugin.version>2.17</checkstyle.plugin.version>
- <checkstyle.version>7.1.2</checkstyle.version>
+ <checkstyle.plugin.version>3.0.0</checkstyle.plugin.version>
+ <checkstyle.version>8.18</checkstyle.version>
<maven.javadoc.version>2.10.3</maven.javadoc.version>
<jacoco.version>0.7.9</jacoco.version>
<enforcer.version>1.4</enforcer.version>
<phase>process-sources</phase>
<configuration>
<configLocation>honeycomb-checkstyle-logging.xml</configLocation>
- <sourceDirectory>${project.basedir}</sourceDirectory>
+ <sourceDirectories>
+ <sourceDirectory>${project.basedir}</sourceDirectory>
+ </sourceDirectories>
+
<outputFile>${project.build.directory}/checkstyle-logging-result.xml</outputFile>
</configuration>
</execution>
<groovy.version>2.4.7</groovy.version>
<groovy.eclipse.compiler.version>2.9.2-01</groovy.eclipse.compiler.version>
<groovy.eclipse.batch.version>2.4.3-01</groovy.eclipse.batch.version>
- <odl.yang-binding.version>0.13.0</odl.yang-binding.version>
+ <odl.yang-binding.version>0.13.2</odl.yang-binding.version>
</properties>
<dependencyManagement>
// TODO(HONEYCOMB-367): updates for whole list instead of list item
// are needed to support deleteALL (might be required for performance reasons).
bgpDataBroker
- .registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, managedId),
- new LocRibChangeListener(writer));
+ .registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, managedId),
+ new LocRibChangeListener(writer));
}
}
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv4.routes.Ipv4Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv4.routes.ipv4.routes.Ipv4Route;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv4.routes.ipv4.routes.Ipv4RouteKey;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
try {
final ContainerNode containerNode = jsonReader.readData(schemaService.getGlobalContext(), path);
- final DOMDataWriteTransaction domDataWriteTransaction = dataTree.newWriteOnlyTransaction();
+ final DOMDataTreeWriteTransaction domDataWriteTransaction = dataTree.newWriteOnlyTransaction();
for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild : containerNode
.getValue()) {
final YangInstanceIdentifier iid = YangInstanceIdentifier.create(dataContainerChild.getIdentifier());
}
// Block here to prevent subsequent initializers processing before context is fully restored
- domDataWriteTransaction.submit().checkedGet();
+ domDataWriteTransaction.commit().get();
LOG.debug("Data from {} restored successfully", path);
- } catch (IOException | TransactionCommitFailedException e) {
- throw new InitializeException("Unable to restore data from " + path, e);
+ } catch (IOException | InterruptedException | ExecutionException ex) {
+ throw new InitializeException("Unable to restore data from " + path, ex);
}
}
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
-import com.google.common.util.concurrent.Futures;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
@Mock
private ContainerNode data;
@Mock
- private DOMDataWriteTransaction writeTx;
+ private DOMDataTreeWriteTransaction writeTx;
private Path path;
private YangInstanceIdentifier.NodeIdentifier nodeId =
new YangInstanceIdentifier.NodeIdentifier(QName.create("namespace", "data"));
when(schemaService.getGlobalContext()).thenReturn(schemaContext);
when(jsonReader.readData(schemaContext, path)).thenReturn(data);
when(dataTree.newWriteOnlyTransaction()).thenReturn(writeTx);
- when(writeTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ when(writeTx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
when(data.getValue()).thenReturn(Collections.singleton(data));
when(data.getIdentifier()).thenReturn(nodeId);
}
verify(dataTree).newWriteOnlyTransaction();
verify(writeTx).put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.create(nodeId), data);
- verify(writeTx).submit();
+ verify(writeTx).commit();
}
@Test
package io.fd.honeycomb.data;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* @param path Path of the node
* @return a CheckFuture containing the result of the read.
*/
- CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(@Nonnull final YangInstanceIdentifier path);
+ FluentFuture<Optional<NormalizedNode<?, ?>>> read(@Nonnull final YangInstanceIdentifier path);
}
<groupId>org.opendaylight.netconf</groupId>
<artifactId>mdsal-netconf-connector</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.apache.commons</groupId>
+ <artifactId>commons-lang3</artifactId>
+ <version>3.8.1</version>
+ </dependency>
<dependency>
<groupId>junit</groupId>
import static com.google.common.base.Preconditions.checkNotNull;
+import com.google.common.collect.ClassToInstanceMap;
+import com.google.common.collect.ImmutableClassToInstanceMap;
import io.fd.honeycomb.data.DataModification;
import io.fd.honeycomb.data.ModifiableDataManager;
import io.fd.honeycomb.data.ReadableDataManager;
import java.io.Closeable;
import java.io.IOException;
-import java.util.Collections;
-import java.util.Map;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
}
@Override
- public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
- LOG.trace("DataBroker({}).newReadOnlyTransaction()", this);
- return transactionFactory.newReadOnlyTransaction();
+ public DOMDataTreeReadTransaction newReadOnlyTransaction() {
+ LOG.trace("DataBroker({}).newReadTransaction()", this);
+ return transactionFactory.newReadTransaction();
}
@Override
- public DOMDataReadWriteTransaction newReadWriteTransaction() {
+ public DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
LOG.trace("DataBroker({}).newReadWriteTransaction()", this);
return transactionFactory.newReadWriteTransaction();
}
@Override
- public DOMDataWriteTransaction newWriteOnlyTransaction() {
- LOG.trace("DataBroker({}).newWriteOnlyTransaction()", this);
- return transactionFactory.newWriteOnlyTransaction();
+ public DOMDataTreeWriteTransaction newWriteOnlyTransaction() {
+ LOG.trace("DataBroker({}).newWriteTransaction()", this);
+ return transactionFactory.newWriteTransaction();
}
@Override
- public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
+ public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) {
throw new UnsupportedOperationException("Not supported");
}
- @Nonnull
@Override
- public Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> getSupportedExtensions() {
- return Collections.singletonMap(
- DOMDataTransactionValidator.class,
- (DOMDataTransactionValidator) tx -> ((ValidableTransaction)tx).validate()
- );
+ public @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() {
+ return ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class,
+ tx -> ((ValidableTransaction) tx).validate());
}
/**
*/
public interface TransactionFactory {
- DOMDataReadOnlyTransaction newReadOnlyTransaction();
+ DOMDataTreeReadTransaction newReadTransaction();
- DOMDataReadWriteTransaction newReadWriteTransaction();
+ DOMDataTreeReadWriteTransaction newReadWriteTransaction();
- DOMDataWriteTransaction newWriteOnlyTransaction();
+ DOMDataTreeWriteTransaction newWriteTransaction();
}
/**
}
@Override
- public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
+ public DOMDataTreeReadTransaction newReadTransaction() {
return ReadOnlyTransaction.create(configDataTree.newModification(), operationalDataTree);
}
@Override
- public DOMDataReadWriteTransaction newReadWriteTransaction() {
+ public DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
final DataModification configModification = configDataTree.newModification();
return new ReadWriteTransaction(
ReadOnlyTransaction.create(configModification, operationalDataTree),
}
@Override
- public DOMDataWriteTransaction newWriteOnlyTransaction() {
+ public DOMDataTreeWriteTransaction newWriteTransaction() {
return WriteTransaction.createConfigOnly(configDataTree.newModification());
}
}
}
@Override
- public DOMDataReadOnlyTransaction newReadOnlyTransaction() {
+ public DOMDataTreeReadTransaction newReadTransaction() {
return ReadOnlyTransaction.createOperationalOnly(operationalDataTree);
}
@Override
- public DOMDataReadWriteTransaction newReadWriteTransaction() {
+ public DOMDataTreeReadWriteTransaction newReadWriteTransaction() {
final DataModification dataModification = operationalDataTree.newModification();
return new ReadWriteTransaction(
- ReadOnlyTransaction.createOperationalOnly(dataModification),
- WriteTransaction.createOperationalOnly(dataModification));
+ ReadOnlyTransaction.createOperationalOnly(dataModification),
+ WriteTransaction.createOperationalOnly(dataModification));
}
@Override
- public DOMDataWriteTransaction newWriteOnlyTransaction() {
+ public DOMDataTreeWriteTransaction newWriteTransaction() {
return WriteTransaction.createOperationalOnly(operationalDataTree.newModification());
}
}
package io.fd.honeycomb.data.impl;
import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.util.concurrent.Futures.immediateCheckedFuture;
import static io.fd.honeycomb.data.impl.ModifiableDataTreeDelegator.DataTreeWriteContextFactory.DataTreeWriteContext;
import static io.fd.honeycomb.data.impl.ModifiableDataTreeManager.DataTreeContextFactory.DataTreeContext;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.data.DataModification;
import io.fd.honeycomb.data.ReadableDataManager;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.write.registry.WriterRegistry.DataObjectUpdates;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public final class ModifiableDataTreeDelegator extends ModifiableDataTreeManager {
private static final Logger LOG = LoggerFactory.getLogger(ModifiableDataTreeDelegator.class);
- private static final ReadableDataManager EMPTY_OPERATIONAL = p -> immediateCheckedFuture(Optional.absent());
+ private static final ReadableDataManager EMPTY_OPERATIONAL =
+ p -> FluentFutures.immediateFluentFuture(Optional.empty());
private final WriterRegistry writerRegistry;
private final DataBroker contextBroker;
try {
writerRegistry.processModifications(baUpdates, ctx);
- final CheckedFuture<Void, TransactionCommitFailedException> contextUpdateResult =
- ((TransactionMappingContext) mappingContext).submit();
+ final FluentFuture<? extends CommitInfo> contextUpdateResult =
+ ((TransactionMappingContext) mappingContext).commit();
// Blocking on context data update
- contextUpdateResult.checkedGet();
+ contextUpdateResult.get();
} catch (UpdateFailedException e) {
// TODO - HONEYCOMB-411
LOG.warn("Failed to apply all changes", e);
// not passing the cause,its logged above and it would be logged after transaction
// ended again(prevent double logging of same error
throw new Reverter.RevertSuccessException(getNonProcessedNodes(baUpdates, processed));
- } catch (TransactionCommitFailedException e) {
+ } catch (InterruptedException | ExecutionException ex) {
// TODO HONEYCOMB-162 revert should probably occur when context is not written successfully
final String msg = "Error while updating mapping context data";
- LOG.error(msg, e);
- throw new TranslationException(msg, e);
+ LOG.error(msg, ex);
+ throw new TranslationException(msg, ex);
} finally {
// Using finally instead of try-with-resources in order to leave ctx open for BulkUpdateException catch
// block. The context is needed there, but try-with-resources closes the resource before handling ex.
@SuppressWarnings("squid:S2095")
private TransactionWriteContext getRevertTransactionContext(final MappingContext affectedMappingContext) {
// Before Tx == after partial update
- final DOMDataReadOnlyTransaction beforeTx = ReadOnlyTransaction.create(this, EMPTY_OPERATIONAL);
+ final DOMDataTreeReadTransaction beforeTx = ReadOnlyTransaction.create(this, EMPTY_OPERATIONAL);
// After Tx == before partial update
- final DOMDataReadOnlyTransaction afterTx = ReadOnlyTransaction.create(untouchedModification, EMPTY_OPERATIONAL);
+ final DOMDataTreeReadTransaction afterTx =
+ ReadOnlyTransaction.create(untouchedModification, EMPTY_OPERATIONAL);
return new TransactionWriteContext(serializer, beforeTx, afterTx, affectedMappingContext);
}
@SuppressWarnings("squid:S2095")
private TransactionWriteContext getTransactionWriteContext() {
// Before Tx must use modification
- final DOMDataReadOnlyTransaction beforeTx = ReadOnlyTransaction.create(untouchedModification, EMPTY_OPERATIONAL);
+ final DOMDataTreeReadTransaction
+ beforeTx = ReadOnlyTransaction.create(untouchedModification, EMPTY_OPERATIONAL);
// After Tx must use current modification
- final DOMDataReadOnlyTransaction afterTx = ReadOnlyTransaction.create(this, EMPTY_OPERATIONAL);
+ final DOMDataTreeReadTransaction afterTx = ReadOnlyTransaction.create(this, EMPTY_OPERATIONAL);
final TransactionMappingContext mappingContext = new TransactionMappingContext(
contextBroker.newReadWriteTransaction());
return new TransactionWriteContext(serializer, beforeTx, afterTx, mappingContext);
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.util.concurrent.Futures.immediateCheckedFuture;
import static io.fd.honeycomb.data.impl.ModifiableDataTreeManager.DataTreeContextFactory.DataTreeContext;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.data.DataModification;
import io.fd.honeycomb.data.ModifiableDataManager;
-import io.fd.honeycomb.translate.ValidationFailedException;
import io.fd.honeycomb.translate.TranslationException;
+import io.fd.honeycomb.translate.ValidationFailedException;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.apache.commons.lang3.builder.RecursiveToStringStyle;
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
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.tree.CursorAwareDataTreeModification;
}
@Override
- public final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(@Nonnull final YangInstanceIdentifier path) {
+ public final FluentFuture<Optional<NormalizedNode<?, ?>>> read(@Nonnull final YangInstanceIdentifier path) {
return newModification().read(path);
}
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(
- @Nonnull final YangInstanceIdentifier path) {
- // TODO(HONEYCOMB-192): switch to java.util.Optional when rest of ODL infra does
- final Optional<NormalizedNode<?, ?>> node = Optional.fromNullable(modification.readNode(path).orElse(null));
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> read(@Nonnull final YangInstanceIdentifier path) {
+ final Optional<NormalizedNode<?, ?>> node = modification.readNode(path);
if (LOG.isTraceEnabled() && node.isPresent()) {
LOG.trace("ConfigSnapshot.read: {}", node.get());
}
- return immediateCheckedFuture(node);
+ return FluentFutures.immediateFluentFuture(node);
}
@Override
// Sealed modification cannot be altered, so create copy.
final CursorAwareDataTreeModification modificationCopy =
(CursorAwareDataTreeModification) snapshot.newModification();
- final DataTreeModificationCursor cursor = modificationCopy.createCursor(dataTree.getRootPath());
- checkState(cursor != null, "DataTreeModificationCursor for root path should not be null");
- modification.applyToCursor(cursor);
+ Optional<? extends DataTreeModificationCursor> cursor = modificationCopy.openCursor(dataTree.getRootPath());
+ checkState(cursor.isPresent(), "DataTreeModificationCursor for root path should not be empty");
+ modification.applyToCursor(cursor.get());
// Then validate it.
validateCandidate(prepareCandidateContext(modificationCopy));
}
return dataCandidate.getModificationType();
}
- com.google.common.base.Optional<NormalizedNode<?, ?>> getDataBefore() {
- // TODO(HONEYCOMB-192): switch to java.util.Optional when rest of ODL infra does
- return com.google.common.base.Optional.fromNullable(dataCandidate.getDataBefore().orElse(null));
+ Optional<NormalizedNode<?, ?>> getDataBefore() {
+ return dataCandidate.getDataBefore();
}
- com.google.common.base.Optional<NormalizedNode<?, ?>> getDataAfter() {
- // TODO(HONEYCOMB-192): switch to java.util.Optional when rest of ODL infra does
- return com.google.common.base.Optional.fromNullable(dataCandidate.getDataAfter().orElse(null));
+ Optional<NormalizedNode<?, ?>> getDataAfter() {
+ return dataCandidate.getDataAfter();
}
Object getSchemaNode() {
((SchemaNode) schemaNode).getQName().equals(identifier.getNodeType())) {
found = schemaNode;
} else {
- found = ((DataNodeContainer) schemaNode).getDataChildByName(identifier.getNodeType());
+ found = ((DataNodeContainer) schemaNode).findDataChildByName(identifier.getNodeType()).orElse(null);
}
} else if (schemaNode instanceof ChoiceSchemaNode) {
// For choices, iterate through all the cases
private ModificationDiff detectUnderDisappearedNonPresenceContainer(
@Nonnull final Modification modification) {
- final com.google.common.base.Optional<NormalizedNode<?, ?>> dataBefore = modification.getDataBefore();
+ final java.util.Optional<NormalizedNode<?, ?>> dataBefore = modification.getDataBefore();
// is disappear case
if (dataBefore.isPresent()) {
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
}
static NormalizedNodeUpdate create(@Nonnull final Modification modification) {
- final com.google.common.base.Optional<NormalizedNode<?, ?>> beforeData =
- modification.getDataBefore();
- final com.google.common.base.Optional<NormalizedNode<?, ?>> afterData =
- modification.getDataAfter();
+ final Optional<NormalizedNode<?, ?>> beforeData = modification.getDataBefore();
+ final Optional<NormalizedNode<?, ?>> afterData = modification.getDataAfter();
checkArgument(beforeData.isPresent() || afterData.isPresent(),
"Both before and after data are null for %s", modification.getId());
- return NormalizedNodeUpdate.create(modification.getId(), beforeData.orNull(), afterData.orNull());
+ return NormalizedNodeUpdate.create(modification.getId(), beforeData.orElse(null), afterData.orElse(null));
}
static NormalizedNodeUpdate create(@Nonnull final YangInstanceIdentifier id,
import static java.util.Objects.requireNonNull;
import com.google.common.base.Function;
-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.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import io.fd.honeycomb.data.DataModification;
import io.fd.honeycomb.data.ReadableDataManager;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-final class ReadOnlyTransaction implements DOMDataReadOnlyTransaction {
+final class ReadOnlyTransaction implements DOMDataTreeReadTransaction {
private static final Logger LOG = LoggerFactory.getLogger(ReadOnlyTransaction.class);
}
@Override
- public synchronized CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(
- final LogicalDatastoreType store,
- final YangInstanceIdentifier path) {
+ public synchronized FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
LOG.debug("ReadOnlyTransaction.read(), store={}, path={}", store, path);
checkState(!closed, "Transaction has been closed");
}
@Override
- public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
- final YangInstanceIdentifier path) {
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
LOG.debug("ReadOnlyTransaction.exists() store={}, path={}", store, path);
- ListenableFuture<Boolean> listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT);
- return Futures.makeChecked(listenableFuture, ANY_EX_TO_READ_FAILED_EXCEPTION_MAPPER);
+ ListenableFuture<Boolean> listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT,
+ MoreExecutors.directExecutor());
+ return FluentFuture.from(listenableFuture);
}
@Nonnull
private static final Function<? super Optional<NormalizedNode<?, ?>>, ? extends Boolean> IS_NODE_PRESENT =
(Function<Optional<NormalizedNode<?, ?>>, Boolean>) input -> input == null ? Boolean.FALSE : input.isPresent();
- private static final Function<? super Exception, ReadFailedException> ANY_EX_TO_READ_FAILED_EXCEPTION_MAPPER =
- (Function<Exception, ReadFailedException>) e -> new ReadFailedException("Exists failed", e);
}
\ No newline at end of file
package io.fd.honeycomb.data.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.apache.commons.lang3.builder.RecursiveToStringStyle;
-import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
-import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
- * Composite DOM transaction that delegates reads to a {@link DOMDataReadTransaction} delegate and writes to a {@link
- * DOMDataWriteTransaction} delegate.
+ * Composite DOM transaction that delegates reads to a {@link DOMDataTreeReadTransaction} delegate and writes to a {@link
+ * DOMDataTreeWriteTransaction} delegate.
*/
-final class ReadWriteTransaction implements DOMDataReadWriteTransaction, ValidableTransaction {
+final class ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction {
- private static final Logger LOG = LoggerFactory.getLogger(ReadWriteTransaction.class);
-
- private final DOMDataReadOnlyTransaction delegateReadTx;
+ private final DOMDataTreeReadTransaction delegateReadTx;
private final ValidableTransaction delegateWriteTx;
- ReadWriteTransaction(@Nonnull final DOMDataReadOnlyTransaction delegateReadTx,
+ ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx,
@Nonnull final ValidableTransaction delegateWriteTx) {
this.delegateReadTx = Preconditions.checkNotNull(delegateReadTx, "delegateReadTx should not be null");
this.delegateWriteTx = Preconditions.checkNotNull(delegateWriteTx, "delegateWriteTx should not be null");
delegateWriteTx.delete(store, path);
}
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- //TODO - remove after https://bugs.opendaylight.org/show_bug.cgi?id=7791 resolved
- if (LOG.isDebugEnabled()) {
- LOG.debug("Submitting transaction {}", ReflectionToStringBuilder.toString(
- delegateWriteTx,
- RecursiveToStringStyle.MULTI_LINE_STYLE,
- false,
- false
- ));
- }
- return delegateWriteTx.submit();
- }
-
@Override
public FluentFuture<? extends CommitInfo> commit() {
return delegateWriteTx.commit();
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
- final YangInstanceIdentifier path) {
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
return delegateReadTx.read(store, path);
}
@Override
- public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
- final YangInstanceIdentifier path) {
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
return delegateReadTx.exists(store, path);
}
}
@Override
- public CheckedFuture<Void, DOMDataTransactionValidator.ValidationFailedException> validate() {
+ public FluentFuture<Void> validate() {
return delegateWriteTx.validate();
}
}
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Collections2;
import com.google.common.collect.Multimap;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.data.ReadableDataManager;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.util.TransactionMappingContext;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
private final BindingNormalizedNodeSerializer serializer;
private final ReaderRegistry readerRegistry;
private final SchemaContext globalContext;
- private final org.opendaylight.controller.md.sal.binding.api.DataBroker contextBroker;
+ private final org.opendaylight.mdsal.binding.api.DataBroker contextBroker;
/**
* Creates operational data tree instance.
public ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer,
@Nonnull final SchemaContext globalContext,
@Nonnull final ReaderRegistry readerRegistry,
- @Nonnull final org.opendaylight.controller.md.sal.binding.api.DataBroker contextBroker) {
+ @Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker) {
this.contextBroker = checkNotNull(contextBroker, "contextBroker should not be null");
this.globalContext = checkNotNull(globalContext, "globalContext should not be null");
this.serializer = checkNotNull(serializer, "serializer should not be null");
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>,
- org.opendaylight.controller.md.sal.common.api.data.ReadFailedException> read(
+ public FluentFuture<Optional<NormalizedNode<?, ?>>> read(
@Nonnull final YangInstanceIdentifier yangInstanceIdentifier) {
- try (TransactionMappingContext mappingContext = new TransactionMappingContext(contextBroker.newReadWriteTransaction());
- ReadContext ctx = new ReadContextImpl(mappingContext)) {
+ try (TransactionMappingContext mappingContext = new TransactionMappingContext(
+ contextBroker.newReadWriteTransaction());
+ ReadContext ctx = new ReadContextImpl(mappingContext)) {
final Optional<NormalizedNode<?, ?>> value;
if (checkNotNull(yangInstanceIdentifier).equals(YangInstanceIdentifier.EMPTY)) {
}
// Submit context mapping updates
- final CheckedFuture<Void, TransactionCommitFailedException> contextUpdateResult =
- ((TransactionMappingContext) ctx.getMappingContext()).submit();
+ final FluentFuture<? extends CommitInfo> contextUpdateResult =
+ ((TransactionMappingContext) ctx.getMappingContext()).commit();
// Blocking on context data update
- contextUpdateResult.checkedGet();
-
- return Futures.immediateCheckedFuture(value);
-
- } catch (ReadFailedException e) {
- return Futures.immediateFailedCheckedFuture(
- new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data", e));
- } catch (TransactionCommitFailedException e) {
- // Context write failed. This should not happen, but if it does, there's not much that can be done here
- // ... try to read again
- final String msg = "Error while updating mapping context data";
- LOG.error(msg, e);
- return Futures.immediateFailedCheckedFuture(
- new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException(msg, e)
- );
+ contextUpdateResult.get();
+
+ return FluentFutures.immediateFluentFuture(value);
+
+ } catch (InterruptedException | ExecutionException | ReadFailedException ex) {
+ return FluentFutures.immediateFailedFluentFuture(
+ new org.opendaylight.controller.md.sal.common.api.data.ReadFailedException("Failed to read data",
+ ex));
}
}
if (dataObject.isPresent()) {
final NormalizedNode<?, ?> value = toNormalizedNodeFunction(path).apply(dataObject.get());
- return Optional.<NormalizedNode<?, ?>>fromNullable(value);
+ return Optional.ofNullable(value);
} else {
- return Optional.absent();
+ return Optional.empty();
}
}
package io.fd.honeycomb.data.impl;
import com.google.common.annotations.Beta;
-import com.google.common.util.concurrent.CheckedFuture;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import com.google.common.util.concurrent.FluentFuture;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator;
-import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator.ValidationFailedException;
/**
- * An {@link DOMDataWriteTransaction} than can be validated.
+ * An {@link DOMDataTreeWriteTransaction} than can be validated.
* @see DOMDataTransactionValidator
*/
@Beta
-interface ValidableTransaction extends DOMDataWriteTransaction {
+interface ValidableTransaction extends DOMDataTreeWriteTransaction {
/**
- * Validates state of the data tree associated with the provided {@link DOMDataWriteTransaction}.
+ * Validates state of the data tree associated with the provided {@link DOMDataTreeWriteTransaction}.
*
* <p>The operation should not have any side-effects on the transaction state.
*
* if the state of the transaction has not been changed.
*
* @return
- * a CheckedFuture containing the result of the validate operation. The future blocks until the validation
- * operation is complete. A successful validate returns nothing. On failure, the Future will fail
- * with a {@link ValidationFailedException} or an exception derived from ValidationFailedException.
+ * a FluentFuture containing the result of the validate operation. The future blocks until the validation
+ * operation is complete. A successful validate returns nothing. On failure, the Future will fail.
*/
- CheckedFuture<Void, ValidationFailedException> validate();
+ FluentFuture<Void> validate();
}
import static java.util.Objects.requireNonNull;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.data.DataModification;
import javax.annotation.Nullable;
import javax.annotation.concurrent.NotThreadSafe;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator;
import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
handleOperation(store, (modification) -> modification.delete(path));
}
- @Deprecated
- @Override
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- LOG.trace("WriteTransaction.submit()");
- checkIsNew();
-
- try {
- doCommit();
- } catch (Exception e) {
- status = TransactionStatus.FAILED;
- LOG.error("Submit failed", e);
- return Futures.immediateFailedCheckedFuture(
- new TransactionCommitFailedException("Failed to validate DataTreeModification", e));
- }
- return Futures.immediateCheckedFuture(null);
- }
-
private void doCommit() throws TranslationException {
status = TransactionStatus.SUBMITED;
if (configModification != null) {
}
@Override
- public CheckedFuture<Void, DOMDataTransactionValidator.ValidationFailedException> validate() {
+ public FluentFuture<Void> validate() {
try {
if (configModification != null) {
configModification.validate();
operationalModification.validate();
}
} catch (Exception e) {
- return Futures.immediateFailedCheckedFuture(new DOMDataTransactionValidator.ValidationFailedException(e.getMessage(), e.getCause()));
+ return FluentFutures.immediateFailedFluentFuture(
+ new DOMDataTransactionValidator.ValidationFailedException(e.getMessage(), e.getCause()));
}
- return Futures.immediateCheckedFuture(null);
+ return FluentFutures.immediateNullFluentFuture();
}
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
+import com.google.common.collect.ClassToInstanceMap;
import io.fd.honeycomb.data.DataModification;
import io.fd.honeycomb.data.ModifiableDataManager;
import io.fd.honeycomb.data.ReadableDataManager;
-import java.util.Map;
+import org.eclipse.jdt.annotation.NonNull;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.netconf.mdsal.connector.DOMDataTransactionValidator;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@Test
public void testNewReadWriteTransaction() {
- final DOMDataReadWriteTransaction readWriteTx = broker.newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction readWriteTx = broker.newReadWriteTransaction();
final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
readWriteTx.read(LogicalDatastoreType.CONFIGURATION, path);
@Test
public void testNewReadOnlyTransaction() {
- final DOMDataReadOnlyTransaction readTx = broker.newReadOnlyTransaction();
+ final DOMDataTreeReadTransaction readTx = broker.newReadOnlyTransaction();
final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
readTx.read(LogicalDatastoreType.CONFIGURATION, path);
@Test(expected = UnsupportedOperationException.class)
public void testCreateTransactionChain() {
- final TransactionChainListener listener = mock(TransactionChainListener.class);
+ final DOMTransactionChainListener listener = mock(DOMTransactionChainListener.class);
broker.createTransactionChain(listener);
}
@Test
public void testGetSupportedExtensions() {
- final Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> supportedExtensions =
- broker.getSupportedExtensions();
+ final @NonNull ClassToInstanceMap<DOMDataBrokerExtension> supportedExtensions =
+ broker.getExtensions();
assertEquals(1, supportedExtensions.size());
assertNotNull(supportedExtensions.get(DOMDataTransactionValidator.class));
}
@Test
public void testNewReadWriteTransaction() {
- final DOMDataReadWriteTransaction readWriteTx = broker.newReadWriteTransaction();
+ final DOMDataTreeReadWriteTransaction readWriteTx = broker.newReadWriteTransaction();
final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
readWriteTx.read(LogicalDatastoreType.OPERATIONAL, path);
@Test
public void testNewReadOnlyTransaction() {
- final DOMDataReadOnlyTransaction readTx = broker.newReadOnlyTransaction();
+ final DOMDataTreeReadTransaction readTx = broker.newReadOnlyTransaction();
final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
readTx.read(LogicalDatastoreType.OPERATIONAL, path);
@Test(expected = IllegalArgumentException.class)
public void testReadConfig() {
- final DOMDataReadOnlyTransaction readTx = broker.newReadOnlyTransaction();
+ final DOMDataTreeReadTransaction readTx = broker.newReadOnlyTransaction();
final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
readTx.read(LogicalDatastoreType.CONFIGURATION, path);
@Test(expected = UnsupportedOperationException.class)
public void testCreateTransactionChain() {
- final TransactionChainListener listener = mock(TransactionChainListener.class);
+ final DOMTransactionChainListener listener = mock(DOMTransactionChainListener.class);
broker.createTransactionChain(listener);
}
@Test
public void testGetSupportedExtensions() {
- final Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> supportedExtensions =
- broker.getSupportedExtensions();
+ final @NonNull ClassToInstanceMap<DOMDataBrokerExtension> supportedExtensions = broker.getExtensions();
assertTrue(supportedExtensions.isEmpty());
}
}
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.translate.write.DataObjectUpdate;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.registry.WriterRegistry;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
@Mock
DataBroker contextBroker;
@Mock
- org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction tx;
+ org.opendaylight.mdsal.binding.api.ReadWriteTransaction tx;
@Captor
ArgumentCaptor<WriteContext> writeContextCaptor;
MockitoAnnotations.initMocks(this);
dataTree = getDataTree();
when(contextBroker.newReadWriteTransaction()).thenReturn(tx);
- when(tx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ when(tx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
when(serializer.fromYangInstanceIdentifier(any(YangInstanceIdentifier.class)))
.thenReturn(((InstanceIdentifier) DEFAULT_ID));
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.Multimap;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.data.DataModification;
import io.fd.honeycomb.translate.write.DataObjectUpdate;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.registry.WriterRegistry;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public void testRead() throws Exception {
final ContainerNode topContainer = getTopContainer("topContainer");
addNodeToTree(dataTree, topContainer, TOP_CONTAINER_ID);
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read =
+ final FluentFuture<Optional<NormalizedNode<?, ?>>> read =
configDataTree.read(TOP_CONTAINER_ID);
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read2 =
+ final FluentFuture<Optional<NormalizedNode<?, ?>>> read2 =
configDataTree.newModification().read(TOP_CONTAINER_ID);
final Optional<NormalizedNode<?, ?>> normalizedNodeOptional = read.get();
final Optional<NormalizedNode<?, ?>> normalizedNodeOptional2 = read2.get();
assertEquals(normalizedNodeOptional, normalizedNodeOptional2);
assertTrue(normalizedNodeOptional.isPresent());
assertEquals(topContainer, normalizedNodeOptional.get());
- assertEquals(dataTree.takeSnapshot().readNode(TOP_CONTAINER_ID), Optional.toJavaUtil(normalizedNodeOptional));
+ assertEquals(dataTree.takeSnapshot().readNode(TOP_CONTAINER_ID), normalizedNodeOptional);
}
@Test
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import io.fd.honeycomb.data.ReadableDataManager;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.data.DataModification;
+import io.fd.honeycomb.data.ReadableDataManager;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@Test
public void testExists() {
final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException>
- future = mock(CheckedFuture.class);
+ final FluentFuture<Optional<NormalizedNode<?, ?>>> future = mock(FluentFuture.class);
when(operationalData.read(path)).thenReturn(future);
readOnlyTx.exists(LogicalDatastoreType.OPERATIONAL, path);
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public class ReadWriteTransactionTest {
@Mock
- private DOMDataReadOnlyTransaction readTx;
+ private DOMDataTreeReadTransaction readTx;
@Mock
private ValidableTransaction writeTx;
}
@Test
- public void testSubmit() throws Exception {
- readWriteTx.submit();
- verify(writeTx).submit();
- }
-
-
- @SuppressWarnings("deprecation")
- @Test
- public void testCommit() throws Exception {
+ public void testCommit() {
readWriteTx.commit();
verify(writeTx).commit();
}
}
@Test
- public void testGetIdentifier() throws Exception {
+ public void testGetIdentifier() {
assertNotNull(readWriteTx.getIdentifier());
}
}
\ No newline at end of file
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterables;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.yangtools.util.UnmodifiableCollection;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
@Mock
private DOMDataBroker netconfMonitoringBroker;
@Mock
- private DOMDataReadOnlyTransaction domDataReadOnlyTransaction;
+ private DOMDataTreeReadTransaction domDataReadOnlyTransaction;
@Mock
private DataBroker contextBroker;
public void setUp() {
initMocks(this);
operationalData = new ReadableDataTreeDelegator(serializer, globalContext, reader, contextBroker);
- doReturn(schemaNode).when(globalContext).getDataChildByName(any(QName.class));
+ doReturn(Optional.of(schemaNode)).when(globalContext).findDataChildByName(any(QName.class));
doReturn(domDataReadOnlyTransaction).when(netconfMonitoringBroker).newReadOnlyTransaction();
- doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(domDataReadOnlyTransaction)
+ doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(domDataReadOnlyTransaction)
.read(any(LogicalDatastoreType.class), any(YangInstanceIdentifier.class));
- final org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction ctxTransaction = mock(
- org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction.class);
+ final org.opendaylight.mdsal.binding.api.ReadWriteTransaction ctxTransaction = mock(
+ org.opendaylight.mdsal.binding.api.ReadWriteTransaction.class);
doReturn(ctxTransaction).when(contextBroker).newReadWriteTransaction();
- doReturn(Futures.immediateCheckedFuture(null)).when(ctxTransaction).submit();
+ doReturn(FluentFutures.immediateNullFluentFuture()).when(ctxTransaction).commit();
}
@Test
final DataContainerChild<?, ?> expectedValue = mock(DataContainerChild.class);
doReturn(expectedValue).when(entry).getValue();
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future = operationalData.read(yangId);
+ final FluentFuture<Optional<NormalizedNode<?, ?>>> future = operationalData.read(yangId);
verify(serializer).fromYangInstanceIdentifier(yangId);
verify(reader).read(same(id), any(ReadContext.class));
public void testReadNonExistingNode() throws Exception {
final YangInstanceIdentifier yangId = mock(YangInstanceIdentifier.class);
doReturn(id).when(serializer).fromYangInstanceIdentifier(yangId);
- doReturn(Optional.absent()).when(reader).read(same(id), any(ReadContext.class));
+ doReturn(Optional.empty()).when(reader).read(same(id), any(ReadContext.class));
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future = operationalData.read(yangId);
+ final FluentFuture<Optional<NormalizedNode<?, ?>>> future = operationalData.read(yangId);
verify(serializer).fromYangInstanceIdentifier(yangId);
verify(reader).read(same(id), any(ReadContext.class));
public void testReadFailed() throws Exception {
doThrow(io.fd.honeycomb.translate.read.ReadFailedException.class).when(reader).readAll(any(ReadContext.class));
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future =
- operationalData.read( YangInstanceIdentifier.EMPTY);
+ final FluentFuture<Optional<NormalizedNode<?, ?>>> future = operationalData.read(YangInstanceIdentifier.EMPTY);
try {
- future.checkedGet();
- } catch (ReadFailedException e) {
- assertTrue(e.getCause() instanceof io.fd.honeycomb.translate.read.ReadFailedException);
+ future.get();
+ } catch (ExecutionException e) {
+ assertTrue(e.getCause() instanceof ReadFailedException);
return;
}
fail("ReadFailedException was expected");
doReturn(vppYangId.getLastPathArgument()).when(vppStateContainer).getIdentifier();
// Read root
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future =
+ final FluentFuture<Optional<NormalizedNode<?, ?>>> future =
operationalData.read(YangInstanceIdentifier.EMPTY);
verify(reader).readAll(any(ReadContext.class));
import static org.mockito.Mockito.verify;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.data.DataModification;
import io.fd.honeycomb.translate.TranslationException;
import io.fd.honeycomb.translate.ValidationFailedException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@Test(expected = IllegalStateException.class)
public void testOnFinishedTx() {
- writeTx.submit();
+ writeTx.commit();
writeTx.put(LogicalDatastoreType.CONFIGURATION, path, data);
verify(configSnapshot).write(path, data);
}
@Test
public void testCancelFinished() {
- writeTx.submit();
+ writeTx.commit();
assertFalse(writeTx.cancel());
}
@Test
public void testSubmit() throws Exception {
- writeTx.submit();
+ writeTx.commit();
verify(configSnapshot).commit();
}
@Test
public void testSubmitFailed() throws Exception {
doThrow(mock(ValidationFailedException.class)).when(configSnapshot).commit();
- final CheckedFuture<Void, TransactionCommitFailedException> future = writeTx.submit();
+ final FluentFuture<? extends CommitInfo> future = writeTx.commit();
try {
future.get();
} catch (Exception e) {
package io.fd.honeycomb.impl;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.mdsal.dom.api.DOMMountPointListener;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class EmptyDomMountService implements DOMMountPointService {
@Override
public Optional<DOMMountPoint> getMountPoint(final YangInstanceIdentifier yangInstanceIdentifier) {
- return Optional.absent();
+ return Optional.empty();
}
@Override
package io.fd.honeycomb.impl;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer;
import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
import org.opendaylight.controller.sal.binding.api.BindingAwareService;
import org.opendaylight.controller.sal.binding.api.rpc.RpcContextIdentifier;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.ContainerWithList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.SimpleContainer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.container.with.list.ListInContainer;
package io.fd.honeycomb.benchmark.data;
-import com.google.inject.*;
import com.google.inject.multibindings.Multibinder;
import com.google.inject.name.Names;
import io.fd.honeycomb.benchmark.util.DataProvider;
import io.fd.honeycomb.translate.read.Reader;
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import java.io.IOException;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.ContainerWithList;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.ContainerWithListBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.SimpleContainer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.io.IOException;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.ExecutionException;
-import java.util.stream.Collectors;
-
/**
* Measures the performance of CONFIG writes into BA DataBroker, backed by HC infrastructure and then NOOP writers.
*/
package io.fd.honeycomb.benchmark.util;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
package io.fd.honeycomb.benchmark.util;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.read.Reader;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.concepts.Builder;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
-import com.google.common.util.concurrent.Futures;
import java.util.Arrays;
import java.util.Map;
import javassist.ClassPool;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.binding.dom.codec.gen.impl.DataObjectSerializerGenerator;
import org.opendaylight.mdsal.binding.dom.codec.gen.impl.StreamWriterGenerator;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.generator.util.JavassistUtils;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
protected SchemaContext schemaContext;
@Mock
- protected org.opendaylight.controller.md.sal.binding.api.DataBroker contextBroker;
+ protected org.opendaylight.mdsal.binding.api.DataBroker contextBroker;
@Mock
- private org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction ctxTx;
+ private org.opendaylight.mdsal.binding.api.ReadWriteTransaction ctxTx;
static BindingToNormalizedNodeCodec getSerializer(final ModuleInfoBackedContext moduleInfoBackedContext,
final SchemaContext schemaContext) {
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
when(contextBroker.newReadWriteTransaction()).thenReturn(ctxTx);
- when(ctxTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ when(ctxTx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
initSerializer();
postSetup();
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.test.model.Ids;
import io.fd.honeycomb.translate.impl.read.GenericListReader;
import io.fd.honeycomb.translate.impl.read.GenericReader;
import io.fd.honeycomb.translate.util.read.ReflexiveReaderCustomizer;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.junit.Test;
public void testReadAll() throws Exception {
final ReadableDataTreeDelegator readableDataTreeDelegator =
new ReadableDataTreeDelegator(serializer, schemaContext, registry, contextBroker);
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, org.opendaylight.controller.md.sal.common.api.data.ReadFailedException>
+ final FluentFuture<Optional<NormalizedNode<?, ?>>>
read = readableDataTreeDelegator.read(YangInstanceIdentifier.EMPTY);
final Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll =
- toBinding(read.checkedGet().get());
+ toBinding(read.get().get());
assertThat(readAll.size(), is(2));
assertTrue(readAll.containsKey(Ids.CONTAINER_WITH_LIST_ID));
assertEquals(readContainerWithList(), readAll.get(Ids.CONTAINER_WITH_LIST_ID).stream().findFirst().get());
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.test.model.Ids;
import io.fd.honeycomb.translate.impl.read.GenericListReader;
import io.fd.honeycomb.translate.impl.read.registry.CompositeReaderRegistryBuilder;
import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
import io.fd.honeycomb.translate.util.YangDAG;
import io.fd.honeycomb.translate.util.read.ReflexiveListReaderCustomizer;
+import java.util.Optional;
import java.util.stream.Collectors;
import org.junit.Test;
import org.mockito.Mock;
public void testReadAll() throws Exception {
final ReadableDataTreeDelegator readableDataTreeDelegator =
new ReadableDataTreeDelegator(serializer, schemaContext, registry, contextBroker);
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, org.opendaylight.controller.md.sal.common.api.data.ReadFailedException>
+ final FluentFuture<Optional<NormalizedNode<?, ?>>>
read = readableDataTreeDelegator.read(YangInstanceIdentifier.EMPTY);
final Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll =
- toBinding(read.checkedGet().get());
+ toBinding(read.get().get());
assertThat(readAll.size(), is(1));
assertEquals(readEntireSubtree(), readAll.get(Ids.CONTAINER_WITH_LIST_ID).stream().findFirst().get());
}
<artifactId>commons-io</artifactId>
<version>${commons-io.version}</version>
</dependency>
+ <dependency>
+ <groupId>javax.activation</groupId>
+ <artifactId>activation</artifactId>
+ <version>1.1.1</version>
+ </dependency>
</dependencies>
</project>
\ No newline at end of file
import com.google.inject.Inject;
import io.fd.honeycomb.binding.init.ProviderTrait;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.impl.BindingDOMDataBrokerAdapter;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMDataBrokerAdapter;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
public final class BindingDataBrokerProvider extends ProviderTrait<DataBroker> {
import io.fd.honeycomb.rpc.RpcRegistryBuilder;
import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
import io.fd.honeycomb.translate.write.registry.WriterRegistry;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
public class ConfigAndOperationalPipelineModule extends PrivateModule {
import com.google.inject.Inject;
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.infra.distro.cfgattrs.HoneycombConfiguration;
-import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter;
+import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
public final class DOMNotificationServiceProvider extends ProviderTrait<DOMNotificationRouter> {
import com.google.inject.Inject;
import io.fd.honeycomb.binding.init.ProviderTrait;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStoreFactory;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStore;
+import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStoreConfigProperties;
+import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStoreFactory;
public final class DataStoreProvider extends ProviderTrait<InMemoryDOMDataStore> {
@Inject
private DOMSchemaService schemaService;
private String name;
- private LogicalDatastoreType type;
- public DataStoreProvider(final String name,
- final LogicalDatastoreType type) {
+ public DataStoreProvider(final String name) {
this.name = name;
- this.type = type;
}
@Override
protected InMemoryDOMDataStore create() {
- return InMemoryDOMDataStoreFactory.create(name, type, schemaService, false, null);
+ return InMemoryDOMDataStoreFactory
+ .create(name, InMemoryDOMDataStoreConfigProperties.getDefault(), schemaService);
}
}
import com.google.inject.Inject;
import com.google.inject.name.Named;
import io.fd.honeycomb.binding.init.ProviderTrait;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.impl.BindingDOMDataBrokerAdapter;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMDataBrokerAdapter;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
/**
* Provides binding adapter for {@link io.fd.honeycomb.data.impl.DataBroker}.
@Override
protected BindingDOMDataBrokerAdapter create() {
-
return new BindingDOMDataBrokerAdapter(domDataBroker, mappingService);
}
}
import io.fd.honeycomb.data.ModifiableDataManager;
import io.fd.honeycomb.data.ReadableDataManager;
import io.fd.honeycomb.data.impl.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
public final class HoneycombDOMDataBrokerProvider extends ProviderTrait<DOMDataBroker> {
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.rpc.HoneycombDOMRpcService;
import io.fd.honeycomb.rpc.RpcRegistry;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
public final class HoneycombDOMRpcServiceProvider extends ProviderTrait<DOMRpcService> {
import io.fd.honeycomb.notification.impl.NotificationProducerTracker;
import java.util.HashSet;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.impl.BindingDOMNotificationPublishServiceAdapter;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
-import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMNotificationPublishServiceAdapter;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
public final class HoneycombNotificationManagerProvider extends ProviderTrait<NotificationCollector> {
// Create BA version of notification service (implementation is free from ODL)
BindingDOMNotificationPublishServiceAdapter bindingDOMNotificationPublishServiceAdapter =
- new BindingDOMNotificationPublishServiceAdapter(codec, notificationRouter);
+ new BindingDOMNotificationPublishServiceAdapter(notificationRouter, codec);
// Create Collector on top of BA notification service and registry
HoneycombNotificationCollector honeycombNotificationCollector =
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitDeadlockException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.broker.impl.SerializedDOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
-import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitDeadlockException;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.broker.SerializedDOMDataBroker;
+import org.opendaylight.mdsal.dom.spi.store.DOMStore;
+import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStore;
import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService;
import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
--- /dev/null
+/*
+ * Copyright (c) 2019 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.infra.distro.data;
+
+import com.google.inject.Inject;
+import io.fd.honeycomb.binding.init.ProviderTrait;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.impl.BindingDOMDataBrokerAdapter;
+import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.controller.sal.core.compat.LegacyDOMDataBrokerAdapter;
+import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+
+/**
+ * Provider for legacy {@linkDataBroker} used in BGP Module.
+ */
+public class LegacyBindingDataBrokerProvider extends ProviderTrait<DataBroker> {
+ @Inject
+ private DOMDataBroker domDataBroker;
+ @Inject
+ private BindingToNormalizedNodeCodec mappingService;
+ @Inject
+ private ModuleInfoBackedContext mibCtx;
+
+ @Override
+ protected BindingDOMDataBrokerAdapter create() {
+ return new BindingDOMDataBrokerAdapter(new LegacyDOMDataBrokerAdapter(domDataBroker), mappingService);
+ }
+
+}
import io.fd.honeycomb.data.impl.ModifiableDataTreeDelegator;
import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule;
import io.fd.honeycomb.translate.write.registry.WriterRegistry;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import io.fd.honeycomb.data.init.RestoringInitializer;
import io.fd.honeycomb.infra.distro.cfgattrs.HoneycombConfiguration;
import java.nio.file.Paths;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
final class PersistedConfigInitializerProvider extends ProviderTrait<RestoringInitializer> {
import io.fd.honeycomb.infra.distro.data.DataTreeProvider;
import io.fd.honeycomb.infra.distro.data.PersistingDataTreeProvider;
import io.fd.honeycomb.translate.MappingContext;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
public class ContextPipelineModule extends PrivateModule {
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.data.ModifiableDataManager;
import io.fd.honeycomb.data.impl.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
public final class HoneycombContextDOMDataBrokerProvider extends ProviderTrait<DOMDataBroker> {
import io.fd.honeycomb.data.init.RestoringInitializer;
import io.fd.honeycomb.infra.distro.cfgattrs.HoneycombConfiguration;
import java.nio.file.Paths;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
final class PersistedContextInitializerProvider extends ProviderTrait<RestoringInitializer> {
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.util.RealtimeMappingContext;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public final class RealtimeMappingContextProvider extends ProviderTrait<MappingContext> {
import io.fd.honeycomb.data.impl.ReadableDataTreeDelegator;
import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule;
import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
public final class ReadableDTDelegProvider extends ProviderTrait<ReadableDataManager> {
@Override
protected ReadableDataTreeDelegator create() {
- return new ReadableDataTreeDelegator(serializer, schemaService.getGlobalContext(),
- registry, contextBroker);
+ return new ReadableDataTreeDelegator(serializer, schemaService.getGlobalContext(), registry, contextBroker);
}
}
import io.fd.honeycomb.data.init.InitializerRegistry;
import io.fd.honeycomb.infra.distro.data.BindingDataBrokerProvider;
import io.fd.honeycomb.infra.distro.data.HoneycombDOMDataBrokerProvider;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
public final class InitializerPipelineModule extends PrivateModule {
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.registry.InitRegistry;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.fd.honeycomb.data.init.InitializerRegistry;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.read.registry.ReaderRegistry;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public final class InitializerRegistryAdapterProvider extends ProviderTrait<InitializerRegistry> {
import io.fd.honeycomb.infra.distro.data.ConfigAndOperationalPipelineModule;
import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule;
import io.fd.honeycomb.translate.util.write.NoopWriterRegistry;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
--- /dev/null
+/*
+ * Copyright (c) 2019 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.infra.distro.schema;
+
+import com.google.inject.Inject;
+import io.fd.honeycomb.binding.init.ProviderTrait;
+import javassist.ClassPool;
+import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.codec.gen.impl.DataObjectSerializerGenerator;
+import org.opendaylight.mdsal.binding.dom.codec.gen.impl.StreamWriterGenerator;
+import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
+import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
+import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.generator.util.JavassistUtils;
+
+public class LegacySerializerProvider extends ProviderTrait<BindingToNormalizedNodeCodec> {
+
+ @Inject
+ private ModuleInfoBackedContext mibCtx;
+
+ @Override
+ protected BindingToNormalizedNodeCodec create() {
+ final DataObjectSerializerGenerator serializerGenerator =
+ StreamWriterGenerator.create(JavassistUtils.forClassPool(ClassPool.getDefault()));
+
+ BindingNormalizedNodeCodecRegistry codecRegistry = new BindingNormalizedNodeCodecRegistry(serializerGenerator);
+ BindingRuntimeContext ctx = BindingRuntimeContext.create(mibCtx, mibCtx.getSchemaContext());
+ codecRegistry.onBindingRuntimeContextUpdated(ctx);
+ BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(mibCtx, codecRegistry);
+ codec.onGlobalContextUpdated(mibCtx.getSchemaContext());
+ return codec;
+ }
+}
import com.google.inject.AbstractModule;
import com.google.inject.Singleton;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
bind(ModuleInfoBackedContext.class).toProvider(ModuleInfoBackedCtxProvider.class).in(Singleton.class);
bind(DOMSchemaService.class).toProvider(SchemaServiceProvider.class).in(Singleton.class);
bind(BindingToNormalizedNodeCodec.class).toProvider(SerializerProvider.class).in(Singleton.class);
+ bind(org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec.class)
+ .toProvider(LegacySerializerProvider.class).in(Singleton.class);
}
}
import com.google.inject.Inject;
import io.fd.honeycomb.binding.init.ProviderTrait;
import javassist.ClassPool;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.dom.codec.gen.impl.DataObjectSerializerGenerator;
import org.opendaylight.mdsal.binding.dom.codec.gen.impl.StreamWriterGenerator;
import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
import com.google.inject.Inject;
import com.google.inject.name.Named;
-import io.fd.honeycomb.translate.util.write.BindingBrokerWriter;
+import io.fd.honeycomb.translate.util.write.LegacyBindingBrokerWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
import javax.annotation.Nonnull;
@Override
public void init(@Nonnull ModifiableWriterRegistryBuilder registry) {
- registry.wildcardedSubtreeAdd(new BindingBrokerWriter<>(EVPN_ROUTES_IID, dataBroker));
+ registry.wildcardedSubtreeAdd(new LegacyBindingBrokerWriter<>(EVPN_ROUTES_IID, dataBroker));
}
}
@Override
protected BGPTableTypeRegistryConsumer create() {
final SimpleBGPTableTypeRegistryProvider registry = new SimpleBGPTableTypeRegistryProvider();
- tableTypes.stream().forEach(tableType -> tableType.register(registry));
+ tableTypes.forEach(tableType -> tableType.register(registry));
return registry;
}
import com.google.inject.Inject;
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.data.init.ShutdownHandler;
+import java.util.ArrayList;
+import java.util.Set;
import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
-
-import org.opendaylight.protocol.bgp.rib.spi.*;
+import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
+import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionProviderActivator;
+import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionProviderContext;
+import org.opendaylight.protocol.bgp.rib.spi.SimpleRIBExtensionProviderContext;
+import org.opendaylight.protocol.bgp.rib.spi.SimpleRIBExtensionProviderContextActivator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.ArrayList;
-import java.util.Set;
-
public class RIBExtensionConsumerContextProvider extends ProviderTrait<RIBExtensionConsumerContext> {
private static final Logger LOG = LoggerFactory.getLogger(RIBExtensionConsumerContextProvider.class);
@Inject
package io.fd.honeycomb.northbound.bgp.extension;
+import static io.fd.honeycomb.northbound.bgp.extension.AbstractBgpExtensionModule.TABLES_IID;
+
import com.google.inject.Inject;
import com.google.inject.name.Named;
-import io.fd.honeycomb.translate.util.write.BindingBrokerWriter;
+import io.fd.honeycomb.translate.util.write.LegacyBindingBrokerWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
+import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv4.routes.Ipv4Routes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.inet.rev180329.ipv6.routes.Ipv6Routes;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import javax.annotation.Nonnull;
-
-import static io.fd.honeycomb.northbound.bgp.extension.AbstractBgpExtensionModule.TABLES_IID;
-
public class InetWriterFactory implements WriterFactory {
private static final InstanceIdentifier<Ipv4Routes> IPV4_ROUTES_IID = TABLES_IID.child((Class) Ipv4Routes.class);
@Override
public void init(@Nonnull ModifiableWriterRegistryBuilder registry) {
- registry.wildcardedSubtreeAdd(new BindingBrokerWriter<>(IPV4_ROUTES_IID, dataBroker));
- registry.wildcardedSubtreeAdd(new BindingBrokerWriter<>(IPV6_ROUTES_IID, dataBroker));
+ registry.wildcardedSubtreeAdd(new LegacyBindingBrokerWriter<>(IPV4_ROUTES_IID, dataBroker));
+ registry.wildcardedSubtreeAdd(new LegacyBindingBrokerWriter<>(IPV6_ROUTES_IID, dataBroker));
}
}
import com.google.inject.Inject;
import com.google.inject.name.Named;
-import io.fd.honeycomb.translate.util.write.BindingBrokerWriter;
+import io.fd.honeycomb.translate.util.write.LegacyBindingBrokerWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
import javax.annotation.Nonnull;
@Override
public void init(@Nonnull ModifiableWriterRegistryBuilder registry) {
- registry.wildcardedSubtreeAdd(new BindingBrokerWriter<>(V4_ROUTES_IID, dataBroker));
+ registry.wildcardedSubtreeAdd(new LegacyBindingBrokerWriter<>(V4_ROUTES_IID, dataBroker));
}
}
import com.google.inject.Inject;
import com.google.inject.name.Named;
-import io.fd.honeycomb.translate.util.write.BindingBrokerWriter;
+import io.fd.honeycomb.translate.util.write.LegacyBindingBrokerWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
import javax.annotation.Nonnull;
@Override
public void init(@Nonnull ModifiableWriterRegistryBuilder registry) {
- registry.wildcardedSubtreeAdd(new BindingBrokerWriter<>(V6_ROUTES_IID, dataBroker));
+ registry.wildcardedSubtreeAdd(new LegacyBindingBrokerWriter<>(V6_ROUTES_IID, dataBroker));
}
}
import com.google.inject.Inject;
import com.google.inject.name.Named;
-import io.fd.honeycomb.translate.util.write.BindingBrokerWriter;
+import io.fd.honeycomb.translate.util.write.LegacyBindingBrokerWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
import javax.annotation.Nonnull;
@Override
public void init(@Nonnull ModifiableWriterRegistryBuilder registry) {
- registry.wildcardedSubtreeAdd(new BindingBrokerWriter<>(LABELED_UNICAST_ROUTES_IID, dataBroker));
- registry.wildcardedSubtreeAdd(new BindingBrokerWriter<>(LABELED_UNICAST_V6_ROUTES_IID, dataBroker));
+ registry.wildcardedSubtreeAdd(new LegacyBindingBrokerWriter<>(LABELED_UNICAST_ROUTES_IID, dataBroker));
+ registry.wildcardedSubtreeAdd(new LegacyBindingBrokerWriter<>(LABELED_UNICAST_V6_ROUTES_IID, dataBroker));
}
}
import com.google.inject.Inject;
import com.google.inject.name.Named;
-import io.fd.honeycomb.translate.util.write.BindingBrokerWriter;
+import io.fd.honeycomb.translate.util.write.LegacyBindingBrokerWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
import javax.annotation.Nonnull;
@Override
public void init(@Nonnull ModifiableWriterRegistryBuilder registry) {
- registry.wildcardedSubtreeAdd(new BindingBrokerWriter<>(LINKSTATE_ROUTES_IID, dataBroker));
+ registry.wildcardedSubtreeAdd(new LegacyBindingBrokerWriter<>(LINKSTATE_ROUTES_IID, dataBroker));
}
}
import io.fd.honeycomb.translate.util.write.BindingBrokerWriter;
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.ApplicationRib;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import io.fd.honeycomb.infra.distro.data.BindingDataBrokerProvider;
import io.fd.honeycomb.infra.distro.data.DataStoreProvider;
import io.fd.honeycomb.infra.distro.data.InmemoryDOMDataBrokerProvider;
+import io.fd.honeycomb.infra.distro.data.LegacyBindingDataBrokerProvider;
import io.fd.honeycomb.translate.bgp.RibWriter;
import io.netty.channel.EventLoopGroup;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStore;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
import org.slf4j.Logger;
private void configureRIB() {
// Create inmemory config data store for HONEYCOMB_BGP
bind(InMemoryDOMDataStore.class).annotatedWith(Names.named(CONFIG))
- .toProvider(new DataStoreProvider(CONFIG, LogicalDatastoreType.CONFIGURATION))
+ .toProvider(new DataStoreProvider(CONFIG))
.in(Singleton.class);
// Create inmemory operational data store for HONEYCOMB_BGP
bind(InMemoryDOMDataStore.class).annotatedWith(Names.named(OPERATIONAL))
- .toProvider(new DataStoreProvider(OPERATIONAL, LogicalDatastoreType.OPERATIONAL))
+ .toProvider(new DataStoreProvider(OPERATIONAL))
.in(Singleton.class);
// Wrap datastores as DOMDataBroker
.in(Singleton.class);
expose(DataBroker.class).annotatedWith(Names.named(HONEYCOMB_BGP));
+ bind(org.opendaylight.controller.md.sal.binding.api.DataBroker.class).annotatedWith(Names.named(HONEYCOMB_BGP))
+ .toProvider(LegacyBindingDataBrokerProvider.class)
+ .in(Singleton.class);
+ expose(org.opendaylight.controller.md.sal.binding.api.DataBroker.class)
+ .annotatedWith(Names.named(HONEYCOMB_BGP));
+
// Create RIB instance
bind(RIB.class).toProvider(BgpRIBProvider.class).in(Singleton.class);
expose(RIB.class);
import java.util.stream.Collectors;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.broker.impl.PingPongDataBroker;
+import org.opendaylight.controller.sal.core.compat.LegacyDOMDataBrokerAdapter;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.impl.BGPRibRoutingPolicyFactoryImpl;
import org.opendaylight.protocol.bgp.openconfig.routing.policy.spi.registry.StatementRegistry;
@Override
protected RIB create() {
+
+ LegacyDOMDataBrokerAdapter DomDataBrokerAdapter = new LegacyDOMDataBrokerAdapter(domBroker);
+ DomDataBrokerAdapter.getSupportedExtensions().get(DOMSchemaService.class);
+
Preconditions.checkArgument(policyCfg.getPolicyConfig().isPresent(),
"Bgp policy configuration failed to load. Check bgp-policy.json configuration file.");
final AsNumber asNumber = new AsNumber(cfg.bgpAsNumber.get().longValue());
final ArrayList<AfiSafi> afiSafiList = new ArrayList<>(configuredAfiSafis);
// based on org.opendaylight.protocol.bgp.rib.impl.config.RibImpl.createRib
- final PingPongDataBroker pingPongDataBroker = new PingPongDataBroker(domBroker);
+ final PingPongDataBroker pingPongDataBroker = new PingPongDataBroker(DomDataBrokerAdapter);
final CodecsRegistryImpl codecsRegistry =
CodecsRegistryImpl.create(codec, extensions.getClassLoadingStrategy());
+
final BGPRibRoutingPolicyFactoryImpl bgpRibRoutingPolicyFactory =
new BGPRibRoutingPolicyFactoryImpl(dataBroker, new StatementRegistry());
final BGPRibRoutingPolicy ribPolicies = bgpRibRoutingPolicyFactory
package io.fd.honeycomb.infra.bgp;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
+
import com.google.inject.Inject;
import com.google.inject.name.Named;
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
import io.fd.honeycomb.translate.util.read.BindingBrokerReader;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.BgpRib;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.BgpRibBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public void init(final ModifiableReaderRegistryBuilder registry) {
- registry.add(new BindingBrokerReader<>(InstanceIdentifier.create(BgpRib.class),
- bgpDataBroker, LogicalDatastoreType.OPERATIONAL, BgpRibBuilder.class));
+ registry.add(new BindingBrokerReader<>(InstanceIdentifier.create(BgpRib.class), bgpDataBroker, OPERATIONAL,
+ BgpRibBuilder.class));
}
}
}
import io.fd.honeycomb.translate.write.WriterFactory;
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
import org.opendaylight.protocol.bgp.rib.impl.spi.BGPPeerRegistry;
import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.Protocol;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev180329.NetworkInstanceProtocol;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.osgi.framework.BundleContext;
/**
* Initializes writer for Bgp Neighbors ({@link Neighbor} node) and all its parents required by HC infra.
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.infra.bgp.BgpConfiguration;
when(globalRib.createPeerChain(any())).thenReturn(chain);
when(chain.newWriteOnlyTransaction()).thenReturn(tx);
- when(tx.submit()).thenReturn(mock(CheckedFuture.class));
+ when(tx.commit()).thenReturn(mock(FluentFuture.class));
when(globalRib.getRibSupportContext()).thenReturn(mock(RIBSupportContextRegistry.class));
when(globalRib.getService()).thenReturn(mock(DOMDataTreeChangeService.class));
when(globalRib.getDispatcher()).thenReturn(dispatcher);
</dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
- <artifactId>netconf-ssh</artifactId>
+ <artifactId>mdsal-netconf-ssh</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
-import org.opendaylight.controller.md.sal.dom.api.DOMNotificationListener;
-import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter;
+import org.opendaylight.mdsal.dom.api.DOMNotification;
+import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.notifications.NotificationPublisherRegistration;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.StreamNameType;
import com.google.inject.name.Named;
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.impl.FakeBindingAwareBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
public final class NetconfBindingBrokerProvider extends ProviderTrait<BindingAwareBroker> {
import com.google.inject.Inject;
import com.google.inject.name.Named;
import io.fd.honeycomb.binding.init.ProviderTrait;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
@Override
protected MdsalNetconfOperationServiceFactory create() {
- MdsalNetconfOperationServiceFactory mdsalNetconfOperationServiceFactory =
- new MdsalNetconfOperationServiceFactory(schemaService, netconfOperationServiceFactoryListener,
- domBroker, rpcService);
- return mdsalNetconfOperationServiceFactory;
+ return new MdsalNetconfOperationServiceFactory(schemaService, netconfOperationServiceFactoryListener,
+ domBroker, rpcService);
}
}
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.util.HashedWheelTimer;
import io.netty.util.Timer;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStore;
import org.opendaylight.netconf.api.NetconfServerDispatcher;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
import org.opendaylight.netconf.impl.osgi.AggregatedNetconfOperationServiceFactory;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
+import org.opendaylight.netconf.mdsal.notification.impl.NetconfNotificationManager;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.notifications.NetconfNotificationListener;
import org.opendaylight.netconf.notifications.NetconfNotificationRegistry;
-import org.opendaylight.netconf.notifications.impl.NetconfNotificationManager;
import org.opendaylight.netconf.ssh.NetconfNorthboundSshServer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// Create inmemory data store for HONEYCOMB_NETCONF config metadata
bind(InMemoryDOMDataStore.class).annotatedWith(Names.named(InmemoryDOMDataBrokerProvider.CONFIG))
.toProvider(
- new DataStoreProvider(InmemoryDOMDataBrokerProvider.CONFIG, LogicalDatastoreType.CONFIGURATION))
+ new DataStoreProvider(InmemoryDOMDataBrokerProvider.CONFIG))
.in(Singleton.class);
// Create inmemory data store for HONEYCOMB_NETCONF operational metadata
bind(InMemoryDOMDataStore.class).annotatedWith(Names.named(InmemoryDOMDataBrokerProvider.OPERATIONAL))
- .toProvider(new DataStoreProvider(InmemoryDOMDataBrokerProvider.OPERATIONAL,
- LogicalDatastoreType.OPERATIONAL))
+ .toProvider(new DataStoreProvider(InmemoryDOMDataBrokerProvider.OPERATIONAL
+ ))
.in(Singleton.class);
// Wrap datastores as DOMDataBroker
bind(DOMDataBroker.class).toProvider(InmemoryDOMDataBrokerProvider.class).in(Singleton.class);
import io.fd.honeycomb.binding.init.ProviderTrait;
import org.opendaylight.controller.config.yang.netconf.mdsal.monitoring.MdsalMonitoringMapperFactory;
import org.opendaylight.controller.config.yang.netconf.mdsal.monitoring.MonitoringToMdsalWriter;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
package io.fd.honeycomb.northbound.netconf;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
+
import com.google.inject.Inject;
import com.google.inject.name.Named;
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
import io.fd.honeycomb.translate.util.read.BindingBrokerReader;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfStateBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public void init(final ModifiableReaderRegistryBuilder registry) {
registry.add(new BindingBrokerReader<>(InstanceIdentifier.create(NetconfState.class),
- netconfMonitoringBindingBrokerDependency,
- LogicalDatastoreType.OPERATIONAL, NetconfStateBuilder.class));
+ netconfMonitoringBindingBrokerDependency, OPERATIONAL, NetconfStateBuilder.class));
}
}
}
import com.google.inject.name.Named;
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.data.init.ShutdownHandler;
-import org.opendaylight.controller.config.yang.netconf.mdsal.notification.CapabilityChangeNotificationProducer;
-import org.opendaylight.controller.config.yang.netconf.mdsal.notification.NotificationToMdsalWriter;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
-import org.opendaylight.netconf.mdsal.notification.NetconfNotificationOperationServiceFactory;
+import org.opendaylight.netconf.mdsal.notification.impl.CapabilityChangeNotificationProducer;
+import org.opendaylight.netconf.mdsal.notification.impl.NetconfNotificationOperationServiceFactory;
+import org.opendaylight.netconf.mdsal.notification.impl.NotificationToMdsalWriter;
import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
import org.opendaylight.netconf.notifications.NetconfNotificationRegistry;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
package io.fd.honeycomb.northbound.netconf;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.OPERATIONAL;
+
import com.google.inject.Inject;
import com.google.inject.name.Named;
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
import io.fd.honeycomb.translate.util.read.BindingBrokerReader;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.Netconf;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.NetconfBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) {
- registry.add(new BindingBrokerReader<>(InstanceIdentifier.create(Netconf.class), netconfDataBroker,
- LogicalDatastoreType.OPERATIONAL, NetconfBuilder.class));
+ registry.add(
+ new BindingBrokerReader<>(InstanceIdentifier.create(Netconf.class), netconfDataBroker, OPERATIONAL,
+ NetconfBuilder.class));
}
}
import org.opendaylight.netconf.api.NetconfServerDispatcher;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
import org.opendaylight.netconf.impl.NetconfServerDispatcherImpl;
+import org.opendaylight.netconf.impl.ServerChannelInitializer;
import org.opendaylight.netconf.impl.SessionIdProvider;
import org.opendaylight.netconf.impl.osgi.AggregatedNetconfOperationServiceFactory;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
NetconfServerSessionNegotiatorFactory serverNegotiatorFactory =
new NetconfServerSessionNegotiatorFactory(timer, netconfOperationProvider, new SessionIdProvider(),
CONNECTION_TIMEOUT_MILLIS, monitoringService);
- NetconfServerDispatcherImpl.ServerChannelInitializer serverChannelInitializer =
- new NetconfServerDispatcherImpl.ServerChannelInitializer(serverNegotiatorFactory);
+ ServerChannelInitializer serverChannelInitializer = new ServerChannelInitializer(serverNegotiatorFactory);
return new NetconfServerDispatcherImpl(serverChannelInitializer, nettyThreadgroup, nettyThreadgroup);
}
import com.google.inject.name.Named;
import io.fd.honeycomb.binding.init.ProviderTrait;
import io.fd.honeycomb.infra.distro.data.ConfigAndOperationalPipelineModule;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter;
+import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.broker.DOMNotificationRouter;
import org.opendaylight.netconf.sal.restconf.impl.BrokerFacade;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
@Override
protected BrokerFacade create() {
- BrokerFacade brokerFacade =
- BrokerFacade.newInstance(rpcService, domDataBroker, notificationService, controllerContext);
- return brokerFacade;
+ return BrokerFacade.newInstance(rpcService, domDataBroker, notificationService, controllerContext);
}
}
import com.google.inject.Inject;
import io.fd.honeycomb.binding.init.ProviderTrait;
-import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import io.fd.honeycomb.notification.NotificationCollector;
import java.util.Collection;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.ThreadSafe;
-import org.opendaylight.controller.md.sal.dom.spi.DOMNotificationSubscriptionListener;
-import org.opendaylight.controller.md.sal.dom.spi.DOMNotificationSubscriptionListenerRegistry;
+import org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListener;
+import org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListenerRegistry;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfSessionStart;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfSessionStartBuilder;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.dom.spi.DOMNotificationSubscriptionListenerRegistry;
+import org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListenerRegistry;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.notifications.rev120206.NetconfSessionStart;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
package io.fd.honeycomb.rpc;
import com.google.common.annotations.Beta;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
@Beta
public class RpcException extends DOMRpcException {
import static net.javacrumbs.futureconverter.java8guava.FutureConverter.toListenableFuture;
-import com.google.common.base.Function;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.CompletableFuture;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
public final class HoneycombDOMRpcService implements DOMRpcService {
- private static final Function<? super Exception, DOMRpcException> ANY_EX_TO_RPC_EXCEPTION_MAPPER =
- e -> (e instanceof DOMRpcException) ? (DOMRpcException) e : new RpcException("RPC failed", e);
-
private final BindingNormalizedNodeSerializer serializer;
private final RpcRegistry rpcRegistry;
@Nonnull
@Override
- public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(@Nonnull final SchemaPath schemaPath,
- @Nullable final NormalizedNode<?, ?> normalizedNode) {
+ public FluentFuture<DOMRpcResult> invokeRpc(@Nonnull final SchemaPath schemaPath,
+ @Nullable final NormalizedNode<?, ?> normalizedNode) {
DataObject input = null;
if (normalizedNode != null) {
// RPC input is optional
}
final CompletableFuture<DataObject> result = rpcRegistry.invoke(schemaPath, input).toCompletableFuture();
final ListenableFuture<DOMRpcResult> output = getDOMRpcResult(toListenableFuture(result));
- return Futures.makeChecked(output, ANY_EX_TO_RPC_EXCEPTION_MAPPER);
+ return FluentFuture.from(output);
}
private ListenableFuture<DOMRpcResult> getDOMRpcResult(final ListenableFuture<DataObject> invoke) {
outputNode = serializer.toNormalizedNodeRpcData(output);
}
return new DefaultDOMRpcResult(outputNode);
- });
+ }, MoreExecutors.directExecutor());
}
@Nonnull
import java.util.concurrent.CompletionStage;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.slf4j.Logger;
import java.net.URI;
import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
assertEquals(outputBi, service.invokeRpc(path, node).get().getResult());
}
- @Test(expected = RpcException.class)
+ @Test(expected = ExecutionException.class)
public void testInvokeRpcFailed() throws Exception {
final CompletableFuture future = new CompletableFuture();
future.completeExceptionally(new RuntimeException());
when(registry.invoke(path, input)).thenReturn(future);
- service.invokeRpc(path, node).checkedGet();
+ service.invokeRpc(path, node).get();
}
private ContainerNode mockContainerNode(final QName nn1) {
import static org.junit.Assert.fail;
import java.net.URI;
-import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
}
@Test
- public void testServiceNotFound() throws ExecutionException, InterruptedException {
+ public void testServiceNotFound() {
final SchemaPath id = SchemaPath.ROOT.createChild(QName.create(namespace, "c"));
final DataObject request = Mockito.mock(DataObject.class);
<artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.apache.commons</groupId>
+ <artifactId>commons-lang3</artifactId>
+ <version>3.8.1</version>
+ </dependency>
</dependencies>
</project>
\ No newline at end of file
package io.fd.honeycomb.test.tools;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-
import javax.annotation.Nonnull;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
abstract class AbstractYangContextHolder {
import java.io.InputStream;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.Statement;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import java.io.InputStream;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import java.lang.reflect.Method;
import javassist.ClassPool;
import org.apache.commons.lang3.reflect.MethodUtils;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.dom.codec.gen.impl.StreamWriterGenerator;
import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import java.util.AbstractMap;
import java.util.Map;
import java.util.Optional;
+import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.generator.impl.BindingSchemaContextUtils;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
return schemaContext;
}
- final com.google.common.base.Optional<InstanceIdentifier<? extends DataObject>> parentInstanceId;
+ final Optional<InstanceIdentifier<? extends DataObject>> parentInstanceId;
try {
parentInstanceId = serializer.toBinding(parentYangId);
} catch (DeserializationException e) {
throw new IllegalStateException(String.format("Unable to resolve %s to instance identifier", parentYangId));
}
- final com.google.common.base.Optional<DataNodeContainer> dataNodeContainerOptional =
+ final Optional<DataNodeContainer> dataNodeContainerOptional =
BindingSchemaContextUtils.findDataNodeContainer(schemaContext, parentInstanceId.get());
if (!dataNodeContainerOptional.isPresent()) {
- throw new IllegalArgumentException(String.format("Error finding DataNodeContainer for %s", parentInstanceId.get()));
+ throw new IllegalArgumentException(
+ String.format("Error finding DataNodeContainer for %s", parentInstanceId.get()));
}
final DataNodeContainer parentNode = dataNodeContainerOptional.get();
}
@Nonnull
- default Map.Entry<InstanceIdentifier<? extends DataObject>, DataObject> nodeBinding(@Nonnull final BindingToNormalizedNodeCodec serializer,
- @Nonnull final YangInstanceIdentifier identifier,
- @Nonnull final NormalizedNode<?, ?> data) {
+ default Map.Entry<InstanceIdentifier<? extends DataObject>, DataObject> nodeBinding(
+ @Nonnull final BindingToNormalizedNodeCodec serializer,
+ @Nonnull final YangInstanceIdentifier identifier,
+ @Nonnull final NormalizedNode<?, ?> data) throws IllegalArgumentException {
try {
return serializer.toBinding(new AbstractMap.SimpleImmutableEntry<>(identifier, data))
- .or(() -> {
- throw new IllegalArgumentException(String.format("Unable to create node binding for %s|%s", identifier, data));
+ .orElseThrow(new Supplier<RuntimeException>() {
+ @Override
+ public RuntimeException get() {
+ throw new IllegalArgumentException(
+ String.format("Unable to create node binding for %s|%s", identifier, data));
+ }
});
} catch (DeserializationException e) {
throw new IllegalArgumentException(String.format("Unable to deserialize node %s|%s", identifier, data), e);
}
@Nonnull
- default InstanceIdentifier<? extends DataObject> identifierBinding(@Nonnull final BindingToNormalizedNodeCodec serializer,
- @Nonnull final YangInstanceIdentifier identifier) {
+ default InstanceIdentifier<? extends DataObject> identifierBinding(
+ @Nonnull final BindingToNormalizedNodeCodec serializer,
+ @Nonnull final YangInstanceIdentifier identifier) throws IllegalArgumentException{
try {
return serializer.toBinding(identifier)
- .or(() -> {
- throw new IllegalArgumentException(String.format("Unable convert %s to binding", identifier));
+ .orElseThrow(new Supplier<RuntimeException>() {
+ @Override
+ public RuntimeException get() {
+ throw new IllegalArgumentException(
+ String.format("Unable convert %s to binding", identifier));
+ }
});
} catch (DeserializationException e) {
throw new IllegalArgumentException(String.format("Unable to deserialize %s", identifier), e);
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
return parameter.getAnnotation(InjectTestData.class).resourcePath();
}
- default YangInstanceIdentifier instanceIdentifier(@Nonnull final AbstractModuleStringInstanceIdentifierCodec parser, @Nonnull final Field field) {
+ default YangInstanceIdentifier instanceIdentifier(@Nonnull final AbstractModuleStringInstanceIdentifierCodec parser,
+ @Nonnull final Field field) {
final String identifier = field.getAnnotation(InjectTestData.class).id();
// == used instead of equals to ensure constant was used
if (NO_ID.equals(identifier)) {
}
}
- default YangInstanceIdentifier instanceIdentifier(@Nonnull final AbstractModuleStringInstanceIdentifierCodec parser, @Nonnull final Parameter parameter) {
+ default YangInstanceIdentifier instanceIdentifier(@Nonnull final AbstractModuleStringInstanceIdentifierCodec parser,
+ @Nonnull final Parameter parameter) {
final String identifier = parameter.getAnnotation(InjectTestData.class).id();
// == used instead of equals to ensure constant was used
if (NO_ID.equals(identifier)) {
import java.lang.reflect.InvocationTargetException;
import java.util.Collections;
import org.junit.Before;
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.data.rev150105.$YangModuleInfoImpl;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
package io.fd.honeycomb.translate;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import com.google.common.annotations.Beta;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
package io.fd.honeycomb.translate.read;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.SubtreeManager;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import io.fd.honeycomb.translate.read.InitFailedException;
import io.fd.honeycomb.translate.read.ReadContext;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
/**
* Root initializer.
package io.fd.honeycomb.translate.read.registry;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.collect.Multimap;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* @throws ReadFailedException if read was unsuccessful
*/
@Nonnull
- Optional<? extends DataObject> read(@Nonnull InstanceIdentifier<? extends DataObject> id,
- @Nonnull ReadContext ctx)
+ Optional<? extends DataObject> read(@Nonnull InstanceIdentifier<? extends DataObject> id, @Nonnull ReadContext ctx)
throws ReadFailedException;
}
package io.fd.honeycomb.translate.write;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.ModificationContext;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import static io.fd.honeycomb.translate.impl.read.GenericInitReader.writeInit;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.read.InitFailedException;
import io.fd.honeycomb.translate.read.InitListReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.spi.read.Initialized;
import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
package io.fd.honeycomb.translate.impl.read;
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.Initialized;
import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer;
+import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.checkerframework.checker.nullness.compatqual.NullableDecl;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
@SuppressWarnings("unchecked")
static void writeInit(final DataBroker broker, final Initialized<? extends DataObject> init) {
final WriteTransaction writeTx = broker.newWriteOnlyTransaction();
- writeTx.merge(CONFIGURATION, (InstanceIdentifier) init.getId(), init.getData(), true);
+
+ InstanceIdentifier id = init.getId();
+ if (id.getPathArguments() instanceof List && ((List) id.getPathArguments()).size() == 1) {
+ //root element only. not necessary to create parents
+ writeTx.merge(CONFIGURATION, id, init.getData());
+ }
+ else {
+ writeTx.mergeParentStructureMerge(CONFIGURATION, id, init.getData());
+ }
FluentFuture<? extends CommitInfo> future = writeTx.commit();
future.addCallback(new FutureCallback<CommitInfo>() {
@Override
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.read.ListReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.read.Reader;
import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
+import io.fd.honeycomb.translate.util.read.ReflexiveListReaderCustomizer;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.ThreadSafe;
-
-import io.fd.honeycomb.translate.util.read.ReflexiveListReaderCustomizer;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import io.fd.honeycomb.translate.read.InitFailedException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
@SuppressWarnings("unchecked")
public static <D extends DataObject> InstanceIdentifier<D> appendTypeToId(
final InstanceIdentifier<? extends DataObject> parentId, final InstanceIdentifier<D> type) {
- final InstanceIdentifier.PathArgument t = new InstanceIdentifier.Item<>(type.getTargetType());
+ final InstanceIdentifier.PathArgument t = InstanceIdentifier.Item.of(type.getTargetType());
return (InstanceIdentifier<D>) InstanceIdentifier.create(Iterables.concat(
parentId.getPathArguments(), Collections.singleton(t)));
}
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterables;
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.Multimap;
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import io.fd.honeycomb.translate.read.ReadContext;
import java.util.Set;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
import com.google.common.collect.Iterables;
import io.fd.honeycomb.translate.read.ListReader;
import io.fd.honeycomb.translate.read.ReadContext;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Builder;
Collections.emptyList(), nextId.getType());
if (method.isPresent()) {
- return Optional.fromNullable(filterSingle(parent, nextId, method.get()));
+ return Optional.ofNullable(filterSingle(parent, nextId, method.get()));
} else {
// List child nodes
method = ReflectionUtils.findMethodReflex(managedType,
final Method keyGetter = ReflectionUtils.findMethodReflex(nextId.getType(), "get",
Collections.emptyList(), key.getClass()).get();
- return Optional.fromNullable(invoke.stream()
+ return Optional.ofNullable(invoke.stream()
.filter(item -> key.equals(invoke(keyGetter, nextId, item)))
.findFirst().orElse(null));
}
// Make sure the key is present
if (isWildcarded(id)) {
return RWUtils.replaceLastInId(id,
- new InstanceIdentifier.IdentifiableItem<>(id.getTargetType(), current.key()));
+ InstanceIdentifier.IdentifiableItem.of(id.getTargetType(), current.key()));
} else {
return id;
}
import static com.google.common.base.Preconditions.checkNotNull;
import static java.util.stream.Collectors.toMap;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
final Optional<? extends DataObject> parentAfter = ctx.readAfter(parentKeyedId);
// Put the parent update data into updates map so that revert can also access the state
- DataObjectUpdate parentUpdate = DataObjectUpdate.create(parentKeyedId, parentBefore.orNull(), parentAfter.orNull());
+ DataObjectUpdate parentUpdate =
+ DataObjectUpdate.create(parentKeyedId, parentBefore.orElse(null), parentAfter.orElse(null));
updates.put(RWUtils.makeIidWildcarded(parentKeyedId), parentUpdate);
return parentUpdate;
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.yangtools.concepts.Builder;
public class GenericInitListReaderTest extends AbstractListReaderTest {
getReader().init(broker, DATA_OBJECT_ID, ctx);
- verify(writeTx, times(2)).merge(LogicalDatastoreType.CONFIGURATION, DATA_OBJECT_ID, data, true);
+ verify(writeTx, times(2)).merge(CONFIGURATION, DATA_OBJECT_ID, data);
verify(writeTx, times(2)).commit();
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
getReader().init(broker, DATA_OBJECT_ID, ctx);
- verify(writeTx).merge(LogicalDatastoreType.CONFIGURATION, DATA_OBJECT_ID, data, true);
+ verify(writeTx).merge(CONFIGURATION, DATA_OBJECT_ID, data);
verify(writeTx).commit();
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.Reader;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
package io.fd.honeycomb.translate.impl.read.registry;
+import static io.fd.honeycomb.translate.impl.read.registry.CompositeReaderRegistryTest.mockReader;
import static io.fd.honeycomb.translate.util.DataObjects.DataObject4;
import static io.fd.honeycomb.translate.util.DataObjects.DataObject4.DataObject41;
import static io.fd.honeycomb.translate.util.DataObjects.DataObjectK;
import static io.fd.honeycomb.translate.util.DataObjects.DataObjectKey;
-import static io.fd.honeycomb.translate.impl.read.registry.CompositeReaderRegistryTest.mockReader;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.read.ListReader;
import io.fd.honeycomb.translate.read.Reader;
import io.fd.honeycomb.translate.util.DataObjects;
import java.util.List;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
import com.google.common.collect.Sets;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.Reader;
import io.fd.honeycomb.translate.util.DataObjects;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
private ReadContext ctx;
@Before
- public void setUp() throws Exception {
+ public void setUp() {
MockitoAnnotations.initMocks(this);
Mockito.doReturn(DataObjects.DataObject4.IID).when(delegate).getManagedDataObjectType();
doReturn(DataObject1.IID).when(delegateLocal).getManagedDataObjectType();
}
@Test
- public void testCreate() throws Exception {
+ public void testCreate() {
final Reader<DataObjects.DataObject4, Builder<DataObjects.DataObject4>> subtreeR =
SubtreeReader.createForReader(Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID), delegate);
final Reader<DataObjects.DataObject4, Builder<DataObjects.DataObject4>> subtreeR =
SubtreeReader.createForReader(Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID), delegate);
- doReturn(Optional.fromNullable(mock(DataObjects.DataObject4.class))).when(delegate).read(DataObjects.DataObject4.IID, ctx);
+ doReturn(Optional.ofNullable(mock(DataObjects.DataObject4.class))).when(delegate)
+ .read(DataObjects.DataObject4.IID, ctx);
subtreeR.read(DataObjects.DataObject4.DataObject41.IID, ctx);
}
final Reader<DataObjects.DataObject4, Builder<DataObjects.DataObject4>> subtreeR =
SubtreeReader.createForReader(Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID), delegate);
- doReturn(Optional.absent()).when(delegate).read(DataObjects.DataObject4.IID, ctx);
+ doReturn(Optional.empty()).when(delegate).read(DataObjects.DataObject4.IID, ctx);
assertFalse(subtreeR.read(DataObjects.DataObject4.DataObject41.IID, ctx).isPresent());
}
final DataObject1 mock = mock(DataObject1.class);
final DataObject1.DataObject11 mock11 = mock(DataObject1.DataObject11.class);
doReturn(mock11).when(mock).getDataObject11();
- doReturn(Optional.fromNullable(mock)).when(delegateLocal).read(DataObject1.IID, ctx);
+ doReturn(Optional.ofNullable(mock)).when(delegateLocal).read(DataObject1.IID, ctx);
assertEquals(mock11, subtreeR.read(DataObject1.DataObject11.IID, ctx).get());
}
final DataObject1 mock = mock(DataObject1.class);
final DataObject1.DataObject11 mock11 = mock(DataObject1.DataObject11.class);
doReturn(mock11).when(mock).getDataObject11();
- doReturn(Optional.fromNullable(mock)).when(delegateLocal).read(DataObject1.IID, ctx);
+ doReturn(Optional.ofNullable(mock)).when(delegateLocal).read(DataObject1.IID, ctx);
assertEquals(mock, subtreeR.read(DataObject1.IID, ctx).get());
}
final InstanceIdentifier<IdentifiableDataObject> keyedIdBefore =
(InstanceIdentifier<IdentifiableDataObject>) InstanceIdentifier.create(Collections
- .singleton(new InstanceIdentifier.IdentifiableItem<>(IdentifiableDataObject.class, beforeKey)));
+ .singleton(InstanceIdentifier.IdentifiableItem.of(IdentifiableDataObject.class, beforeKey)));
final InstanceIdentifier<IdentifiableDataObject> keyedIdAfter =
(InstanceIdentifier<IdentifiableDataObject>) InstanceIdentifier.create(Collections
- .singleton(new InstanceIdentifier.IdentifiableItem<>(IdentifiableDataObject.class, keyAfter)));
+ .singleton(InstanceIdentifier.IdentifiableItem.of(IdentifiableDataObject.class, keyAfter)));
writer.processModification(DATA_OBJECT_ID, before, after, ctx);
verify(customizer).updateCurrentAttributes(keyedIdBefore, before, after, ctx);
final InstanceIdentifier<IdentifiableDataObject> keyedIdBefore =
(InstanceIdentifier<IdentifiableDataObject>) InstanceIdentifier.create(Collections
- .singleton(new InstanceIdentifier.IdentifiableItem<>(IdentifiableDataObject.class, beforeKey)));
+ .singleton(InstanceIdentifier.IdentifiableItem.of(IdentifiableDataObject.class, beforeKey)));
final InstanceIdentifier<IdentifiableDataObject> keyedIdAfter =
(InstanceIdentifier<IdentifiableDataObject>) InstanceIdentifier.create(Collections
- .singleton(new InstanceIdentifier.IdentifiableItem<>(IdentifiableDataObject.class, keyAfter)));
+ .singleton(InstanceIdentifier.IdentifiableItem.of(IdentifiableDataObject.class, keyAfter)));
writer.validate(DATA_OBJECT_ID, before, after, ctx);
verify(validator).validateUpdate(keyedIdBefore, before, after, ctx);
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMultimap;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.junit.Before;
@Nonnull
public static <D extends DataObject & Identifiable<K>, K extends Identifier<D>> InstanceIdentifier.IdentifiableItem<D, K> getCurrentIdItem(
@Nonnull final InstanceIdentifier<D> id, final K key) {
- return new InstanceIdentifier.IdentifiableItem<>(id.getTargetType(), key);
+ return InstanceIdentifier.IdentifiableItem.of(id.getTargetType(), key);
}
/**
*/
@SuppressWarnings("unchecked")
public static <D extends DataObject> InstanceIdentifier<D> makeIidLastWildcarded(final InstanceIdentifier<D> id) {
- final InstanceIdentifier.Item<D> wildcardedItem = new InstanceIdentifier.Item<>(id.getTargetType());
+ final InstanceIdentifier.Item<D> wildcardedItem = InstanceIdentifier.Item.of(id.getTargetType());
final Iterable<InstanceIdentifier.PathArgument> pathArguments = id.getPathArguments();
return (InstanceIdentifier<D>) InstanceIdentifier.create(
Iterables.concat(
private static InstanceIdentifier.PathArgument cleanPathArgumentFromKeys(final InstanceIdentifier.PathArgument pathArgument) {
return pathArgument instanceof InstanceIdentifier.IdentifiableItem<?, ?>
- ? new InstanceIdentifier.Item<>(pathArgument.getType())
+ ? InstanceIdentifier.Item.of(pathArgument.getType())
: pathArgument;
}
}
package io.fd.honeycomb.translate.util;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.MappingContext;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public <T extends DataObject> Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId) {
- try (ReadOnlyTransaction tx = contextBindingBrokerDependency.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = contextBindingBrokerDependency.newReadOnlyTransaction()) {
try {
- return tx.read(LogicalDatastoreType.OPERATIONAL, currentId).checkedGet();
- } catch (ReadFailedException e) {
+ return tx.read(LogicalDatastoreType.OPERATIONAL, currentId).get();
+ } catch (InterruptedException | ExecutionException e) {
throw new IllegalStateException("Unable to perform read of " + currentId, e);
}
}
final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction();
writeTx.delete(LogicalDatastoreType.OPERATIONAL, path);
try {
- writeTx.submit().checkedGet();
- } catch (TransactionCommitFailedException e) {
+ writeTx.commit().get();
+ } catch (InterruptedException | ExecutionException e) {
throw new IllegalStateException("Unable to perform delete of " + path, e);
}
}
@Override
public <T extends DataObject> void merge(final InstanceIdentifier<T> path, final T data) {
final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction();
- writeTx.merge(LogicalDatastoreType.OPERATIONAL, path, data, true);
+ writeTx.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, path, data);
try {
- writeTx.submit().checkedGet();
- } catch (TransactionCommitFailedException e) {
+ writeTx.commit().get();
+ } catch (InterruptedException | ExecutionException e) {
throw new IllegalStateException("Unable to perform merge of " + path, e);
}
}
@Override
public <T extends DataObject> void put(final InstanceIdentifier<T> path, final T data) {
final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.OPERATIONAL, path, data, true);
+ writeTx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, path, data);
try {
- writeTx.submit().checkedGet();
- } catch (TransactionCommitFailedException e) {
+ writeTx.commit().get();
+ } catch (InterruptedException | ExecutionException e) {
throw new IllegalStateException("Unable to perform put of " + path, e);
}
}
package io.fd.honeycomb.translate.util;
-import com.google.common.base.Optional;
import java.lang.reflect.Method;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
/**
* @param paramTypes List of input argument types
* @param retType Return type
*
- * @return Found method or Optional.absent() if there's no such method
+ * @return Found method or Optional.empty() if there's no such method
*/
@Nonnull
public static Optional<Method> findMethodReflex(@Nonnull final Class<?> managedType,
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static boolean isMethodMatch(final @Nonnull String prefix,
package io.fd.honeycomb.translate.util;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.translate.MappingContext;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public <T extends DataObject> Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId) {
try {
- return readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, currentId).checkedGet();
- } catch (ReadFailedException e) {
- throw new IllegalStateException("Unable to perform read", e);
+ return readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, currentId).get();
+ } catch (InterruptedException | ExecutionException ex) {
+ throw new IllegalStateException("Unable to perform read", ex);
}
}
readWriteTransaction.put(LogicalDatastoreType.OPERATIONAL, path, data, true);
}
- public CheckedFuture<Void, TransactionCommitFailedException> submit() {
- return readWriteTransaction.submit();
+ public FluentFuture<? extends CommitInfo> commit() {
+ return readWriteTransaction.commit();
}
@Override
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.read.Reader;
import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.read.ReadFailedException;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
final D built = builder.build();
final Optional<D> read = isPresent(id, built, ctx)
? Optional.of(built)
- : Optional.absent();
+ : Optional.empty();
LOG.debug("{}: Current node read successfully. Result: {}", this, read);
return read;
package io.fd.honeycomb.translate.util.read;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.translate.read.ReadContext;
-import io.fd.honeycomb.translate.read.Reader;
import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.read.Reader;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Override
public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nonnull final ReadContext ctx) throws ReadFailedException {
- try (final ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) {
- final CheckedFuture<? extends Optional<? extends DataObject>, org.opendaylight.controller.md.sal.common.api.data.ReadFailedException>
+ try (final ReadTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) {
+ final FluentFuture<? extends Optional<? extends DataObject>>
read = readOnlyTransaction.read(datastoreType, id);
try {
- return read.checkedGet();
- } catch (org.opendaylight.controller.md.sal.common.api.data.ReadFailedException e) {
- throw new ReadFailedException(id, e);
+ return read.get();
+ } catch (InterruptedException | ExecutionException ex) {
+ throw new ReadFailedException(id, ex);
}
}
}
package io.fd.honeycomb.translate.util.read;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.read.ListReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.read.Reader;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
package io.fd.honeycomb.translate.util.read;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.Reader;
import java.io.Closeable;
+import java.util.Optional;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
private static final class NoopMappingContext implements MappingContext {
@Override
public <T extends DataObject> Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId) {
- return Optional.absent();
+ return Optional.empty();
}
@Override
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import io.fd.honeycomb.translate.util.ReflectionUtils;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.nonNull;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.util.read.cache.noop.NoopDumpPostProcessingFunction;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
* @param cache modification cache of current transaction
* @throws ReadFailedException if execution of dumping request failed
* @returns If present in cache ,returns cached instance, if not, tries to dump data using provided executor,
- * otherwise Optional.absent()
+ * otherwise Optional.empty()
*/
public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier,
@Nonnull final ModificationCache cache)
* @param dumpParams parameters to configure dump request
* @throws ReadFailedException if execution of dumping request failed
* @returns If present in cache ,returns cached instance, if not, tries to dump data using provided executor,
- * otherwise Optional.absent()
+ * otherwise Optional.empty()
*/
public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier,
@Nonnull final ModificationCache cache, final U dumpParams)
package io.fd.honeycomb.translate.util.write;
-import com.google.common.util.concurrent.CheckedFuture;
+import static org.opendaylight.mdsal.common.api.LogicalDatastoreType.CONFIGURATION;
+
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.translate.write.WriteContext;
import io.fd.honeycomb.translate.write.WriteFailedException;
import io.fd.honeycomb.translate.write.Writer;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
* Simple DataBroker backed writer allowing to delegate writes to different brokers.
@Nonnull final WriteContext ctx) throws WriteFailedException {
final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
writeTransaction.put(CONFIGURATION, (InstanceIdentifier<DataObject>) id, dataAfter);
- final CheckedFuture<Void, TransactionCommitFailedException> result = writeTransaction.submit();
+ final FluentFuture<? extends CommitInfo> result = writeTransaction.commit();
try {
- result.checkedGet();
- } catch (TransactionCommitFailedException e) {
- throw new WriteFailedException(id, e);
+ result.get();
+ } catch (InterruptedException | ExecutionException ex) {
+ throw new WriteFailedException(id, ex);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2019 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.translate.util.write;
+
+import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+
+import com.google.common.util.concurrent.FluentFuture;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.honeycomb.translate.write.Writer;
+import java.util.concurrent.ExecutionException;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Simple DataBroker backed writer allowing to delegate writes to different brokers.
+ */
+public final class LegacyBindingBrokerWriter<D extends DataObject> implements Writer<D> {
+ private final InstanceIdentifier<D> instanceIdentifier;
+ private final DataBroker dataBroker;
+
+ public LegacyBindingBrokerWriter(final InstanceIdentifier<D> instanceIdentifier, final DataBroker dataBroker) {
+ this.instanceIdentifier = instanceIdentifier;
+ this.dataBroker = dataBroker;
+ }
+
+ @Nonnull
+ @Override
+ public InstanceIdentifier<D> getManagedDataObjectType() {
+ return instanceIdentifier;
+ }
+
+ @Override
+ public void processModification(@Nonnull final InstanceIdentifier<? extends DataObject> id,
+ @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter,
+ @Nonnull final WriteContext ctx) throws WriteFailedException {
+ final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
+ writeTransaction.put(CONFIGURATION, (InstanceIdentifier<DataObject>) id, dataAfter);
+ final FluentFuture<? extends CommitInfo> result = writeTransaction.commit();
+ try {
+ result.get();
+ } catch (InterruptedException | ExecutionException ex) {
+ throw new WriteFailedException(id, ex);
+ }
+ }
+
+ @Override
+ public boolean supportsDirectUpdate() {
+ return false;
+ }
+}
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.write.WriteContext;
import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
*/
public final class TransactionWriteContext implements WriteContext {
- private final DOMDataReadOnlyTransaction beforeTx;
- private final DOMDataReadOnlyTransaction afterTx;
+ private final DOMDataTreeReadTransaction beforeTx;
+ private final DOMDataTreeReadTransaction afterTx;
private final ModificationCache ctx;
private final BindingNormalizedNodeSerializer serializer;
private final MappingContext mappingContext;
public TransactionWriteContext(final BindingNormalizedNodeSerializer serializer,
- final DOMDataReadOnlyTransaction beforeTx,
- final DOMDataReadOnlyTransaction afterTx,
+ final DOMDataTreeReadTransaction beforeTx,
+ final DOMDataTreeReadTransaction afterTx,
final MappingContext mappingContext) {
this.serializer = serializer;
this.beforeTx = beforeTx;
private <T extends DataObject> Optional<T> read(final InstanceIdentifier<T> currentId,
- final DOMDataReadOnlyTransaction tx) {
+ final DOMDataTreeReadTransaction tx) {
final YangInstanceIdentifier path = serializer.toYangInstanceIdentifier(currentId);
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read =
- tx.read(LogicalDatastoreType.CONFIGURATION, path);
+ final FluentFuture<Optional<NormalizedNode<?, ?>>> read = tx.read(LogicalDatastoreType.CONFIGURATION, path);
try {
// TODO HONEYCOMB-169 once the APIs are asynchronous use just Futures.transform
- final Optional<NormalizedNode<?, ?>> optional = read.checkedGet();
+ final Optional<NormalizedNode<?, ?>> optional = read.get();
if (!optional.isPresent()) {
- return Optional.absent();
+ return Optional.empty();
}
final NormalizedNode<?, ?> data = optional.get();
checkState(targetType.isAssignableFrom(entry.getValue().getClass()),
"Unexpected data object type, should be: %s, but was: %s", targetType, entry.getValue().getClass());
return Optional.of(targetType.cast(entry.getValue()));
- } catch (ReadFailedException e) {
+ } catch (InterruptedException | ExecutionException e) {
throw new IllegalStateException("Unable to perform read", e);
}
}
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.translate.MappingContext;
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.util.DataObjects;
import io.fd.honeycomb.translate.util.write.TransactionWriteContext;
import java.util.Map;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@Mock
private BindingNormalizedNodeSerializer serializer;
@Mock
- private DOMDataReadOnlyTransaction beforeTx;
+ private DOMDataTreeReadTransaction beforeTx;
@Mock
- private DOMDataReadOnlyTransaction afterTx;
+ private DOMDataTreeReadTransaction afterTx;
@Mock
private Map.Entry entry;
@Mock
@Test
public void testReadBeforeNoData() throws Exception {
when(beforeTx.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn(
- Futures.immediateCheckedFuture(Optional.absent()));
+ FluentFutures.immediateFluentFuture(Optional.empty()));
final InstanceIdentifier<DataObjects.DataObject1> instanceId =
InstanceIdentifier.create(DataObjects.DataObject1.class);
@Test
public void testReadBefore() throws Exception {
when(beforeTx.read(eq(LogicalDatastoreType.CONFIGURATION), any(YangInstanceIdentifier.class))).thenReturn(
- Futures.immediateCheckedFuture(Optional.of(mock(NormalizedNode.class))));
+ FluentFutures.immediateFluentFuture(Optional.of(mock(NormalizedNode.class))));
final InstanceIdentifier<DataObjects.DataObject1> instanceId =
InstanceIdentifier.create(DataObjects.DataObject1.class);
@Test(expected = IllegalStateException.class)
public void testReadBeforeFailed() throws Exception {
when(beforeTx.read(LogicalDatastoreType.CONFIGURATION, yangId)).thenReturn(
- Futures.immediateFailedCheckedFuture(mock(ReadFailedException.class)));
+ FluentFutures.immediateFailedFluentFuture(mock(ReadFailedException.class)));
transactionWriteContext.readBefore(mock(InstanceIdentifier.class));
}
@Test(expected = IllegalStateException.class)
public void testReadAfterFailed() throws Exception {
when(afterTx.read(LogicalDatastoreType.CONFIGURATION, yangId)).thenReturn(
- Futures.immediateFailedCheckedFuture(mock(ReadFailedException.class)));
+ FluentFutures.immediateFailedFluentFuture(mock(ReadFailedException.class)));
transactionWriteContext.readAfter(mock(InstanceIdentifier.class));
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private RealtimeMappingContext ctx;
private InstanceIdentifier<DataObject> id = InstanceIdentifier.create(DataObject.class);
@Mock
- private ReadOnlyTransaction readTx;
+ private ReadTransaction readTx;
@Mock
private WriteTransaction writeTx;
@Mock
when(broker.newReadOnlyTransaction()).thenReturn(readTx);
when(broker.newWriteOnlyTransaction()).thenReturn(writeTx);
- when(writeTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ when(writeTx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
}
@Test
- public void testRead() throws Exception {
- final CheckedFuture<Optional<DataObject>, ReadFailedException> futureData =
- Futures.immediateCheckedFuture(Optional.of((data)));
+ public void testRead() {
+ final FluentFuture<Optional<DataObject>> futureData =
+ FluentFutures.immediateFluentFuture(Optional.of((data)));
when(readTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData);
assertSame(ctx.read(id).get(), data);
verify(broker).newReadOnlyTransaction();
verify(readTx).read(LogicalDatastoreType.OPERATIONAL, id);
- when(readTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ when(readTx.read(LogicalDatastoreType.OPERATIONAL, id))
+ .thenReturn(FluentFutures.immediateFluentFuture(Optional.empty()));
assertFalse(ctx.read(id).isPresent());
}
@Test
- public void testMerge() throws Exception {
+ public void testMerge() {
ctx.merge(id, data);
verify(broker).newWriteOnlyTransaction();
- verify(writeTx).merge(LogicalDatastoreType.OPERATIONAL, id, data, true);
+ verify(writeTx).mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, id, data);
}
@Test(expected = IllegalStateException.class)
public void testMergeFailure() throws Exception {
- when(writeTx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(ex));
+ when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex));
ctx.merge(id, data);
}
@Test
- public void testPut() throws Exception {
+ public void testPut() {
ctx.put(id, data);
verify(broker).newWriteOnlyTransaction();
- verify(writeTx).put(LogicalDatastoreType.OPERATIONAL, id, data, true);
+ verify(writeTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, id, data);
}
@Test(expected = IllegalStateException.class)
- public void testPutFailure() throws Exception {
- when(writeTx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(ex));
+ public void testPutFailure() {
+ when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex));
ctx.put(id, data);
}
@Test
- public void testDelete() throws Exception {
+ public void testDelete() {
ctx.delete(id);
verify(broker).newWriteOnlyTransaction();
verify(writeTx).delete(LogicalDatastoreType.OPERATIONAL, id);
}
@Test(expected = IllegalStateException.class)
- public void testDeleteFailure() throws Exception {
- when(writeTx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(ex));
+ public void testDeleteFailure() {
+ when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex));
ctx.delete(id);
}
}
\ No newline at end of file
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
MockitoAnnotations.initMocks(this);
ctx = new TransactionMappingContext(writeTx);
- when(writeTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ when(writeTx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
}
@Test
public void testRead() throws Exception {
- final CheckedFuture<Optional<DataObject>, ReadFailedException> futureData =
- Futures.immediateCheckedFuture(Optional.of((data)));
+ final FluentFuture<Optional<DataObject>> futureData = FluentFutures.immediateFluentFuture(Optional.of((data)));
when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData);
assertSame(ctx.read(id).get(), data);
verify(writeTx).read(LogicalDatastoreType.OPERATIONAL, id);
- when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
+ when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id))
+ .thenReturn(FluentFutures.immediateFluentFuture(Optional.empty()));
assertFalse(ctx.read(id).isPresent());
}
@Test(expected = IllegalStateException.class)
public void testReadFailure() throws Exception {
- final CheckedFuture<Optional<DataObject>, ReadFailedException> futureData =
- Futures.immediateFailedCheckedFuture(ex);
+ final FluentFuture<Optional<DataObject>> futureData =
+ FluentFutures.immediateFailedFluentFuture(ex);
when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData);
assertSame(ctx.read(id).get(), data);
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.translate.read.ReadContext;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-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.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Mock
private ReadContext ctx;
@Mock
- private ReadOnlyTransaction tx;
+ private ReadTransaction tx;
@Mock
private DataObject data;
private BindingBrokerReader<DataObject, DataObjectBuilder> bbReader;
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
when(broker.newReadOnlyTransaction()).thenReturn(tx);
- when(tx.read(LogicalDatastoreType.CONFIGURATION, id)).thenReturn(Futures.immediateCheckedFuture(Optional.of(data)));
+ when(tx.read(LogicalDatastoreType.CONFIGURATION, id))
+ .thenReturn(FluentFutures.immediateFluentFuture(Optional.of(data)));
bbReader = new BindingBrokerReader<>(id, broker, LogicalDatastoreType.CONFIGURATION, DataObjectBuilder.class);
}
@Test(expected = io.fd.honeycomb.translate.read.ReadFailedException.class)
public void testFailedRead() throws Exception {
when(tx.read(LogicalDatastoreType.CONFIGURATION, id))
- .thenReturn(Futures.immediateFailedCheckedFuture(new ReadFailedException("failing")));
+ .thenReturn(FluentFutures.immediateFailedFluentFuture(new ReadFailedException("failing")));
bbReader.read(id, ctx);
}
final TestingListObjectBuilder builder = new TestingListObjectBuilder();
final InstanceIdentifier<TestingListObject> id =
(InstanceIdentifier<TestingListObject>) InstanceIdentifier.create(
- Collections.singletonList(new InstanceIdentifier.IdentifiableItem<>(TestingListObject.class, keyOne)));
+ Collections.singletonList(InstanceIdentifier.IdentifiableItem.of(TestingListObject.class, keyOne)));
customizer.readCurrentAttributes(id, builder, readContext);
assertEquals(keyOne, builder.getKey());
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.read.ReadFailedException;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.translate.write.WriteContext;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
when(broker.newWriteOnlyTransaction()).thenReturn(tx);
- when(tx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ when(tx.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
bbWriter = new BindingBrokerWriter<>(id, broker);
}
bbWriter.processModification(id, data, data, ctx);
verify(broker).newWriteOnlyTransaction();
verify(tx).put(LogicalDatastoreType.CONFIGURATION, id, data);
- verify(tx).submit();
+ verify(tx).commit();
}
@Test(expected = io.fd.honeycomb.translate.write.WriteFailedException.class)
public void testFailedWrite() throws Exception {
- when(tx.submit()).thenReturn(Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("failing")));
+ when(tx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(new InterruptedException("failing")));
bbWriter.processModification(id, data, data, ctx);
}
}
\ No newline at end of file