<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.14.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.14.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<relativePath/>
</parent>
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.ExecutionException;
import org.opendaylight.dsbenchmark.DatastoreAbstractWriter;
-import org.opendaylight.mdsal.binding.api.BindingTransactionChain;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
-import org.opendaylight.mdsal.common.api.AsyncTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChain;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput.DataStore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestExec;
// Dump the whole list into the data store in a single transaction
// with <outerListElem> PUTs on the transaction
- TxchainBaWrite dd = new TxchainBaWrite(bindingDataBroker,
- StartTestInput.Operation.PUT,
- outerListElem,
- innerListElem,
- outerListElem,
- dataStore);
+ TxchainBaWrite dd = new TxchainBaWrite(bindingDataBroker, StartTestInput.Operation.PUT, outerListElem,
+ innerListElem, outerListElem, dataStore);
dd.createList();
dd.executeList();
}
@Override
public void executeList() {
final LogicalDatastoreType dsType = getDataStoreType();
- final BindingTransactionChain chain = bindingDataBroker.createTransactionChain(this);
+ final TransactionChain chain = bindingDataBroker.createTransactionChain(this);
WriteTransaction tx = chain.newWriteOnlyTransaction();
int txSubmitted = 0;
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
- LOG.error("Broken chain {} in TxchainBaDelete, transaction {}, cause {}",
- chain, transaction.getIdentifier(), cause);
+ public void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
+ final Throwable cause) {
+ LOG.error("Broken chain {} in TxchainBaDelete, transaction {}, cause {}", chain, transaction.getIdentifier(),
+ cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final TransactionChain chain) {
LOG.debug("TxchainBaDelete closed successfully, chain {}", chain);
}
}
import org.opendaylight.dsbenchmark.DatastoreAbstractWriter;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
-import org.opendaylight.mdsal.common.api.AsyncTransaction;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChain;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput.DataStore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestExec;
// Dump the whole list into the data store in a single transaction
// with <outerListElem> PUTs on the transaction
- TxchainBaWrite dd = new TxchainBaWrite(bindingDataBroker,
- StartTestInput.Operation.PUT,
- outerListElem,
- innerListElem,
- outerListElem,
- dataStore);
+ TxchainBaWrite dd = new TxchainBaWrite(bindingDataBroker, StartTestInput.Operation.PUT, outerListElem,
+ innerListElem, outerListElem, dataStore);
dd.createList();
dd.executeList();
}
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
- LOG.error("Broken chain {} in TxchainBaDelete, transaction {}, cause {}",
- chain, transaction.getIdentifier(), cause);
+ public void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
+ final Throwable cause) {
+ LOG.error("Broken chain {} in TxchainBaDelete, transaction {}, cause {}", chain, transaction.getIdentifier(),
+ cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final TransactionChain chain) {
LOG.debug("TxchainBaDelete closed successfully, chain {}", chain);
}
-
}
import java.util.concurrent.ExecutionException;
import org.opendaylight.dsbenchmark.BaListBuilder;
import org.opendaylight.dsbenchmark.DatastoreAbstractWriter;
-import org.opendaylight.mdsal.binding.api.BindingTransactionChain;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.Transaction;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.TransactionChainListener;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
-import org.opendaylight.mdsal.common.api.AsyncTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChain;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput.DataStore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput.Operation;
@Override
public void executeList() {
- final BindingTransactionChain chain = bindingDataBroker.createTransactionChain(this);
+ final TransactionChain chain = bindingDataBroker.createTransactionChain(this);
final LogicalDatastoreType dsType = getDataStoreType();
WriteTransaction tx = chain.newWriteOnlyTransaction();
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
- LOG.error("Broken chain {} in DatastoreBaAbstractWrite, transaction {}, cause {}",
- chain, transaction.getIdentifier(), cause);
+ public void onTransactionChainFailed(final TransactionChain chain, final Transaction transaction,
+ final Throwable cause) {
+ LOG.error("Broken chain {} in DatastoreBaAbstractWrite, transaction {}, cause {}", chain,
+ transaction.getIdentifier(), cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final TransactionChain chain) {
LOG.debug("DatastoreBaAbstractWrite closed successfully, chain {}", chain);
}
-
}
import com.google.common.util.concurrent.MoreExecutors;
import java.util.concurrent.ExecutionException;
import org.opendaylight.dsbenchmark.DatastoreAbstractWriter;
-import org.opendaylight.mdsal.common.api.AsyncTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChain;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput.DataStore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestExec;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class TxchainDomDelete extends DatastoreAbstractWriter implements TransactionChainListener {
+public class TxchainDomDelete extends DatastoreAbstractWriter implements DOMTransactionChainListener {
private static final Logger LOG = LoggerFactory.getLogger(TxchainBaWrite.class);
private final DOMDataBroker domDataBroker;
// Dump the whole list into the data store in a single transaction
// with <outerListElem> PUTs on the transaction
- TxchainDomWrite dd = new TxchainDomWrite(domDataBroker,
- StartTestInput.Operation.PUT,
- outerListElem,
- innerListElem,
- outerListElem,
- dataStore);
+ TxchainDomWrite dd = new TxchainDomWrite(domDataBroker, StartTestInput.Operation.PUT, outerListElem,
+ innerListElem, outerListElem, dataStore);
dd.createList();
dd.executeList();
}
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
- LOG.error("Broken chain {} in TxchainDomDelete, transaction {}, cause {}",
- chain, transaction.getIdentifier(), cause);
+ public void onTransactionChainFailed(final DOMTransactionChain chain, final DOMDataTreeTransaction transaction,
+ final Throwable cause) {
+ LOG.error("Broken chain {} in TxchainDomDelete, transaction {}, cause {}", chain, transaction.getIdentifier(),
+ cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final DOMTransactionChain chain) {
LOG.debug("TxchainDomDelete closed successfully, chain {}", chain);
}
}
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.dsbenchmark.DatastoreAbstractWriter;
-import org.opendaylight.mdsal.common.api.AsyncTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChain;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput.DataStore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestExec;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class TxchainDomRead extends DatastoreAbstractWriter implements TransactionChainListener {
+public class TxchainDomRead extends DatastoreAbstractWriter implements DOMTransactionChainListener {
private static final Logger LOG = LoggerFactory.getLogger(TxchainDomRead.class);
private final DOMDataBroker domDataBroker;
// Dump the whole list into the data store in a single transaction
// with <outerListElem> PUTs on the transaction
- TxchainDomWrite dd = new TxchainDomWrite(domDataBroker,
- StartTestInput.Operation.PUT,
- outerListElem,
- innerListElem,
- outerListElem,
- dataStore);
+ TxchainDomWrite dd = new TxchainDomWrite(domDataBroker, StartTestInput.Operation.PUT, outerListElem,
+ innerListElem, outerListElem, dataStore);
dd.createList();
dd.executeList();
}
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
- LOG.error("Broken chain {} in TxchainDomDelete, transaction {}, cause {}",
- chain, transaction.getIdentifier(), cause);
+ public void onTransactionChainFailed(final DOMTransactionChain chain, final DOMDataTreeTransaction transaction,
+ final Throwable cause) {
+ LOG.error("Broken chain {} in TxchainDomDelete, transaction {}, cause {}", chain, transaction.getIdentifier(),
+ cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final DOMTransactionChain chain) {
LOG.debug("TxchainDomDelete closed successfully, chain {}", chain);
}
}
import java.util.concurrent.ExecutionException;
import org.opendaylight.dsbenchmark.DatastoreAbstractWriter;
import org.opendaylight.dsbenchmark.DomListBuilder;
-import org.opendaylight.mdsal.common.api.AsyncTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChain;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput.DataStore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestExec;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class TxchainDomWrite extends DatastoreAbstractWriter implements TransactionChainListener {
+public class TxchainDomWrite extends DatastoreAbstractWriter implements DOMTransactionChainListener {
private static final Logger LOG = LoggerFactory.getLogger(TxchainDomWrite.class);
private final DOMDataBroker domDataBroker;
private List<MapEntryNode> list;
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain,
- final AsyncTransaction<?, ?> transaction, final Throwable cause) {
- LOG.error("Broken chain {} in TxchainDomWrite, transaction {}, cause {}",
- chain, transaction.getIdentifier(), cause);
+ public void onTransactionChainFailed(final DOMTransactionChain chain, final DOMDataTreeTransaction transaction,
+ final Throwable cause) {
+ LOG.error("Broken chain {} in TxchainDomWrite, transaction {}, cause {}", chain, transaction.getIdentifier(),
+ cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final DOMTransactionChain chain) {
LOG.debug("Chain {} closed successfully", chain);
}
}
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.14.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.controller</groupId>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.14.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>odl-mdsal-binding-base</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.controller</groupId>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.odlparent</groupId>
- <artifactId>odl-guava-23</artifactId>
+ <artifactId>odl-guava</artifactId>
<type>xml</type>
<classifier>features</classifier>
</dependency>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-config-netty">
<feature name="odl-config-netty">
- <feature version="[3.1.0,4)">odl-guava-23</feature>
- <feature version="[3.1.0,4)">odl-netty-4</feature>
+ <feature version="[4,5)">odl-guava</feature>
+ <feature version="[4,5)">odl-netty-4</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<scope>import</scope>
<type>pom</type>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>2.0.10</version>
+ <version>2.1.2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.2.0" name="odl-mdsal-${project.version}">
<feature name="odl-mdsal-broker-local" version="${project.version}">
- <feature version="[3.1.0,4)">odl-lmax-3</feature>
- <feature version="[2.0.3,3)">odl-yangtools-codec</feature>
+ <feature version="[4,5)">odl-lmax-3</feature>
+ <feature version="[2.1,3)">odl-yangtools-codec</feature>
<bundle start-level="40">mvn:org.opendaylight.controller/blueprint/${blueprint.version}</bundle>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-controller-${project.version}">
<feature name="odl-mdsal-clustering-commons" version="${project.version}">
- <feature version="[3.1.0,4)">odl-akka-system-2.5</feature>
- <feature version="[3.1.0,4)">odl-akka-persistence-2.5</feature>
- <feature version="[3.1.0,4)">odl-akka-clustering-2.5</feature>
+ <feature version="[4,5)">odl-akka-system-2.5</feature>
+ <feature version="[4,5)">odl-akka-persistence-2.5</feature>
+ <feature version="[4,5)">odl-akka-clustering-2.5</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
</dependency>
<dependency>
<groupId>org.opendaylight.odlparent</groupId>
- <artifactId>odl-akka-leveldb-0.7</artifactId>
- <version>3.1.3</version>
+ <artifactId>odl-akka-leveldb-0.10</artifactId>
+ <version>4.0.2</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
-->
<features xmlns="http://karaf.apache.org/xmlns/features/v1.4.0" name="odl-controller-${project.version}">
<feature name="odl-mdsal-remoterpc-connector" version="${project.version}">
- <feature version="[3.1.0,4)">odl-akka-leveldb-0.7</feature>
+ <feature version="[4,5)">odl-akka-leveldb-0.10</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>odl-mdsal-binding-runtime</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>features-mdsal</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<classifier>features</classifier>
<type>xml</type>
<scope>runtime</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.mdsal.model</groupId>
- <artifactId>features-mdsal-model</artifactId>
- <version>0.14.0-SNAPSHOT</version>
- <classifier>features</classifier>
- <type>xml</type>
- <scope>runtime</scope>
- </dependency>
-
</dependencies>
<scm>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>2.0.10</version>
+ <version>2.1.2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
return trackedService;
}
+
+ @Override
+ public boolean isStaticLifecycle() {
+ return true;
+ }
}
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
return this.timer.stop();
}
+ public static HashedWheelTimerCloseable newInstance(@Nullable final Long duration,
+ @Nullable final Integer ticksPerWheel) {
+ return newInstance(null, duration, ticksPerWheel);
+ }
+
public static HashedWheelTimerCloseable newInstance(@Nullable final ThreadFactory threadFactory,
@Nullable final Long duration, @Nullable final Integer ticksPerWheel) {
TimeUnit unit = TimeUnit.MILLISECONDS;
<bean id="timer" class="org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerCloseable"
factory-method="newInstance">
- <argument><null/></argument> <!-- ThreadFactory -->
<argument value="${tick-duration}"/>
<argument value="${ticks-per-wheel}"/>
</bean>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.14.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<relativePath/>
</parent>
*/
package org.opendaylight.controller.cluster.access.client;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import akka.persistence.SnapshotMetadata;
import akka.testkit.TestProbe;
import akka.testkit.javadsl.TestKit;
+import com.typesafe.config.ConfigFactory;
import java.lang.reflect.Field;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
public void setUp() throws Exception {
initialBehavior = createInitialBehaviorMock();
system = ActorSystem.apply("system1");
- final ActorRef storeRef = system.registerExtension(Persistence.lookup()).snapshotStoreFor(null);
+ final ActorRef storeRef = system.registerExtension(Persistence.lookup()).snapshotStoreFor(null,
+ ConfigFactory.empty());
probe = new TestProbe(system);
storeRef.tell(probe.ref(), ActorRef.noSender());
final MemberName name = MemberName.forName("member-1");
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
@Test
public void testSlicingFailureOnTransmit() {
doAnswer(invocation -> {
- invocation.getArgumentAt(0, SliceOptions.class).getOnFailureCallback().accept(new Exception("mock"));
+ invocation.<SliceOptions>getArgument(0).getOnFailureCallback().accept(new Exception("mock"));
return Boolean.FALSE;
}).when(mockMessageSlicer).slice(any());
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>bundle-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.14.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>findbugs</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
</dependency>
</dependencies>
<configuration>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyObject;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyObject;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import com.google.common.collect.Sets;
import java.util.Arrays;
import java.util.Collections;
-import org.hamcrest.Description;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.ArgumentMatcher;
+import org.mockito.ArgumentMatchers;
import org.mockito.InOrder;
-import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
context.setReplicatedLog(ReplicatedLogImpl.newInstance(context));
}
- private void sendMessageToSupport(Object message) {
+ private void sendMessageToSupport(final Object message) {
sendMessageToSupport(message, false);
}
- private void sendMessageToSupport(Object message, boolean expComplete) {
+ private void sendMessageToSupport(final Object message, final boolean expComplete) {
boolean complete = support.handleRecoveryMessage(message, mockPersistentProvider);
assertEquals("complete", expComplete, complete);
}
}
static UpdateElectionTerm updateElectionTerm(final long term, final String votedFor) {
- return Matchers.argThat(new ArgumentMatcher<UpdateElectionTerm>() {
- @Override
- public boolean matches(Object argument) {
- UpdateElectionTerm other = (UpdateElectionTerm) argument;
- return term == other.getCurrentTerm() && votedFor.equals(other.getVotedFor());
- }
-
- @Override
- public void describeTo(Description description) {
- description.appendValue(new UpdateElectionTerm(term, votedFor));
- }
- });
+ return ArgumentMatchers.argThat(
+ other -> term == other.getCurrentTerm() && votedFor.equals(other.getVotedFor()));
}
@Test
package org.opendaylight.controller.cluster.raft;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.same;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import akka.japi.Procedure;
import java.util.Collections;
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.internal.matchers.Same;
import org.opendaylight.controller.cluster.DataPersistenceProvider;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
- private void verifyPersist(Object message, Matcher<?> matcher, boolean async) throws Exception {
+ private void verifyPersist(Object message, ArgumentMatcher<?> matcher, boolean async) throws Exception {
ArgumentCaptor<Procedure> procedure = ArgumentCaptor.forClass(Procedure.class);
if (async) {
- verify(mockPersistence).persistAsync(Matchers.argThat(matcher), procedure.capture());
+ verify(mockPersistence).persistAsync(argThat(matcher), procedure.capture());
} else {
- verify(mockPersistence).persist(Matchers.argThat(matcher), procedure.capture());
+ verify(mockPersistence).persist(argThat(matcher), procedure.capture());
}
procedure.getValue().apply(message);
reset(mockPersistence);
ReplicatedLogEntry logEntry2 = new SimpleReplicatedLogEntry(2, 1, new MockPayload("2"));
- Procedure<ReplicatedLogEntry> mockCallback = Mockito.mock(Procedure.class);
+ Procedure<ReplicatedLogEntry> mockCallback = mock(Procedure.class);
log.appendAndPersist(logEntry2, mockCallback, true);
verifyPersist(logEntry2);
public void testAppendAndPersisWithDuplicateEntry() throws Exception {
ReplicatedLog log = ReplicatedLogImpl.newInstance(context);
- Procedure<ReplicatedLogEntry> mockCallback = Mockito.mock(Procedure.class);
+ Procedure<ReplicatedLogEntry> mockCallback = mock(Procedure.class);
ReplicatedLogEntry logEntry = new SimpleReplicatedLogEntry(1, 1, new MockPayload("1"));
log.appendAndPersist(logEntry, mockCallback, true);
verifyNoMoreInteractions(mockPersistence);
}
- public Matcher<DeleteEntries> match(final DeleteEntries actual) {
- return new BaseMatcher<DeleteEntries>() {
- @Override
- public boolean matches(Object obj) {
- DeleteEntries other = (DeleteEntries) obj;
- return actual.getFromIndex() == other.getFromIndex();
- }
-
- @Override
- public void describeTo(Description description) {
- description.appendText("DeleteEntries: fromIndex: " + actual.getFromIndex());
- }
- };
+ public ArgumentMatcher<DeleteEntries> match(final DeleteEntries actual) {
+ return other -> actual.getFromIndex() == other.getFromIndex();
}
}
*/
package org.opendaylight.controller.md.sal.binding.impl;
-import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
protected Optional<DataObject> toBindingData(final InstanceIdentifier<?> path, final NormalizedNode<?, ?> data) {
if (path.isWildcarded()) {
- return Optional.absent();
+ return Optional.empty();
}
return (Optional<DataObject>) getCodec().deserializeFunction(path)
.apply(Optional.<NormalizedNode<?, ?>>of(data));
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.MoreExecutors;
import org.opendaylight.controller.md.sal.common.api.MappingCheckedFuture;
import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
Preconditions.checkArgument(!path.isWildcarded(), "Invalid read of wildcarded path %s", path);
return MappingCheckedFuture.create(
- Futures.transform(readTx.read(store, codec.toYangInstanceIdentifierBlocking(path)),
- codec.deserializeFunction(path)),
- ReadFailedException.MAPPER);
+ Futures.transform(readTx.read(store, codec.toYangInstanceIdentifierBlocking(path)),
+ result -> Optional.fromJavaUtil(codec.deserializeFunction(path).apply(result.toJavaUtil())),
+ MoreExecutors.directExecutor()),
+ ReadFailedException.MAPPER);
}
}
*/
package org.opendaylight.controller.md.sal.binding.impl;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.controller.md.sal.binding.api.MountPointService.MountPointListener;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.api.DOMMountPointListener;
// DOMRpcResult does not have a notion of success, hence we have to reverse-engineer it by looking
// at reported errors and checking whether they are just warnings.
- final Collection<RpcError> errors = input.getErrors();
+ final Collection<? extends RpcError> errors = input.getErrors();
return RpcResult.class.cast(RpcResultBuilder.status(errors.stream()
.noneMatch(error -> error.getSeverity() == ErrorSeverity.ERROR))
.withResult(bindingResult).withRpcErrors(errors).build());
package org.opendaylight.controller.md.sal.binding.impl;
import static org.mockito.AdditionalMatchers.not;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import java.util.Collection;
-import org.hamcrest.Description;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
}
static DOMDataTreeIdentifier domDataTreeIdentifier(final YangInstanceIdentifier yangID) {
- return Matchers.argThat(new ArgumentMatcher<DOMDataTreeIdentifier>() {
- @Override
- public boolean matches(final Object argument) {
- final DOMDataTreeIdentifier treeId = (DOMDataTreeIdentifier) argument;
- return treeId.getDatastoreType() == LogicalDatastoreType.CONFIGURATION
- && yangID.equals(treeId.getRootIdentifier());
- }
-
- @Override
- public void describeTo(final Description description) {
- description.appendValue(new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, yangID));
- }
- });
+ return ArgumentMatchers.argThat(treeId -> treeId.getDatastoreType() == LogicalDatastoreType.CONFIGURATION
+ && yangID.equals(treeId.getRootIdentifier()));
}
private static class TestClusteredDataTreeChangeListener implements ClusteredDataTreeChangeListener<Top> {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yangtools-artifacts</artifactId>
- <version>2.0.10</version>
+ <version>2.1.2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>2.6.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
import static org.ops4j.pax.exam.CoreOptions.systemPackages;
import static org.ops4j.pax.exam.CoreOptions.systemProperty;
+
import org.ops4j.pax.exam.Option;
import org.ops4j.pax.exam.options.DefaultCompositeOption;
import org.ops4j.pax.exam.util.PathUtils;
mavenBundle(YANGTOOLS, "yang-common").versionAsInProject(), // //
mavenBundle(YANGTOOLS, "object-cache-api").versionAsInProject(), // //
mavenBundle(YANGTOOLS, "object-cache-guava").versionAsInProject(), // //
- mavenBundle(YANGTOOLS, "triemap").versionAsInProject(), // //
+ mavenBundle("tech.pantheon", "triemap").versionAsInProject(), // //
mavenBundle(CONTROLLER, "sal-common-api").versionAsInProject(), // //
mavenBundle(CONTROLLER, "sal-common-impl").versionAsInProject(), // //
public static Option baseModelBundles() {
return new DefaultCompositeOption( //
- mavenBundle(MDSAL+".model", "yang-ext").versionAsInProject(),
+ mavenBundle(MDSAL + ".model", "yang-ext").versionAsInProject(),
mavenBundle(MDSAL_MODELS, "ietf-type-util").versionAsInProject(),
mavenBundle(MDSAL_MODELS, "ietf-inet-types").versionAsInProject(),
mavenBundle(MDSAL_MODELS, "ietf-yang-types").versionAsInProject(),
return new DefaultCompositeOption(
// Repository required to load harmcrest (OSGi-fied version).
// Mockito
- mavenBundle("org.mockito", "mockito-core", "1.10.19"),
- mavenBundle("org.objenesis", "objenesis", "2.2"),
+ mavenBundle("org.mockito", "mockito-core").versionAsInProject(),
+ mavenBundle("net.bytebuddy", "byte-buddy").versionAsInProject(),
+ mavenBundle("org.objenesis", "objenesis").versionAsInProject(),
junitBundles(),
/*
@Override
protected Option[] getAdditionalOptions() {
- return new Option[]{mavenBundle("org.opendaylight.controller", "sal-test-model").versionAsInProject()};
+ return new Option[] {
+ mavenBundle("org.opendaylight.controller", "sal-test-model").versionAsInProject(),
+ mavenBundle("net.bytebuddy", "byte-buddy").versionAsInProject(),
+ };
}
}
<dependencies>
<!-- Java -->
<dependency>
- <groupId>xmlunit</groupId>
- <artifactId>xmlunit</artifactId>
- <scope>test</scope>
+ <groupId>org.xmlunit</groupId>
+ <artifactId>xmlunit-legacy</artifactId>
</dependency>
<dependency>
import akka.persistence.serialization.Snapshot;
import akka.persistence.serialization.SnapshotSerializer;
import akka.persistence.snapshot.japi.SnapshotStore;
+import akka.serialization.JavaSerializer;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.io.ByteStreams;
import com.typesafe.config.Config;
import java.util.Deque;
import java.util.List;
import java.util.Optional;
+import java.util.concurrent.Callable;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
}
private Object deserialize(final File file) throws IOException {
- try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(file))) {
- return in.readObject();
- } catch (ClassNotFoundException e) {
- throw new IOException("Error loading snapshot file " + file, e);
- } catch (IOException e) {
- LOG.debug("Error loading snapshot file {}", file, e);
-
- return tryDeserializeAkkaSnapshot(file);
- }
+ return JavaSerializer.currentSystem().withValue((ExtendedActorSystem) context().system(),
+ (Callable<Object>) () -> {
+ try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(file))) {
+ return in.readObject();
+ } catch (ClassNotFoundException e) {
+ throw new IOException("Error loading snapshot file " + file, e);
+ } catch (IOException e) {
+ LOG.debug("Error loading snapshot file {}", file, e);
+ return tryDeserializeAkkaSnapshot(file);
+ }
+ });
}
private Object tryDeserializeAkkaSnapshot(final File file) throws IOException {
createSnapshotDir();
system = ActorSystem.create("test", ConfigFactory.load("LocalSnapshotStoreTest.conf"));
- snapshotStore = system.registerExtension(Persistence.lookup()).snapshotStoreFor(null);
+ snapshotStore = system.registerExtension(Persistence.lookup()).snapshotStoreFor(null, ConfigFactory.empty());
}
@AfterClass
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
return ret;
}
+ /**
+ * Creates a new bean if the backing executor is a ThreadPoolExecutor and registers it.
+ *
+ * @param executor the backing {@link Executor}
+ * @param beanName Used as the <code>name</code> property in the bean's ObjectName.
+ * @param beanType Used as the <code>type</code> property in the bean's ObjectName.
+ * @return a registered ThreadExecutorStatsMXBeanImpl instance if the backing executor
+ * is a ThreadPoolExecutor, otherwise null.
+ */
+ public static ThreadExecutorStatsMXBeanImpl create(final Executor executor, final String beanName,
+ final String beanType) {
+ return create(executor, beanName, beanType, null);
+ }
+
/**
* Creates a new bean if the backing executor is a ThreadPoolExecutor.
*
<version>1.9.0-SNAPSHOT</version>
<packaging>bundle</packaging>
+ <dependencyManagement>
+ <dependencies>
+ <dependency>
+ <groupId>tech.pantheon.triemap</groupId>
+ <artifactId>bom</artifactId>
+ <version>1.0.0</version>
+ <scope>import</scope>
+ <type>pom</type>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
+
<dependencies>
<!-- Java -->
<dependency>
<artifactId>yang-data-codec-xml</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.yangtools</groupId>
+ <groupId>tech.pantheon.triemap</groupId>
<artifactId>triemap</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-text</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-dom-inmemory-datastore</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.mdsal.dom.spi.store.DOMStore;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTreeChangePublisher;
}
@Override
- public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
+ public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) {
checkNotClosed();
final Map<LogicalDatastoreType, DOMStoreTransactionChain> backingChains =
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.cluster.databroker;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.EnumMap;
import java.util.Map;
-import org.opendaylight.mdsal.common.api.AsyncTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionFactory;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public abstract class AbstractDOMBrokerTransaction<T extends DOMStoreTransaction> implements
- AsyncTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
+public abstract class AbstractDOMBrokerTransaction<T extends DOMStoreTransaction> implements DOMDataTreeTransaction {
private final EnumMap<LogicalDatastoreType, T> backingTxs;
private final Object identifier;
*/
protected AbstractDOMBrokerTransaction(final Object identifier,
Map<LogicalDatastoreType, ? extends DOMStoreTransactionFactory> storeTxFactories) {
- this.identifier = Preconditions.checkNotNull(identifier, "Identifier should not be null");
- this.storeTxFactories = Preconditions.checkNotNull(storeTxFactories,
- "Store Transaction Factories should not be null");
+ this.identifier = requireNonNull(identifier, "Identifier should not be null");
+ this.storeTxFactories = requireNonNull(storeTxFactories, "Store Transaction Factories should not be null");
this.backingTxs = new EnumMap<>(LogicalDatastoreType.class);
}
* if no subtransaction is associated with key.
*/
protected final T getSubtransaction(final LogicalDatastoreType key) {
- Preconditions.checkNotNull(key, "key must not be null.");
+ requireNonNull(key, "key must not be null.");
T ret = backingTxs.get(key);
if (ret == null) {
ret = createTransaction(key);
backingTxs.put(key, ret);
}
- Preconditions.checkArgument(ret != null, "No subtransaction associated with %s", key);
+ checkArgument(ret != null, "No subtransaction associated with %s", key);
return ret;
}
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientLocalHistory;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientSnapshot;
import org.opendaylight.controller.cluster.databroker.actors.dds.ClientTransaction;
-import org.opendaylight.mdsal.common.api.TransactionChainClosedException;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
}
private ClientSnapshot createSnapshot() {
- try {
- return recordSnapshot(history.takeSnapshot());
- } catch (org.opendaylight.mdsal.common.api.TransactionChainClosedException e) {
- throw new TransactionChainClosedException("Transaction chain has been closed", e);
- }
+ return recordSnapshot(history.takeSnapshot());
}
private ClientTransaction createTransaction() {
- try {
- return recordSnapshot(history.createTransaction());
- } catch (org.opendaylight.mdsal.common.api.TransactionChainClosedException e) {
- throw new TransactionChainClosedException("Transaction chain has been closed", e);
- }
+ return recordSnapshot(history.createTransaction());
}
private Throwable allocationContext() {
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
import org.slf4j.Logger;
private static final Logger LOG = LoggerFactory.getLogger(DOMBrokerTransactionChain.class);
private final AtomicLong txNum = new AtomicLong();
private final AbstractDOMBroker broker;
- private final TransactionChainListener listener;
+ private final DOMTransactionChainListener listener;
private final long chainId;
private volatile State state = State.RUNNING;
* If any of arguments is null.
*/
DOMBrokerTransactionChain(final long chainId, final Map<LogicalDatastoreType, DOMStoreTransactionChain> chains,
- final AbstractDOMBroker broker, final TransactionChainListener listener) {
+ final AbstractDOMBroker broker, final DOMTransactionChainListener listener) {
super(chains);
this.chainId = chainId;
this.broker = Preconditions.checkNotNull(broker);
import org.opendaylight.controller.cluster.access.concepts.LocalHistoryIdentifier;
import org.opendaylight.controller.cluster.access.concepts.Response;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
-import org.opendaylight.mdsal.common.api.TransactionChainClosedException;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainClosedException;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.slf4j.Logger;
private void checkNotClosed() {
if (state == State.CLOSED) {
- throw new TransactionChainClosedException(String.format("Local history %s is closed", identifier));
+ throw new DOMTransactionChainClosedException(String.format("Local history %s is closed", identifier));
}
}
* Allocate a new {@link ClientTransaction}.
*
* @return A new {@link ClientTransaction}
- * @throws TransactionChainClosedException if this history is closed
+ * @throws DOMTransactionChainClosedException if this history is closed
* @throws IllegalStateException if a previous dependent transaction has not been closed
*/
public ClientTransaction createTransaction() {
* Create a new {@link ClientSnapshot}.
*
* @return A new {@link ClientSnapshot}
- * @throws TransactionChainClosedException if this history is closed
+ * @throws DOMTransactionChainClosedException if this history is closed
* @throws IllegalStateException if a previous dependent transaction has not been closed
*/
public ClientSnapshot takeSnapshot() {
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.controller.cluster.datastore.messages.CloseTransactionChain;
import org.opendaylight.controller.cluster.datastore.messages.PrimaryShardInfo;
-import org.opendaylight.mdsal.common.api.TransactionChainClosedException;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainClosedException;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain;
private static final State CLOSED_STATE = new DefaultState() {
@Override
void checkReady() {
- throw new TransactionChainClosedException("Transaction chain has been closed");
+ throw new DOMTransactionChainClosedException("Transaction chain has been closed");
}
};
import akka.pattern.Patterns;
import akka.util.Timeout;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import java.util.Collection;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
DataTree dataTree = getLocalEntityOwnershipShardDataTree();
if (dataTree == null) {
- return Optional.absent();
+ return Optional.empty();
}
java.util.Optional<NormalizedNode<?, ?>> entityNode = dataTree.takeSnapshot().readNode(
entityPath(forEntity.getType(), forEntity.getIdentifier()));
if (!entityNode.isPresent()) {
- return Optional.absent();
+ return Optional.empty();
}
// Check if there are any candidates, if there are none we do not really have ownership state
final boolean hasCandidates = optionalCandidates.isPresent()
&& ((MapNode) optionalCandidates.get()).getValue().size() > 0;
if (!hasCandidates) {
- return Optional.absent();
+ return Optional.empty();
}
MemberName localMemberName = context.getCurrentMemberName();
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.Collection;
}
private static Collection<String> getCandidateNames(final MapEntryNode entity) {
- Collection<MapEntryNode> candidates = ((MapNode)entity.getChild(CANDIDATE_NODE_ID).get()).getValue();
- Collection<String> candidateNames = new ArrayList<>(candidates.size());
- for (MapEntryNode candidate: candidates) {
- candidateNames.add(candidate.getChild(CANDIDATE_NAME_NODE_ID).get().getValue().toString());
- }
-
- return candidateNames;
+ return entity.getChild(CANDIDATE_NODE_ID).map(child -> {
+ Collection<MapEntryNode> candidates = ((MapNode) child).getValue();
+ Collection<String> candidateNames = new ArrayList<>(candidates.size());
+ for (MapEntryNode candidate: candidates) {
+ candidateNames.add(candidate.getChild(CANDIDATE_NAME_NODE_ID).get().getValue().toString());
+ }
+ return candidateNames;
+ }).orElse(ImmutableList.of());
}
private void searchForEntitiesOwnedBy(final Set<String> ownedBy, final EntityWalker walker) {
}
private static boolean hasCandidate(final MapEntryNode entity, final MemberName candidateName) {
- return ((MapNode)entity.getChild(CANDIDATE_NODE_ID).get()).getChild(candidateNodeKey(candidateName.getName()))
+ return entity.getChild(CANDIDATE_NODE_ID)
+ .flatMap(child -> ((MapNode)child).getChild(candidateNodeKey(candidateName.getName())))
.isPresent();
}
import java.util.Map;
import java.util.Optional;
import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.triemap.TrieMap;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
+import tech.pantheon.triemap.TrieMap;
/**
* EntityOwnershipStatistics is a utility class that keeps track of ownership statistics for the candidates and
<argument ref="listenableFutureExecutor"/>
<argument value="CommitFutureExecutorStats"/>
<argument value="DOMDataBroker"/>
- <argument><null/></argument>
</bean>
<!-- Distributed EntityOwnershipService -->
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.DataStoreUnavailableException;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
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.mdsal.dom.broker.TransactionCommitFailedExceptionMapper;
import org.opendaylight.mdsal.dom.spi.store.DOMStore;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
LogicalDatastoreType.OPERATIONAL, domStore, LogicalDatastoreType.CONFIGURATION, domStore),
futureExecutor)) {
- dataBroker.createTransactionChain(mock(TransactionChainListener.class));
+ dataBroker.createTransactionChain(mock(DOMTransactionChainListener.class));
verify(domStore, times(2)).createTransactionChain();
}
doReturn(operationalTransaction).when(mockChain).newWriteOnlyTransaction();
DOMTransactionChain transactionChain = dataBroker.createTransactionChain(
- mock(TransactionChainListener.class));
+ mock(DOMTransactionChainListener.class));
DOMDataTreeWriteTransaction domDataWriteTransaction = transactionChain.newWriteOnlyTransaction();
*/
package org.opendaylight.controller.cluster.databroker.actors.dds;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@SuppressWarnings("unchecked")
private void setupExecuteInActor() {
doAnswer(inv -> {
- inv.getArgumentAt(0, InternalCommand.class).execute(mock(ClientActorBehavior.class));
+ inv.<InternalCommand<?>>getArgument(0).execute(mock(ClientActorBehavior.class));
return null;
}).when(context).executeInActor(any(InternalCommand.class));
}
setupExecuteInActor();
transaction.handleReplayedRemoteRequest(request, callback, Ticker.systemTicker().read());
- final ArgumentCaptor<Response> captor = ArgumentCaptor.forClass(Response.class);
+ final ArgumentCaptor<Response<?, ?>> captor = ArgumentCaptor.forClass(Response.class);
verify(callback).accept(captor.capture());
final Response<?, ?> value = captor.getValue();
Assert.assertTrue(value instanceof ReadTransactionSuccess);
setupExecuteInActor();
transaction.handleReplayedRemoteRequest(request, callback, Ticker.systemTicker().read());
- final ArgumentCaptor<Response> captor = ArgumentCaptor.forClass(Response.class);
+ final ArgumentCaptor<Response<?, ?>> captor = ArgumentCaptor.forClass(Response.class);
verify(callback).accept(captor.capture());
final Response<?, ?> value = captor.getValue();
Assert.assertTrue(value instanceof ExistsTransactionSuccess);
* @return void - always null
*/
protected static final <T> Answer<T> applyToCursorAnswer(final InvocationOnMock invocation) {
- final DataTreeModificationCursor cursor =
- invocation.getArgumentAt(0, DataTreeModificationCursor.class);
+ final DataTreeModificationCursor cursor = invocation.getArgument(0);
cursor.write(PATH_1.getLastPathArgument(), DATA_1);
cursor.merge(PATH_2.getLastPathArgument(), DATA_2);
cursor.delete(PATH_3.getLastPathArgument());
return null;
}
-
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
final DataTree mock = mock(DataTree.class);
doAnswer(invocation -> {
- actual.validate(invocation.getArgumentAt(0, DataTreeModification.class));
+ actual.validate(invocation.getArgument(0));
return null;
}).when(mock).validate(any(DataTreeModification.class));
- doAnswer(invocation -> actual.prepare(invocation.getArgumentAt(0, DataTreeModification.class))).when(
+ doAnswer(invocation -> actual.prepare(invocation.getArgument(0))).when(
mock).prepare(any(DataTreeModification.class));
doAnswer(invocation -> {
- actual.commit(invocation.getArgumentAt(0, DataTreeCandidate.class));
+ actual.commit(invocation.getArgument(0));
return null;
}).when(mock).commit(any(DataTreeCandidate.class));
doAnswer(invocation -> {
- actual.setSchemaContext(invocation.getArgumentAt(0, SchemaContext.class));
+ actual.setSchemaContext(invocation.getArgument(0));
return null;
}).when(mock).setSchemaContext(any(SchemaContext.class));
private static <T> FutureCallback<T> mockFutureCallback(final FutureCallback<T> actual) {
FutureCallback<T> mock = mock(FutureCallback.class);
doAnswer(invocation -> {
- actual.onFailure(invocation.getArgumentAt(0, Throwable.class));
+ actual.onFailure(invocation.getArgument(0));
return null;
}).when(mock).onFailure(any(Throwable.class));
doAnswer(invocation -> {
- actual.onSuccess((T) invocation.getArgumentAt(0, Throwable.class));
+ actual.onSuccess(invocation.getArgument(0));
return null;
- }).when(mock).onSuccess((T) any(Object.class));
+ }).when(mock).onSuccess((T) nullable(Object.class));
return mock;
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.argThat;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
doReturn(mockClusterWrapper).when(mockActorContext).getClusterWrapper();
doReturn(dataStoreContextBuilder.build()).when(mockActorContext).getDatastoreContext();
+ doReturn(new Timeout(5, TimeUnit.SECONDS)).when(mockActorContext).getTransactionCommitOperationTimeout();
final ClientIdentifier mockClientId = MockIdentifiers.clientIdentifier(getClass(), memberName);
mockComponentFactory = new TransactionContextFactory(mockActorContext, mockClientId);
protected CreateTransaction eqCreateTransaction(final String expMemberName,
final TransactionType type) {
- ArgumentMatcher<CreateTransaction> matcher = new ArgumentMatcher<CreateTransaction>() {
+ class CreateTransactionArgumentMatcher implements ArgumentMatcher<CreateTransaction> {
@Override
- public boolean matches(final Object argument) {
- if (CreateTransaction.class.equals(argument.getClass())) {
- CreateTransaction obj = CreateTransaction.fromSerializable(argument);
- return obj.getTransactionId().getHistoryId().getClientId().getFrontendId().getMemberName()
- .getName().equals(expMemberName) && obj.getTransactionType() == type.ordinal();
- }
-
- return false;
+ public boolean matches(CreateTransaction argument) {
+ return argument.getTransactionId().getHistoryId().getClientId().getFrontendId().getMemberName()
+ .getName().equals(expMemberName) && argument.getTransactionType() == type.ordinal();
}
- };
+ }
- return argThat(matcher);
+ return argThat(new CreateTransactionArgumentMatcher());
}
protected DataExists eqDataExists() {
- ArgumentMatcher<DataExists> matcher = new ArgumentMatcher<DataExists>() {
+ class DataExistsArgumentMatcher implements ArgumentMatcher<DataExists> {
@Override
- public boolean matches(final Object argument) {
- return argument instanceof DataExists && ((DataExists)argument).getPath().equals(TestModel.TEST_PATH);
+ public boolean matches(DataExists argument) {
+ return argument.getPath().equals(TestModel.TEST_PATH);
}
- };
+ }
- return argThat(matcher);
+ return argThat(new DataExistsArgumentMatcher());
}
protected ReadData eqReadData() {
}
protected ReadData eqReadData(final YangInstanceIdentifier path) {
- ArgumentMatcher<ReadData> matcher = new ArgumentMatcher<ReadData>() {
+ class ReadDataArgumentMatcher implements ArgumentMatcher<ReadData> {
@Override
- public boolean matches(final Object argument) {
- return argument instanceof ReadData && ((ReadData)argument).getPath().equals(path);
+ public boolean matches(ReadData argument) {
+ return argument.getPath().equals(path);
}
- };
+ }
- return argThat(matcher);
+ return argThat(new ReadDataArgumentMatcher());
}
protected Future<Object> readyTxReply(final String path) {
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
any(SchemaContext.class), any(Collection.class));
kit.testWriteTransaction(dataStore, TestModel.OUTER_LIST_PATH,
- ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build());
+ ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
+ .build());
verify(cohort).canCommit(any(Object.class), any(SchemaContext.class), any(Collection.class));
cohortReg.close();
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.ReadFailedException;
-import org.opendaylight.mdsal.common.api.TransactionChainClosedException;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
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.DOMTransactionChainClosedException;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.mdsal.dom.spi.store.DOMStore;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
testKit.testWriteTransaction(dataStore, TestModel.OUTER_LIST_PATH,
ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
.build());
}
}
writeTx.merge(TestModel.OUTER_LIST_PATH,
ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
.build());
writeTx.write(listEntryPath,
// and ready it
final DOMStoreReadWriteTransaction rwTx = txChain.newReadWriteTransaction();
final MapNode outerNode = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
.build();
rwTx.write(TestModel.OUTER_LIST_PATH, outerNode);
.put(LogicalDatastoreType.CONFIGURATION, dataStore).build(),
MoreExecutors.directExecutor());
- final TransactionChainListener listener = Mockito.mock(TransactionChainListener.class);
+ final DOMTransactionChainListener listener = Mockito.mock(DOMTransactionChainListener.class);
DOMTransactionChain txChain = broker.createTransactionChain(listener);
final List<ListenableFuture<?>> futures = new ArrayList<>();
// Try to create another Tx of each type - should fail b/c
// the previous Tx was closed.
- testKit.assertExceptionOnTxChainCreates(txChain, TransactionChainClosedException.class);
+ testKit.assertExceptionOnTxChainCreates(txChain, DOMTransactionChainClosedException.class);
}
}
DOMStoreWriteTransaction writeTx2 = txChain.newWriteOnlyTransaction();
writeTx2.write(TestModel.OUTER_LIST_PATH,
ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
.build());
// Ensure the reads succeed.
.put(LogicalDatastoreType.CONFIGURATION, dataStore).build(),
MoreExecutors.directExecutor());
- final TransactionChainListener listener = Mockito.mock(TransactionChainListener.class);
+ final DOMTransactionChainListener listener = Mockito.mock(DOMTransactionChainListener.class);
final DOMTransactionChain txChain = broker.createTransactionChain(listener);
final DOMDataTreeReadWriteTransaction writeTx = txChain.newReadWriteTransaction();
.put(LogicalDatastoreType.CONFIGURATION, dataStore).build(),
MoreExecutors.directExecutor());
- final TransactionChainListener listener = Mockito.mock(TransactionChainListener.class);
+ final DOMTransactionChainListener listener = Mockito.mock(DOMTransactionChainListener.class);
final DOMTransactionChain txChain = broker.createTransactionChain(listener);
final DOMDataTreeWriteTransaction writeTx = txChain.newReadWriteTransaction();
// Write 2 updates.
testKit.testWriteTransaction(dataStore, TestModel.OUTER_LIST_PATH,
ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .withChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
.build());
YangInstanceIdentifier listPath = YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import org.opendaylight.controller.md.cluster.datastore.model.SchemaContextHelper;
import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.mdsal.dom.spi.store.DOMStore;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
LogicalDatastoreType.CONFIGURATION, followerDistributedDataStore).build(),
MoreExecutors.directExecutor());
- final TransactionChainListener listener = Mockito.mock(TransactionChainListener.class);
+ final DOMTransactionChainListener listener = Mockito.mock(DOMTransactionChainListener.class);
final DOMTransactionChain txChain = broker.createTransactionChain(listener);
final DOMDataTreeWriteTransaction writeTx = txChain.newWriteOnlyTransaction();
LogicalDatastoreType.CONFIGURATION, followerDistributedDataStore).build(),
MoreExecutors.directExecutor());
- final TransactionChainListener listener = Mockito.mock(TransactionChainListener.class);
+ final DOMTransactionChainListener listener = Mockito.mock(DOMTransactionChainListener.class);
final DOMTransactionChain txChain = broker.createTransactionChain(listener);
final DOMDataTreeWriteTransaction writeTx = txChain.newWriteOnlyTransaction();
cars.add(CarsModel.newCarEntry("car" + carIndex, BigInteger.valueOf(carIndex)));
writeTx2.write(CarsModel.newCarPath("car" + carIndex), cars.getLast());
carIndex++;
- NormalizedNode<?, ?> people = PeopleModel.newPersonMapNode();
+ NormalizedNode<?, ?> people = ImmutableNodes.mapNodeBuilder(PeopleModel.PERSON_QNAME)
+ .withChild(PeopleModel.newPersonEntry("Dude")).build();
writeTx2.write(PeopleModel.PERSON_LIST_PATH, people);
final DOMStoreThreePhaseCommitCohort writeTx2Cohort = writeTx2.ready();
txContext.executeModification(DELETE, null);
assertEquals(2, limiter.availablePermits());
- Future<Object> future = txContext.sendBatchedModifications();
+ final Future<Object> sendFuture = txContext.sendBatchedModifications();
assertEquals(2, limiter.availablePermits());
BatchedModifications msg = kit.expectMsgClass(BatchedModifications.class);
assertEquals(2, msg.getModifications().size());
assertEquals(1, msg.getTotalMessagesSent());
sendReply(new Failure(new NullPointerException()));
- assertFuture(future, new OnComplete<Object>() {
+ assertFuture(sendFuture, new OnComplete<Object>() {
@Override
public void onComplete(final Throwable failure, final Object success) {
assertTrue(failure instanceof NullPointerException);
}
});
- future = txContext.directCommit(null);
+ final Future<Object> commitFuture = txContext.directCommit(null);
msg = kit.expectMsgClass(BatchedModifications.class);
// Modification should have been thrown away by the dropped transmit induced by executeRead()
assertTrue(msg.isReady());
assertEquals(2, msg.getTotalMessagesSent());
sendReply(new Failure(new IllegalStateException()));
- assertFuture(future, new OnComplete<Object>() {
+ assertFuture(commitFuture, new OnComplete<Object>() {
@Override
public void onComplete(final Throwable failure, final Object success) {
assertTrue(failure instanceof IllegalStateException);
// Last acquire should have failed ...
assertEquals(0, limiter.availablePermits());
- Future<Object> future = txContext.sendBatchedModifications();
+ final Future<Object> future = txContext.sendBatchedModifications();
assertEquals(0, limiter.availablePermits());
BatchedModifications msg = kit.expectMsgClass(BatchedModifications.class);
*/
package org.opendaylight.controller.cluster.datastore;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.inOrder;
import org.mockito.invocation.InvocationOnMock;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.controller.cluster.datastore.persisted.CommitTransactionPayload;
-import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
public final class ShardDataTreeMocking {
return commitCallback;
}
- @SuppressWarnings("unchecked")
private static <T> Object invokeSuccess(final InvocationOnMock invocation, final T value) {
- invocation.getArgumentAt(0, FutureCallback.class).onSuccess(value);
+ invocation.<FutureCallback<T>>getArgument(0).onSuccess(value);
return null;
}
private static Object invokeFailure(final InvocationOnMock invocation) {
- invocation.getArgumentAt(0, FutureCallback.class).onFailure(mock(Exception.class));
+ invocation.<FutureCallback<?>>getArgument(0).onFailure(mock(Exception.class));
return null;
}
public static void immediatePayloadReplication(final ShardDataTree shardDataTree, final Shard mockShard) {
doAnswer(invocation -> {
- shardDataTree.applyReplicatedPayload(invocation.getArgumentAt(0, TransactionIdentifier.class),
- invocation.getArgumentAt(1, Payload.class));
+ shardDataTree.applyReplicatedPayload(invocation.getArgument(0), invocation.getArgument(1));
return null;
}).when(mockShard).persistPayload(any(TransactionIdentifier.class), any(CommitTransactionPayload.class),
anyBoolean());
final ContainerNode writeData = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
new WriteModification(TestModel.TEST_PATH, writeData).apply(modification);
- final MapNode mergeData = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build();
+ final MapNode mergeData = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .addChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
+ .build();
new MergeModification(TestModel.OUTER_LIST_PATH, mergeData).apply(modification);
final TransactionIdentifier txId = nextTransactionId();
final ContainerNode writeData = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
new WriteModification(TestModel.TEST_PATH, writeData).apply(modification);
- final MapNode mergeData = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build();
+ final MapNode mergeData = ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .addChild(ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 42))
+ .build();
new MergeModification(TestModel.OUTER_LIST_PATH, mergeData).apply(modification);
final TransactionIdentifier txId = nextTransactionId();
package org.opendaylight.controller.cluster.datastore;
import static org.junit.Assert.assertSame;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
private void canCommitSuccess() {
doAnswer(invocation -> {
- invocation.getArgumentAt(0, SimpleShardDataTreeCohort.class).successfulCanCommit();
+ invocation.<SimpleShardDataTreeCohort>getArgument(0).successfulCanCommit();
return null;
}).when(mockShardDataTree).startCanCommit(cohort);
private void testValidatationPropagates(final Exception cause) {
doAnswer(invocation -> {
- invocation.getArgumentAt(0, SimpleShardDataTreeCohort.class).failedCanCommit(cause);
+ invocation.<SimpleShardDataTreeCohort>getArgument(0).failedCanCommit(cause);
return null;
}).when(mockShardDataTree).startCanCommit(cohort);
private DataTreeCandidateTip preCommitSuccess() {
final DataTreeCandidateTip mockCandidate = mock(DataTreeCandidateTip.class);
doAnswer(invocation -> {
- invocation.getArgumentAt(0, SimpleShardDataTreeCohort.class).successfulPreCommit(mockCandidate);
+ invocation.<SimpleShardDataTreeCohort>getArgument(0).successfulPreCommit(mockCandidate);
return null;
}).when(mockShardDataTree).startPreCommit(cohort);
final DataTreeCandidateTip candidate = preCommitSuccess();
doAnswer(invocation -> {
- invocation.getArgumentAt(0, SimpleShardDataTreeCohort.class).successfulCommit(UnsignedLong.valueOf(0),
- () -> { });
+ invocation.<SimpleShardDataTreeCohort>getArgument(0).successfulCommit(UnsignedLong.valueOf(0), () -> { });
return null;
}).when(mockShardDataTree).startCommit(cohort, candidate);
final Exception cause = new IllegalArgumentException("mock");
doAnswer(invocation -> {
- invocation.getArgumentAt(0, SimpleShardDataTreeCohort.class).failedPreCommit(cause);
+ invocation.<SimpleShardDataTreeCohort>getArgument(0).failedPreCommit(cause);
return null;
}).when(mockShardDataTree).startPreCommit(cohort);
final Exception cause = new IllegalArgumentException("mock");
doAnswer(invocation -> {
- invocation.getArgumentAt(0, SimpleShardDataTreeCohort.class).failedCommit(cause);
+ invocation.<SimpleShardDataTreeCohort>getArgument(0).failedCommit(cause);
return null;
}).when(mockShardDataTree).startCommit(cohort, candidate);
*/
package org.opendaylight.controller.cluster.datastore.entityownership;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.argThat;
import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.CANDIDATE_NAME_QNAME;
import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.ENTITY_ID_QNAME;
import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.ENTITY_OWNERS_PATH;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
-import org.hamcrest.Description;
import org.junit.Assert;
-import org.mockito.ArgumentMatcher;
-import org.mockito.Matchers;
import org.opendaylight.controller.cluster.access.concepts.MemberName;
import org.opendaylight.controller.cluster.datastore.AbstractActorTest;
import org.opendaylight.controller.cluster.datastore.AbstractShardTest;
import org.opendaylight.controller.cluster.datastore.identifiers.ShardIdentifier;
import org.opendaylight.controller.cluster.raft.client.messages.GetOnDemandRaftState;
import org.opendaylight.controller.cluster.raft.client.messages.OnDemandRaftState;
-import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState;
import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipChange;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.clustering.entity.owners.rev150804.EntityOwners;
final QName childMap, final QName child, final Object key, final boolean expectPresent) {
Optional<DataContainerChild<? extends PathArgument, ?>> childNode =
parent.getChild(new NodeIdentifier(childMap));
- assertEquals("Missing " + childMap.toString(), true, childNode.isPresent());
+ // We have to account for empty maps disappearing. If we expect the entry to be non-present, tolerate a missing
+ // map.
+ if (!expectPresent && !childNode.isPresent()) {
+ return null;
+ }
+
+ assertTrue("Missing " + childMap.toString(), childNode.isPresent());
MapNode entityTypeMapNode = (MapNode) childNode.get();
Optional<MapEntryNode> entityTypeEntry = entityTypeMapNode.getChild(new NodeIdentifierWithPredicates(
static DOMEntityOwnershipChange ownershipChange(final DOMEntity expEntity, final boolean expWasOwner,
final boolean expIsOwner, final boolean expHasOwner, final boolean expInJeopardy) {
- return Matchers.argThat(new ArgumentMatcher<DOMEntityOwnershipChange>() {
- @Override
- public boolean matches(final Object argument) {
- DOMEntityOwnershipChange change = (DOMEntityOwnershipChange) argument;
- return expEntity.equals(change.getEntity()) && expWasOwner == change.getState().wasOwner()
- && expIsOwner == change.getState().isOwner() && expHasOwner == change.getState().hasOwner()
- && expInJeopardy == change.inJeopardy();
- }
-
- @Override
- public void describeTo(final Description description) {
- description.appendValue(new DOMEntityOwnershipChange(expEntity, EntityOwnershipChangeState.from(
- expWasOwner, expIsOwner, expHasOwner), expInJeopardy));
- }
- });
+ return argThat(change -> expEntity.equals(change.getEntity()) && expWasOwner == change.getState().wasOwner()
+ && expIsOwner == change.getState().isOwner() && expHasOwner == change.getState().hasOwner()
+ && expInJeopardy == change.inJeopardy());
}
static DOMEntityOwnershipChange ownershipChange(final DOMEntity expEntity) {
- return Matchers.argThat(new ArgumentMatcher<DOMEntityOwnershipChange>() {
- @Override
- public boolean matches(final Object argument) {
- DOMEntityOwnershipChange change = (DOMEntityOwnershipChange) argument;
- return expEntity.equals(change.getEntity());
- }
-
- @Override
- public void describeTo(final Description description) {
- description.appendValue(new DOMEntityOwnershipChange(expEntity, EntityOwnershipChangeState.from(
- false, false, false)));
- }
- });
+ return argThat(change -> expEntity.equals(change.getEntity()));
}
@SuppressWarnings("checkstyle:IllegalCatch")
boolean passed = false;
for (int i = 0; i < 100; i++) {
Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
- final com.google.common.base.Optional<EntityOwnershipState> leaderState =
- leaderEntityOwnershipService.getOwnershipState(ENTITY1);
- final com.google.common.base.Optional<EntityOwnershipState> follower1State =
+ final Optional<EntityOwnershipState> leaderState = leaderEntityOwnershipService.getOwnershipState(ENTITY1);
+ final Optional<EntityOwnershipState> follower1State =
follower1EntityOwnershipService.getOwnershipState(ENTITY1);
- final com.google.common.base.Optional<EntityOwnershipState> follower2State =
+ final Optional<EntityOwnershipState> follower2State =
follower2EntityOwnershipService.getOwnershipState(ENTITY1);
final Optional<DOMEntityOwnershipChange> leaderChange = getValueSafely(leaderChangeCaptor);
final Optional<DOMEntityOwnershipChange> follower1Change = getValueSafely(follower1ChangeCaptor);
private static void verifyGetOwnershipState(final DOMEntityOwnershipService service, final DOMEntity entity,
final EntityOwnershipState expState) {
- com.google.common.base.Optional<EntityOwnershipState> state = service.getOwnershipState(entity);
- assertEquals("getOwnershipState present", true, state.isPresent());
+ Optional<EntityOwnershipState> state = service.getOwnershipState(entity);
+ assertTrue("getOwnershipState present", state.isPresent());
assertEquals("EntityOwnershipState", expState, state.get());
}
import static org.opendaylight.controller.cluster.datastore.entityownership.EntityOwnersModel.entityTypeEntryWithEntityEntry;
import akka.actor.ActorRef;
-import com.google.common.base.Optional;
import com.google.common.collect.Sets;
import java.util.Collection;
+import java.util.Optional;
import java.util.concurrent.TimeUnit;
import org.junit.After;
import org.junit.Before;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.md.sal.dom.broker.impl.legacy.sharded.adapter;
-import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
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.opendaylight.mdsal.common.api.TransactionChain;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-
-class ShardedDOMDataBrokerDelegatingTransactionChain implements DOMTransactionChain, org.opendaylight.mdsal.common
- .api.TransactionChainListener {
+class ShardedDOMDataBrokerDelegatingTransactionChain implements DOMTransactionChain, DOMTransactionChainListener {
private final org.opendaylight.mdsal.dom.api.DOMTransactionChain txChainDelegate;
private final SchemaContext schemaContext;
private final TransactionChainListener txChainListener;
final org.opendaylight.mdsal.dom.api.DOMDataBroker
brokerDelegate,
final TransactionChainListener txChainListener) {
- checkNotNull(brokerDelegate);
- this.schemaContext = checkNotNull(schemaContext);
- this.txChainIdentifier = checkNotNull(txChainIdentifier);
- this.txChainListener = checkNotNull(txChainListener);
+ requireNonNull(brokerDelegate);
+ this.schemaContext = requireNonNull(schemaContext);
+ this.txChainIdentifier = requireNonNull(txChainIdentifier);
+ this.txChainListener = requireNonNull(txChainListener);
this.txChainDelegate = brokerDelegate.createTransactionChain(this);
transactionMap = Maps.newHashMap();
}
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> transactionChain,
- final org.opendaylight.mdsal.common.api.AsyncTransaction<?, ?>
- asyncTransaction,
- final Throwable throwable) {
- txChainListener
- .onTransactionChainFailed(this, transactionFromDelegate(asyncTransaction.getIdentifier()), throwable);
+ public void onTransactionChainFailed(org.opendaylight.mdsal.dom.api.DOMTransactionChain chain,
+ DOMDataTreeTransaction transaction, Throwable cause) {
+ txChainListener.onTransactionChainFailed(this, transactionFromDelegate(transaction.getIdentifier()), cause);
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> transactionChain) {
+ public void onTransactionChainSuccessful(org.opendaylight.mdsal.dom.api.DOMTransactionChain chain) {
txChainListener.onTransactionChainSuccessful(this);
}
@Override
public Optional<DOMMountPoint> getMountPoint(final YangInstanceIdentifier path) {
- final Optional<org.opendaylight.mdsal.dom.api.DOMMountPoint> delegateMountPoint = delegate.getMountPoint(path);
- return delegateMountPoint.isPresent() ? Optional.of(convert(delegateMountPoint.get())) : Optional.absent();
+ return Optional.fromJavaUtil(delegate.getMountPoint(path).map(DOMMountPointServiceImpl::convert));
}
private static DOMMountPoint convert(final org.opendaylight.mdsal.dom.api.DOMMountPoint from) {
@Override
public <T extends DOMService> Optional<T> getService(final Class<T> cls) {
- return from.getService(cls);
+ return Optional.fromJavaUtil(from.getService(cls));
}
@Override
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMDataTreeTransaction;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainClosedException;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.util.concurrent.ExceptionMapper;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
private static final ExceptionMapper<TransactionCommitFailedException> COMMIT_EX_MAPPER =
new ExceptionMapper<TransactionCommitFailedException>("commit", TransactionCommitFailedException.class) {
@Override
- protected TransactionCommitFailedException newWithCause(String message, Throwable cause) {
+ protected TransactionCommitFailedException newWithCause(final String message, final Throwable cause) {
if (cause instanceof org.opendaylight.mdsal.common.api.OptimisticLockFailedException) {
return new OptimisticLockFailedException(cause.getMessage(), cause.getCause());
} else if (cause instanceof org.opendaylight.mdsal.common.api.TransactionCommitFailedException) {
private final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate;
private final ClassToInstanceMap<DOMDataBrokerExtension> extensions;
- public LegacyDOMDataBrokerAdapter(org.opendaylight.mdsal.dom.api.DOMDataBroker delegate) {
+ public LegacyDOMDataBrokerAdapter(final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate) {
this.delegate = delegate;
ClassToInstanceMap<org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension> delegateExtensions =
extBuilder.put(DOMDataTreeChangeService.class, new DOMDataTreeChangeService() {
@Override
public <L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerDataTreeChangeListener(
- DOMDataTreeIdentifier treeId, final L listener) {
+ final DOMDataTreeIdentifier treeId, final L listener) {
final org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener delegateListener;
if (listener instanceof ClusteredDOMDataTreeChangeListener) {
delegateListener = (org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener)
@Override
public DOMTransactionChain createTransactionChain(final TransactionChainListener listener) {
AtomicReference<DOMTransactionChain> legacyChain = new AtomicReference<>();
- org.opendaylight.mdsal.common.api.TransactionChainListener delegateListener =
- new org.opendaylight.mdsal.common.api.TransactionChainListener() {
- @SuppressWarnings("rawtypes")
+ DOMTransactionChainListener delegateListener =
+ new DOMTransactionChainListener() {
@Override
- public void onTransactionChainFailed(final org.opendaylight.mdsal.common.api.TransactionChain<?, ?> chain,
- final org.opendaylight.mdsal.common.api.AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ @SuppressWarnings("rawtypes")
+ public void onTransactionChainFailed(final org.opendaylight.mdsal.dom.api.DOMTransactionChain chain,
+ final DOMDataTreeTransaction transaction, final Throwable cause) {
listener.onTransactionChainFailed(legacyChain.get(),
- (AsyncTransaction) () -> transaction.getIdentifier(),
- cause instanceof Exception ? COMMIT_EX_MAPPER.apply((Exception)cause) : cause);
+ (AsyncTransaction) () -> transaction.getIdentifier(),
+ cause instanceof Exception ? COMMIT_EX_MAPPER.apply((Exception)cause) : cause);
}
@Override
- public void onTransactionChainSuccessful(org.opendaylight.mdsal.common.api.TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final org.opendaylight.mdsal.dom.api.DOMTransactionChain chain) {
listener.onTransactionChainSuccessful(legacyChain.get());
}
};
static <T> T wrapException(final Supplier<T> supplier) {
try {
return supplier.get();
- } catch (org.opendaylight.mdsal.common.api.TransactionChainClosedException e) {
+ } catch (DOMTransactionChainClosedException e) {
throw new TransactionChainClosedException("Transaction chain already closed", e);
}
}
private final DOMDataTreeWriteTransaction writeDelegate;
private final Object identifier;
- DOMDataTransactionAdapter(@Nonnull DOMDataTreeReadTransaction readDelegate) {
+ DOMDataTransactionAdapter(@Nonnull final DOMDataTreeReadTransaction readDelegate) {
this.readDelegate = Preconditions.checkNotNull(readDelegate);
this.identifier = readDelegate.getIdentifier();
this.writeDelegate = null;
}
- DOMDataTransactionAdapter(@Nonnull DOMDataTreeWriteTransaction writeDelegate) {
+ DOMDataTransactionAdapter(@Nonnull final DOMDataTreeWriteTransaction writeDelegate) {
this.writeDelegate = Preconditions.checkNotNull(writeDelegate);
this.identifier = writeDelegate.getIdentifier();
this.readDelegate = null;
}
- DOMDataTransactionAdapter(@Nonnull DOMDataTreeReadWriteTransaction rwDelegate) {
+ DOMDataTransactionAdapter(@Nonnull final DOMDataTreeReadWriteTransaction rwDelegate) {
this.readDelegate = Preconditions.checkNotNull(rwDelegate);
this.writeDelegate = rwDelegate;
this.identifier = readDelegate.getIdentifier();
final SettableFuture<CommitInfo> resultFuture = SettableFuture.create();
writeDelegate().commit().addCallback(new FutureCallback<CommitInfo>() {
@Override
- public void onSuccess(CommitInfo result) {
+ public void onSuccess(final CommitInfo result) {
resultFuture.set(result);
}
@Override
- public void onFailure(Throwable ex) {
+ public void onFailure(final Throwable ex) {
if (ex instanceof Exception) {
resultFuture.setException(COMMIT_EX_MAPPER.apply((Exception)ex));
} else {
private static class DOMDataReadOnlyTransactionAdapter implements DOMDataReadOnlyTransaction {
private final DOMDataTransactionAdapter adapter;
- DOMDataReadOnlyTransactionAdapter(DOMDataTreeReadTransaction delegateTx) {
+ DOMDataReadOnlyTransactionAdapter(final DOMDataTreeReadTransaction delegateTx) {
adapter = new DOMDataTransactionAdapter(delegateTx);
}
@Override
- public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(LogicalDatastoreType store,
- YangInstanceIdentifier path) {
+ public CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> read(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
return adapter.read(store, path);
}
@Override
- public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType store,
- YangInstanceIdentifier path) {
+ public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
+ final YangInstanceIdentifier path) {
return adapter.exists(store, path);
}
// interface isn't. In lieu of changing the interface, we assume the implementation is Serializable which is
// reasonable since the only implementation that is actually used is from the RpcResultBuilder.
@SuppressFBWarnings("SE_BAD_FIELD")
- private final Collection<RpcError> errors;
+ private final Collection<? extends RpcError> errors;
// Unfortunately the NormalizedNode interface isn't Serializable but we assume the implementations are.
@SuppressFBWarnings("SE_BAD_FIELD")
this(result, Collections.<RpcError>emptyList());
}
- public DefaultDOMRpcResult(final NormalizedNode<?, ?> result, final @Nonnull Collection<RpcError> errors) {
+ public DefaultDOMRpcResult(final NormalizedNode<?, ?> result,
+ final @Nonnull Collection<? extends RpcError> errors) {
this.result = result;
this.errors = Preconditions.checkNotNull(errors);
}
}
@Override
- public @Nonnull Collection<RpcError> getErrors() {
+ public @Nonnull Collection<? extends RpcError> getErrors() {
return errors;
}
protected abstract @Nonnull DOMRpcResult delegate();
@Override
- public Collection<RpcError> getErrors() {
+ public Collection<? extends RpcError> getErrors() {
return delegate().getErrors();
}
private final List<RpcErrorData> rpcErrorDataList = new ArrayList<>();
- public RpcErrorsException(final String message, final Iterable<RpcError> rpcErrors) {
+ public RpcErrorsException(final String message, final Iterable<? extends RpcError> rpcErrors) {
super(message);
for (final RpcError rpcError: rpcErrors) {
final ErrorType errorType, final String tag, final String message, final String applicationTag,
final String info, final String causeMsg) {
assertNotNull("RpcResult was null", rpcResult);
- final Collection<RpcError> rpcErrors = rpcResult.getErrors();
+ final Collection<? extends RpcError> rpcErrors = rpcResult.getErrors();
assertEquals("RpcErrors count", 1, rpcErrors.size());
assertRpcErrorEquals(rpcErrors.iterator().next(), severity, errorType, tag, message,
applicationTag, info, causeMsg);
</build>
<dependencies>
<dependency>
- <groupId>org.opendaylight.mdsal.model</groupId>
- <artifactId>ietf-inet-types-2013-07-15</artifactId>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.mdsal.model</groupId>
- <artifactId>ietf-yang-types-20130715</artifactId>
+ <groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
+ <artifactId>rfc6991</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.14.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
- <groupId>org.opendaylight.mdsal.model</groupId>
- <artifactId>ietf-inet-types-2013-07-15</artifactId>
+ <groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
+ <artifactId>rfc6991-ietf-inet-types</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>0.14.0-SNAPSHOT</version>
+ <version>3.0.1</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>3.1.3</version>
+ <version>4.0.2</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.controller</groupId>
Code Review / controller.git / commitdiff