This mass-converts all of neutron to use MD-SAL APIs.
JIRA: NEUTRON-206
Change-Id: I4ea16c5a4b506fd6ae4be4cfb46864604584d4f1
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
Signed-off-by: Achuth <achuth.maniyedath@gmail.com>
<odlparent.spotbugs.enforce>false</odlparent.spotbugs.enforce>
</properties>
+ <dependencyManagement>
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-artifacts</artifactId>
+ <version>5.0.9</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.aaa</groupId>
+ <artifactId>aaa-artifacts</artifactId>
+ <version>0.12.0-SNAPSHOT</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.infrautils</groupId>
+ <artifactId>infrautils-artifacts</artifactId>
+ <version>1.8.0-SNAPSHOT</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
+
<dependencies>
<dependency>
<!-- GSON is only used by the test code (which is in src/main here) -->
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
- <version>1.11.0</version>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
</exclusions>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
- <version>1.11.0</version>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<type>test-jar</type>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-testutils</artifactId>
- <version>1.8.0-SNAPSHOT</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>inject.guice.testutils</artifactId>
- <version>1.8.0-SNAPSHOT</version>
<scope>test</scope>
<exclusions>
<exclusion>
<dependency>
<groupId>org.opendaylight.aaa.web</groupId>
<artifactId>web-jetty-impl</artifactId>
- <version>0.12.0-SNAPSHOT</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.aaa.web</groupId>
<artifactId>servlet-jersey2</artifactId>
- <version>0.12.0-SNAPSHOT</version>
<scope>test</scope>
</dependency>
</dependencies>
import org.opendaylight.aaa.web.jetty.JettyWebServer;
import org.opendaylight.aaa.web.servlet.ServletSupport;
import org.opendaylight.aaa.web.servlet.jersey2.JerseyServletSupport;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.test.DataBrokerTestModule;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.neutron.northbound.api.WebInitializer;
import org.opendaylight.neutron.spi.INeutronBgpvpnCRUD;
import org.opendaylight.neutron.spi.INeutronFirewallCRUD;
*
* @author Michael Vorburger.ch
*/
+@SuppressWarnings("checkstyle:IllegalCatch")
public class NeutronTestWiring extends AbstractModule {
+ private static final class BrokerSetup extends AbstractConcurrentDataBrokerTest {
+ BrokerSetup() {
+ super(true);
+ try {
+ setup();
+ } catch (Exception e) {
+ throw new IllegalStateException("Failed to initialize", e);
+ }
+ }
+ }
@Override
protected void configure() {
bind(ServletSupport.class).toInstance(new JerseyServletSupport());
bind(WebInitializer.class);
- DataBrokerTestModule dataBrokerTestModule = new DataBrokerTestModule(true);
- DataBroker dataBroker = dataBrokerTestModule.getDataBroker();
+ DataBroker dataBroker = new BrokerSetup().getDataBroker();
bind(DataBroker.class).toInstance(dataBroker);
bind(INeutronNetworkCRUD.class).to(NeutronNetworkInterface.class);
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.neutron.hostconfig.utils.NeutronHostconfigUtils;
-import org.opendaylight.ovsdb.utils.mdsal.utils.ControllerMdsalUtils;
+import org.opendaylight.ovsdb.utils.mdsal.utils.MdsalUtils;
import org.opendaylight.ovsdb.utils.southbound.utils.SouthboundUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
@Inject
public NeutronHostconfigOvsListener(final DataBroker dataBroker) {
this.dataBroker = dataBroker;
- ControllerMdsalUtils mdsalUtils = new ControllerMdsalUtils(dataBroker);
- this.southboundUtils = new SouthboundUtils(mdsalUtils);
+ this.southboundUtils = new SouthboundUtils(new MdsalUtils(dataBroker));
this.neutronHostconfig = new NeutronHostconfigUtils(dataBroker);
}
}
}
- private InstanceIdentifier<Node> createNodeIdentifier() {
+ private static InstanceIdentifier<Node> createNodeIdentifier() {
return InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundUtils.OVSDB_TOPOLOGY_ID))
public void init() {
LOG.info("{} start", getClass().getSimpleName());
DataTreeIdentifier<Node> dataTreeIdentifier =
- new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, createNodeIdentifier());
+ DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, createNodeIdentifier());
LOG.info("Neutron Hostconfig DataChange listener registration {}", dataTreeIdentifier);
listenerRegistration = dataBroker.registerDataTreeChangeListener(dataTreeIdentifier, this);
}
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
</blueprint>
<name>ODL :: neutron :: ${project.artifactId}</name>
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.neutron</groupId>
package org.opendaylight.neutron.hostconfig.utils;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import com.google.common.base.Throwables;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.hostconfig.rev150712.hostconfig.attributes.Hostconfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.hostconfig.rev150712.hostconfig.attributes.hostconfigs.Hostconfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.hostconfig.rev150712.hostconfig.attributes.hostconfigs.HostconfigBuilder;
public class NeutronHostconfigUtils {
private static final Logger LOG = LoggerFactory.getLogger(NeutronHostconfigUtils.class);
+ private static final InstanceIdentifier<Hostconfigs> HOSTCONFIGS = InstanceIdentifier.builder(Neutron.class)
+ .child(Hostconfigs.class).build();
+
private final DataBroker dataBroker;
public enum Action {
final WriteTransaction writeTx = dataBroker.newWriteOnlyTransaction();
hostConfigId = createInstanceIdentifier(hostConfig);
writeTx.put(LogicalDatastoreType.OPERATIONAL, hostConfigId, hostConfig, true);
- writeTx.submit().checkedGet();
+ commit(writeTx);
LOG.trace("Hostconfig updated for node {}", hostConfig.getHostId());
break;
case DELETE:
final WriteTransaction delTx = dataBroker.newWriteOnlyTransaction();
hostConfigId = createInstanceIdentifier(hostConfig);
delTx.delete(LogicalDatastoreType.OPERATIONAL, hostConfigId);
+ commit(delTx);
LOG.trace("Hostconfig deleted for node {}", hostConfig.getHostId());
- delTx.submit().checkedGet();
break;
default:
break;
return hostconfigBuilder.build();
}
- private InstanceIdentifier<Hostconfig> createInstanceIdentifier(Hostconfig hostconfig) {
- return InstanceIdentifier.create(Neutron.class).child(Hostconfigs.class)
- .child(Hostconfig.class, hostconfig.key());
+ private static void commit(WriteTransaction tx) throws TransactionCommitFailedException {
+ try {
+ tx.commit().get();
+ } catch (InterruptedException e) {
+ throw new TransactionCommitFailedException("Interrupted while waiting", e);
+ } catch (ExecutionException e) {
+ LOG.debug("Commit failed", e);
+ Throwables.throwIfInstanceOf(e.getCause(), TransactionCommitFailedException.class);
+ throw new TransactionCommitFailedException("Commit failed", e);
+ }
+ }
+
+ private static InstanceIdentifier<Hostconfig> createInstanceIdentifier(Hostconfig hostconfig) {
+ return HOSTCONFIGS.child(Hostconfig.class, hostconfig.key());
}
}
<artifactId>sal-netconf-connector</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
- <type>test-jar</type>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-broker-impl</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-dom-adapter</artifactId>
+ <type>test-jar</type>
<scope>test</scope>
</dependency>
</dependencies>
* 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.neutron.hostconfig.vpp;
import com.google.common.base.Preconditions;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;
-
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.neutron.hostconfig.utils.NeutronHostconfigUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
public void init() {
LOG.info("Initializing {}", getClass().getSimpleName());
- DataTreeIdentifier<Node> dataTreeIdentifier = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ DataTreeIdentifier<Node> dataTreeIdentifier = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, new TopologyKey(TOPOLOGY_NETCONF))
.child(Node.class)
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
<cm:property-placeholder persistent-id="org.opendaylight.neutron.hostconfig.vpp.startup" update-strategy="none">
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
import java.util.Set;
-import org.opendaylight.controller.md.sal.binding.test.AbstractConcurrentDataBrokerTest;
+import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
package org.opendaylight.neutron.hostconfig.vpp;
import com.google.common.util.concurrent.SettableFuture;
-
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-
import org.eclipse.jdt.annotation.NonNull;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataObjectModification.ModificationType;
+import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus;
@Before
public void init() throws InterruptedException, ExecutionException {
- DataTreeIdentifier<Hostconfig> dataTreeIdentifier = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ DataTreeIdentifier<Hostconfig> dataTreeIdentifier = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
hostConfigIid(NODE_ID).firstIdentifierOf(Hostconfigs.class).builder().child(Hostconfig.class).build());
listenerRegistration = getDataBroker().registerDataTreeChangeListener(dataTreeIdentifier,
NeutronHostconfigVppListenerTest.this);
createNetconfNode(NODE_ID, V3PO_1704_CAPABILITY, V3PO_1701_CAPABILITY, INTERFACES);
WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.put(LogicalDatastoreType.OPERATIONAL, iid, node1, true);
- writeTx.submit().get();
+ writeTx.commit().get();
Assert.assertEquals(sf.get(), Integer.valueOf(1));
sf = SettableFuture.create();
writeTx = getDataBroker().newWriteOnlyTransaction();
writeTx.delete(LogicalDatastoreType.OPERATIONAL, iid);
- writeTx.submit().get();
+ writeTx.commit().get();
Assert.assertEquals(sf.get(), Integer.valueOf(2));
}
<name>ODL :: neutron :: ${project.artifactId}</name>
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.neutron</groupId>
* 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.neutron.logger;
import com.google.common.base.Preconditions;
import javax.annotation.PreDestroy;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
-import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataObjectModification;
+import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
+import org.opendaylight.mdsal.binding.api.DataTreeModification;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
LOG.info("Register listener for Neutron model data changes");
InstanceIdentifier<Neutron> instanceId = Preconditions.checkNotNull(InstanceIdentifier.create(Neutron.class));
- DataTreeIdentifier<Neutron> configurationDataTreeId = new DataTreeIdentifier<>(
+ DataTreeIdentifier<Neutron> configurationDataTreeId = DataTreeIdentifier.create(
LogicalDatastoreType.CONFIGURATION, instanceId);
configurationDataTreeChangeListener = changes -> logChanges("Configuration DataTreeChanged ", changes);
configurationRegisteredListener = db.registerDataTreeChangeListener(configurationDataTreeId,
configurationDataTreeChangeListener);
- DataTreeIdentifier<
- Neutron> operationalDataTreeId = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, instanceId);
+ DataTreeIdentifier<Neutron> operationalDataTreeId = DataTreeIdentifier.create(
+ LogicalDatastoreType.OPERATIONAL, instanceId);
operationalDataTreeChangeListener = changes -> logChanges("Operational DataTreeChanged ", changes);
operationalRegisteredListener = db.registerDataTreeChangeListener(operationalDataTreeId,
operationalDataTreeChangeListener);
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
</blueprint>
<artifactId>yang-ext</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-common-api</artifactId>
</dependency>
<dependency>
<groupId>commons-net</groupId>
package org.opendaylight.neutron.spi;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.ReadOperations;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
/**
* @return boolean
* @throws ReadFailedException if the read failed
*/
- boolean exists(String uuid, ReadTransaction tx) throws ReadFailedException;
+ boolean exists(String uuid, ReadOperations tx) throws ReadFailedException;
/**
* Applications call this interface method to return if a particular
package org.opendaylight.neutron.spi;
import java.util.List;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
/**
*/
package org.opendaylight.neutron.spi;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
/**
*/
package org.opendaylight.neutron.spi;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
/**
* {@link ReadFailedException} as an unchecked RuntimeException.
<dependencies>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-common-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-common-api</artifactId>
</dependency>
<dependency>
<groupId>com.webcohesion.enunciate</groupId>
import java.util.List;
import java.util.Objects;
import javax.ws.rs.core.Response;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.neutron.spi.INeutronCRUD;
import org.opendaylight.neutron.spi.INeutronCRUD.Result;
import org.opendaylight.neutron.spi.INeutronObject;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
) {
INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
try {
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
if (!loadBalancerPoolInterface.exists(loadBalancerPoolUUID, tx)) {
throw new ResourceNotFoundException(uuidNoExist());
}
try {
INeutronLoadBalancerPoolCRUD loadBalancerPoolInterface = getNeutronCRUD();
- try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction tx = dataBroker.newReadOnlyTransaction()) {
if (!loadBalancerPoolInterface.exists(loadBalancerPoolUUID, tx)) {
throw new ResourceNotFoundException(uuidNoExist());
}
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.apache.aries.blueprint.annotation.service.Reference;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.neutron.spi.INeutronTapFlowCRUD;
import org.opendaylight.neutron.spi.NeutronTapFlow;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
<groupId>org.apache.aries.blueprint</groupId>
<artifactId>blueprint-maven-plugin-annotation</artifactId>
<optional>true</optional>
- </dependency>
+ </dependency>
<dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>sal-binding-api</artifactId>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.neutron</groupId>
package org.opendaylight.neutron.transcriber;
import java.lang.reflect.Type;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronObject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yangtools.concepts.Builder;
package org.opendaylight.neutron.transcriber;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.base.Throwables;
+import com.google.common.util.concurrent.FluentFuture;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ExecutionException;
import javax.annotation.PreDestroy;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.infrautils.utils.function.CheckedFunction;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadOperations;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.neutron.spi.INeutronAdminAttributes;
import org.opendaylight.neutron.spi.INeutronBaseAttributes;
import org.opendaylight.neutron.spi.INeutronCRUD;
protected abstract S fromMd(T dataObject);
- private <W extends DataObject> W readMd(InstanceIdentifier<W> path, ReadTransaction tx) throws ReadFailedException {
- Preconditions.checkNotNull(tx);
- W result = null;
- final CheckedFuture<Optional<W>,
- ReadFailedException> future = tx.read(LogicalDatastoreType.CONFIGURATION, path);
- if (future != null) {
- Optional<W> optional = future.checkedGet();
- if (optional.isPresent()) {
- result = optional.get();
- }
+ private <W extends DataObject> W readMd(InstanceIdentifier<W> path, ReadOperations tx) throws ReadFailedException {
+ final FluentFuture<Optional<W>> future = Preconditions.checkNotNull(tx).read(LogicalDatastoreType.CONFIGURATION,
+ path);
+ try {
+ return future.get().orElse(null);
+ } catch (InterruptedException e) {
+ throw new ReadFailedException("Interrupted while waiting for read of " + path, e);
+ } catch (ExecutionException e) {
+ Throwables.throwIfInstanceOf(e.getCause(), ReadFailedException.class);
+ throw new ReadFailedException("Read of " + path + " failed", e);
}
- return result;
}
protected <W extends DataObject> W readMd(InstanceIdentifier<W> path) throws ReadFailedException {
- try (ReadOnlyTransaction tx = getDataBroker().newReadOnlyTransaction()) {
+ try (ReadTransaction tx = getDataBroker().newReadOnlyTransaction()) {
return readMd(path, tx);
}
}
final T item = toMd(neutronObject);
final InstanceIdentifier<T> iid = createInstanceIdentifier(item);
tx.put(LogicalDatastoreType.CONFIGURATION, iid, item, true);
- final CheckedFuture<Void, TransactionCommitFailedException> future = tx.submit();
// Check if it's successfully committed, otherwise exception will be thrown.
- future.checkedGet();
+ checkedCommit(tx);
}
private void removeMd(T item, WriteTransaction tx) throws TransactionCommitFailedException {
Preconditions.checkNotNull(tx);
final InstanceIdentifier<T> iid = createInstanceIdentifier(item);
tx.delete(LogicalDatastoreType.CONFIGURATION, iid);
- final CheckedFuture<Void, TransactionCommitFailedException> future = tx.submit();
// Check if it's successfully committed, otherwise exception will be thrown.
- future.checkedGet();
+ checkedCommit(tx);
}
protected static Uuid toUuid(String uuid) {
}
@Override
- public boolean exists(String uuid, ReadTransaction tx) throws ReadFailedException {
+ public boolean exists(String uuid, ReadOperations tx) throws ReadFailedException {
Preconditions.checkNotNull(tx);
final T dataObject = readMd(createInstanceIdentifier(toMd(uuid)), tx);
return dataObject != null;
@Override
public S get(String uuid) throws ReadFailedException {
- try (ReadOnlyTransaction tx = getDataBroker().newReadOnlyTransaction()) {
+ try (ReadTransaction tx = getDataBroker().newReadOnlyTransaction()) {
return get(uuid, tx);
}
}
@Override
public List<S> getAll() throws ReadFailedRuntimeException {
- try (ReadOnlyTransaction tx = getDataBroker().newReadOnlyTransaction()) {
+ try (ReadTransaction tx = getDataBroker().newReadOnlyTransaction()) {
try {
return getAll(tx);
} catch (ReadFailedException e) {
* Default implementation just returns true. Some but not all transcribers will customize this.
*
* <p>Implementations *MUST* use the passed in transaction. They will typically call the
- * {@link #exists(String, ReadTransaction)} method on ANOTHER transcriber with it.
+ * {@link #exists(String, ReadOperations)} method on ANOTHER transcriber with it.
*
* <p>Implementations should chain {@link #ifNonNull(Object, CheckedFunction)}, or perform null safe comparisons
* otherwise, for both optional non-mandatory {@link NeutronObject} as well as mandatory properties which may well
*
* @throws ReadFailedException in case of a data store problem
*/
- protected boolean areAllDependenciesAvailable(ReadTransaction tx, S neutronObject) throws ReadFailedException {
+ protected boolean areAllDependenciesAvailable(ReadOperations tx, S neutronObject) throws ReadFailedException {
return true;
}
/**
* Utility to perform well readable code of null-safe chains of e.g.
- * {@link #exists(String, ReadTransaction)} method calls.
+ * {@link #exists(String, ReadOperations)} method calls.
*
* @throws ReadFailedException in case of a data store problem
*/
}
}
+ protected static final void checkedCommit(WriteTransaction tx) throws TransactionCommitFailedException {
+ final FluentFuture<?> future = tx.commit();
+ try {
+ future.get();
+ } catch (InterruptedException e) {
+ throw new TransactionCommitFailedException("Interrupted while waiting for commit", e);
+ } catch (ExecutionException e) {
+ Throwables.throwIfInstanceOf(e.getCause(), TransactionCommitFailedException.class);
+ throw new TransactionCommitFailedException("Transaction commit failed", e);
+ }
+ }
}
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronBgpvpnCRUD;
import org.opendaylight.neutron.spi.NeutronBgpvpn;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronFirewallCRUD;
import org.opendaylight.neutron.spi.NeutronFirewall;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.fwaas.rev150712.firewalls.attributes.Firewalls;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronFirewallPolicyCRUD;
import org.opendaylight.neutron.spi.NeutronFirewallPolicy;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.fwaas.rev150712.policies.attributes.FirewallPolicies;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.northbound.api.BadRequestException;
import org.opendaylight.neutron.spi.INeutronFirewallRuleCRUD;
import org.opendaylight.neutron.spi.NeutronFirewallRule;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronFloatingIpCRUD;
import org.opendaylight.neutron.spi.NeutronFloatingIp;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronL2gatewayConnectionCRUD;
import org.opendaylight.neutron.spi.NeutronL2gatewayConnection;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l2gateways.rev150712.l2gateway.connections.attributes.L2gatewayConnections;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronL2gatewayCRUD;
import org.opendaylight.neutron.spi.NeutronL2gateway;
import org.opendaylight.neutron.spi.NeutronL2gatewayDevice;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronLoadBalancerHealthMonitorCRUD;
import org.opendaylight.neutron.spi.NeutronID;
import org.opendaylight.neutron.spi.NeutronLoadBalancerHealthMonitor;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronLoadBalancerCRUD;
import org.opendaylight.neutron.spi.NeutronLoadBalancer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.northbound.api.BadRequestException;
import org.opendaylight.neutron.spi.INeutronLoadBalancerListenerCRUD;
import org.opendaylight.neutron.spi.NeutronID;
*/
package org.opendaylight.neutron.transcriber;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableBiMap;
-import com.google.common.util.concurrent.CheckedFuture;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
import org.opendaylight.neutron.spi.NeutronID;
import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.lbaas.attributes.pools.pool.members.MemberBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.lbaasv2.rev150712.pool.attributes.SessionPersistenceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.OperationFailedException;
import org.slf4j.Logger;
@Override
public boolean neutronLoadBalancerPoolMemberExists(String poolUuid, String uuid) throws ReadFailedException {
- final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
+ final Member member = readMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
if (member == null) {
return false;
}
@Override
public NeutronLoadBalancerPoolMember getNeutronLoadBalancerPoolMember(String poolUuid, String uuid)
throws ReadFailedException {
- final Member member = readMemberMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
+ final Member member = readMd(createMemberInstanceIdentifier(toMd(poolUuid), toMemberMd(uuid)));
if (member == null) {
return null;
}
return memberBuilder.build();
}
- private <T extends DataObject> T readMemberMd(InstanceIdentifier<T> path) throws ReadFailedException {
- T result = null;
- try (ReadOnlyTransaction transaction = getDataBroker().newReadOnlyTransaction()) {
- final CheckedFuture<Optional<T>, ReadFailedException> future = transaction
- .read(LogicalDatastoreType.CONFIGURATION, path);
- if (future != null) {
- Optional<T> optional;
- optional = future.checkedGet();
- if (optional.isPresent()) {
- result = optional.get();
- }
- }
- }
- return result;
- }
-
private void addMemberMd(Pool pool, NeutronLoadBalancerPoolMember neutronObject)
throws TransactionCommitFailedException {
// TODO think about adding existence logic
final Member item = toMemberMd(neutronObject);
final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item, true);
- transaction.submit().checkedGet();
+ checkedCommit(transaction);
}
private void removeMemberMd(Pool pool, Member item) throws TransactionCommitFailedException {
final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
final InstanceIdentifier<Member> iid = createMemberInstanceIdentifier(pool, item);
transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
- transaction.submit().checkedGet();
+ checkedCommit(transaction);
}
}
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronMeteringLabelCRUD;
import org.opendaylight.neutron.spi.NeutronMeteringLabel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.metering.rev150712.metering.labels.attributes.MeteringLabels;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronMeteringLabelRuleCRUD;
import org.opendaylight.neutron.spi.NeutronMeteringLabelRule;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadOperations;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.neutron.spi.NeutronNetworkSegment;
}
@Override
- protected boolean areAllDependenciesAvailable(ReadTransaction tx, NeutronNetwork network)
+ protected boolean areAllDependenciesAvailable(ReadOperations tx, NeutronNetwork network)
throws ReadFailedException {
return ifNonNull(network.getQosPolicyId(), qosPolicyId -> qosPolicyInterface.exists(qosPolicyId, tx));
}
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronPortCRUD;
import org.opendaylight.neutron.spi.NeutronIps;
import org.opendaylight.neutron.spi.NeutronPort;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronQosPolicyCRUD;
import org.opendaylight.neutron.spi.NeutronQosBandwidthLimitRule;
import org.opendaylight.neutron.spi.NeutronQosDscpMarkingRule;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronRouterCRUD;
import org.opendaylight.neutron.spi.NeutronIps;
import org.opendaylight.neutron.spi.NeutronRoute;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.northbound.api.BadRequestException;
import org.opendaylight.neutron.spi.INeutronSFCFlowClassifierCRUD;
import org.opendaylight.neutron.spi.NeutronSFCFlowClassifier;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronSFCPortChainCRUD;
import org.opendaylight.neutron.spi.NeutronSFCPortChain;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronSFCPortPairGroupCRUD;
import org.opendaylight.neutron.spi.NeutronSFCPortPairGroup;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronSFCPortPairCRUD;
import org.opendaylight.neutron.spi.NeutronSFCPortPair;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronSecurityGroupCRUD;
import org.opendaylight.neutron.spi.NeutronSecurityGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev150712.security.groups.attributes.SecurityGroups;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadOperations;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.neutron.northbound.api.BadRequestException;
import org.opendaylight.neutron.spi.INeutronSecurityRuleCRUD;
import org.opendaylight.neutron.spi.NeutronSecurityRule;
}
@Override
- protected boolean areAllDependenciesAvailable(ReadTransaction tx, NeutronSecurityRule securityRule)
+ protected boolean areAllDependenciesAvailable(ReadOperations tx, NeutronSecurityRule securityRule)
throws ReadFailedException {
return ifNonNull(securityRule.getSecurityRuleGroupID(),
groupID -> securityGroupInterface.exists(groupID, tx))
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
import org.opendaylight.neutron.spi.NeutronRoute;
import org.opendaylight.neutron.spi.NeutronSubnet;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.mdsal.common.api.ReadFailedException;
+import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
import org.opendaylight.neutron.spi.INeutronTapFlowCRUD;
import org.opendaylight.neutron.spi.NeutronTapFlow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
final TapFlow item = toMd(tapFlow);
final InstanceIdentifier<TapFlow> iid = createTapFlowInstanceIdentifier(tapFlow.getTapFlowServiceID(), item);
transaction.put(LogicalDatastoreType.CONFIGURATION, iid, item, true);
- transaction.submit().checkedGet();
+ checkedCommit(transaction);
}
private void removeTapFlowMd(String tapServiceUUID, String tapFlowUUID) throws TransactionCommitFailedException {
final WriteTransaction transaction = getDataBroker().newWriteOnlyTransaction();
final InstanceIdentifier<TapFlow> iid = createTapFlowInstanceIdentifier(tapServiceUUID, toMd(tapFlowUUID));
transaction.delete(LogicalDatastoreType.CONFIGURATION, iid);
- transaction.submit().checkedGet();
+ checkedCommit(transaction);
}
private void addTapFlowMd(NeutronTapFlow tapFlow) throws TransactionCommitFailedException {
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronTapServiceCRUD;
import org.opendaylight.neutron.spi.NeutronTapService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.tapaas.rev171024.tap.services.attributes.TapServices;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronTrunkCRUD;
import org.opendaylight.neutron.spi.NeutronTrunk;
import org.opendaylight.neutron.spi.NeutronTrunkSubPort;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronVpnIkePolicyCRUD;
import org.opendaylight.neutron.spi.NeutronVpnIkePolicy;
import org.opendaylight.neutron.spi.NeutronVpnLifetime;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronVpnIpSecPolicyCRUD;
import org.opendaylight.neutron.spi.NeutronVpnIpSecPolicy;
import org.opendaylight.neutron.spi.NeutronVpnLifetime;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronVpnIpSecSiteConnectionsCRUD;
import org.opendaylight.neutron.spi.NeutronVpnDeadPeerDetection;
import org.opendaylight.neutron.spi.NeutronVpnIpSecSiteConnection;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.apache.aries.blueprint.annotation.service.Service;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.neutron.spi.INeutronVpnServiceCRUD;
import org.opendaylight.neutron.spi.NeutronVpnService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.vpnaas.rev150712.vpnservices.attributes.VpnServices;
odl:use-default-for-reference-types="true">
<reference id="dataBroker"
- interface="org.opendaylight.controller.md.sal.binding.api.DataBroker"
+ interface="org.opendaylight.mdsal.binding.api.DataBroker"
odl:type="default" />
</blueprint>