<parent>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>binding-parent</artifactId>
- <version>8.0.11</version>
+ <version>9.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>2.0.13</version>
+ <version>3.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>aaa-artifacts</artifactId>
- <version>0.14.10</version>
+ <version>0.15.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.controller</groupId>
<artifactId>mdsal-it-parent</artifactId>
- <version>4.0.10</version>
+ <version>5.0.1</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>8.0.11</version>
+ <version>9.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>8.0.11</version>
+ <version>9.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-hwvtepsouthbound-api-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-hwvtepsouthbound-api" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[8,9)">odl-mdsal-model-odl-l2-types</feature>
+ <feature version="[9,10)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[9,10)">odl-mdsal-model-odl-l2-types</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-restconf</artifactId>
- <version>2.0.14</version>
+ <version>3.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-mdsal-apidocs</artifactId>
- <version>2.0.14</version>
+ <version>3.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.ovsdb</groupId>
<name>ODL :: ovsdb :: ${project.artifactId}</name>
<dependencies>
- <dependency>
- <groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-util</artifactId>
<artifactId>org.apache.karaf.shell.core</artifactId>
<scope>provided</scope>
</dependency>
+ <dependency>
+ <!-- FIXME: needed because of OsgiCommandSupport -->
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.framework</artifactId>
+ </dependency>
<!-- Testing Dependencies -->
<dependency>
return entityConnectionMap.get(entity);
}
- private static class HwvtepDeviceEntityOwnershipListener implements EntityOwnershipListener {
+ private static final class HwvtepDeviceEntityOwnershipListener implements EntityOwnershipListener {
private final HwvtepConnectionManager hcm;
private final EntityOwnershipListenerRegistration listenerRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepDataChangeListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public final class HwvtepDataChangeListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
private ListenerRegistration<HwvtepDataChangeListener> registration;
private final HwvtepConnectionManager hcm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepOperGlobalListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public final class HwvtepOperGlobalListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepOperGlobalListener.class);
private static final Map<InstanceIdentifier<Node>, ConnectionInfo> NODE_CONNECTION_INFO = new ConcurrentHashMap<>();
}
}
- private static class HwvtepsbPluginInstanceEntityOwnershipListener implements EntityOwnershipListener {
+ private static final class HwvtepsbPluginInstanceEntityOwnershipListener implements EntityOwnershipListener {
private final HwvtepSouthboundProvider hsp;
private final EntityOwnershipListenerRegistration listenerRegistration;
import static java.util.Objects.requireNonNull;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
// Prevent instantiating a utility class
}
- // FIXME: eliminate this static wiring by encaspulating the codec into a service
- @Deprecated
+ // FIXME: eliminate this static wiring by encapsulating the codec into a service
+ @Deprecated(forRemoval = true)
+ @SuppressFBWarnings("EI_EXPOSE_STATIC_REP2")
public static void setInstanceIdentifierCodec(InstanceIdentifierCodec iidc) {
instanceIdentifierCodec = iidc;
}
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
import org.opendaylight.yangtools.yang.model.api.Module;
-public class InstanceIdentifierCodec
+public final class InstanceIdentifierCodec
// FIXME: this really wants to be wired as yangtools-data-codec-gson's codecs, because ...
extends AbstractModuleStringInstanceIdentifierCodec implements EffectiveModelContextListener {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepReconciliationManager implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
-
+public final class HwvtepReconciliationManager implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepReconciliationManager.class);
+
private final ListenerRegistration<HwvtepReconciliationManager> registration;
private final HwvtepConnectionManager hcm;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
}
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void removeLogicalRouter(final TransactionBuilder transaction,
final InstanceIdentifier<Node> instanceIdentifier, final List<LogicalRouters> routerList) {
for (LogicalRouters lrouter: routerList) {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class LogicalSwitchUcastsRemoveCommand
+public final class LogicalSwitchUcastsRemoveCommand
extends AbstractTransactCommand<LogicalSwitches, LogicalSwitchesKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(LogicalSwitchUcastsRemoveCommand.class);
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class PhysicalSwitchUpdateCommand extends AbstractTransactCommand {
+public final class PhysicalSwitchUpdateCommand extends AbstractTransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(PhysicalSwitchUpdateCommand.class);
public PhysicalSwitchUpdateCommand(final HwvtepOperationalState state,
if (bfdParams != null) {
Map<String, String> bfdParamMap = new HashMap<>();
for (BfdParams bfdParam : bfdParams.values()) {
- bfdParamMap.put(bfdParam.getBfdParamKey(), bfdParam.getBfdParamValue());
- }
- try {
- tunnel.setBfdParams(ImmutableMap.copyOf(bfdParamMap));
- } catch (NullPointerException e) {
- LOG.warn("Incomplete BFD Params for tunnel", e);
+ bfdParamMap.put(bfdParam.requireBfdParamKey(), bfdParam.requireBfdParamValue());
}
+ tunnel.setBfdParams(ImmutableMap.copyOf(bfdParamMap));
}
}
if (bfdLocalConfigs != null) {
Map<String, String> configLocalMap = new HashMap<>();
for (BfdLocalConfigs localConfig : bfdLocalConfigs.values()) {
- configLocalMap.put(localConfig.getBfdLocalConfigKey(), localConfig.getBfdLocalConfigValue());
- }
- try {
- tunnel.setBfdConfigLocal(ImmutableMap.copyOf(configLocalMap));
- } catch (NullPointerException e) {
- LOG.warn("Incomplete BFD LocalConfig for tunnel", e);
+ configLocalMap.put(localConfig.requireBfdLocalConfigKey(), localConfig.requireBfdLocalConfigValue());
}
+ tunnel.setBfdConfigLocal(ImmutableMap.copyOf(configLocalMap));
}
}
if (bfdRemoteConfigs != null) {
Map<String, String> configRemoteMap = new HashMap<>();
for (BfdRemoteConfigs remoteConfig : bfdRemoteConfigs.values()) {
- configRemoteMap.put(remoteConfig.getBfdRemoteConfigKey(), remoteConfig.getBfdRemoteConfigValue());
- }
- try {
- tunnel.setBfdConfigRemote(ImmutableMap.copyOf(configRemoteMap));
- } catch (NullPointerException e) {
- LOG.warn("Incomplete BFD RemoteConfig for tunnel", e);
+ configRemoteMap.put(remoteConfig.requireBfdRemoteConfigKey(),
+ remoteConfig.requireBfdRemoteConfigValue());
}
+ tunnel.setBfdConfigRemote(ImmutableMap.copyOf(configRemoteMap));
}
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class PlainLogicalSwitchRemoveCmd
+public final class PlainLogicalSwitchRemoveCmd
extends AbstractTransactCommand<LogicalSwitches, LogicalSwitchesKey, HwvtepGlobalAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(PlainLogicalSwitchRemoveCmd.class);
@Override
public void execute(TransactionBuilder transaction) {
- for (TransactCommand command:commands) {
- try {
- command.execute(transaction);
- } catch (NullPointerException e) {
- LOG.error("Execution of command {} failed with the following exception."
- + " Continuing the execution of remaining commands", command, e);
- }
+ for (TransactCommand command : commands) {
+ command.execute(transaction);
}
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class GlobalUpdateCommand extends AbstractTransactionCommand {
+public final class GlobalUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(GlobalUpdateCommand.class);
private final Map<UUID, Global> updatedHwvtepRows =
import org.slf4j.LoggerFactory;
-public class HwvtepLogicalRouterUpdateCommand extends AbstractTransactionCommand {
+public final class HwvtepLogicalRouterUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepLogicalRouterUpdateCommand.class);
+
private final Map<UUID, LogicalRouter> updatedLRRows;
public HwvtepLogicalRouterUpdateCommand(HwvtepConnectionInstance key, TableUpdates updates,
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepLogicalSwitchUpdateCommand extends AbstractTransactionCommand {
+public final class HwvtepLogicalSwitchUpdateCommand extends AbstractTransactionCommand {
+ private static final Logger LOG = LoggerFactory.getLogger(HwvtepLogicalSwitchUpdateCommand.class);
private final Map<UUID, LogicalSwitch> updatedLSRows;
- private static final Logger LOG = LoggerFactory.getLogger(HwvtepLogicalSwitchUpdateCommand.class);
public HwvtepLogicalSwitchUpdateCommand(HwvtepConnectionInstance key, TableUpdates updates,
DatabaseSchema dbSchema) {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepManagerUpdateCommand extends AbstractTransactionCommand {
-
+public final class HwvtepManagerUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepManagerUpdateCommand.class);
+
private final Map<UUID, Manager> updatedMgrRows;
private final Map<UUID, Manager> oldMgrRows;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class HwvtepMcastMacsLocalUpdateCommand extends AbstractTransactionCommand {
+public final class HwvtepMcastMacsLocalUpdateCommand extends AbstractTransactionCommand {
private final Map<UUID, McastMacsLocal> updatedMMacsLocalRows;
private final Map<UUID, PhysicalLocatorSet> updatedPLocSetRows;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class HwvtepMcastMacsRemoteUpdateCommand extends AbstractTransactionCommand {
-
+public final class HwvtepMcastMacsRemoteUpdateCommand extends AbstractTransactionCommand {
private final Map<UUID, McastMacsRemote> updatedMMacsRemoteRows;
private final Map<UUID, PhysicalLocatorSet> updatedPLocSetRows;
private final Map<UUID, PhysicalLocator> updatedPLocRows;
import java.util.ArrayList;
import java.util.List;
-import java.util.NoSuchElementException;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.hwvtepsouthbound.HwvtepConnectionInstance;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepOperationalCommandAggregator implements TransactionCommand {
-
+public final class HwvtepOperationalCommandAggregator implements TransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepOperationalCommandAggregator.class);
+
private List<TransactionCommand> commands = new ArrayList<>();
private final HwvtepConnectionInstance connectionInstance;
@Override
public void execute(ReadWriteTransaction transaction) {
for (TransactionCommand command: commands) {
- try {
- // This may be noisy, can be silenced if needed.
- LOG.trace("Executing command {}", command);
- command.execute(transaction);
- } catch (NullPointerException | NoSuchElementException | ClassCastException e) {
- LOG.error("Execution of command {} failed with the following exception."
- + " Continuing the execution of remaining commands", command, e);
- }
-
+ // This may be noisy, can be silenced if needed.
+ LOG.trace("Executing command {}", command);
+ command.execute(transaction);
}
connectionInstance.getDeviceInfo().onOperDataAvailable();
}
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class HwvtepPhysicalLocatorUpdateCommand extends AbstractTransactionCommand {
-
+public final class HwvtepPhysicalLocatorUpdateCommand extends AbstractTransactionCommand {
private final Map<UUID, PhysicalLocator> updatedPLocRows;
private final Map<UUID, PhysicalLocator> oldPLocRows;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepPhysicalPortUpdateCommand extends AbstractTransactionCommand {
+public final class HwvtepPhysicalPortUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepPhysicalPortUpdateCommand.class);
private final Map<UUID, PhysicalPort> updatedPPRows;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepPhysicalSwitchUpdateCommand extends AbstractTransactionCommand {
-
+public final class HwvtepPhysicalSwitchUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepPhysicalSwitchUpdateCommand.class);
+
private final Map<UUID, PhysicalSwitch> updatedPSRows;
private Map<UUID, Tunnel> updatedTunnelRows;
private final Map<UUID, PhysicalSwitch> oldPSRows;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepTunnelRemoveCommand extends AbstractTransactionCommand {
-
+public final class HwvtepTunnelRemoveCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepTunnelRemoveCommand.class);
+
Collection<Tunnel> deletedTunnelRows = null;
public HwvtepTunnelRemoveCommand(HwvtepConnectionInstance key, TableUpdates updates, DatabaseSchema dbSchema) {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepTunnelUpdateCommand extends AbstractTransactionCommand {
-
+public final class HwvtepTunnelUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepTunnelUpdateCommand.class);
+
private Map<UUID, Tunnel> updatedTunnelRows;
public HwvtepTunnelUpdateCommand(HwvtepConnectionInstance key, TableUpdates updates, DatabaseSchema dbSchema) {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class HwvtepUcastMacsLocalUpdateCommand extends AbstractTransactionCommand {
-
+public final class HwvtepUcastMacsLocalUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(HwvtepUcastMacsLocalUpdateCommand.class);
+
private final Map<UUID, UcastMacsLocal> updatedUMacsLocalRows;
private final Map<UUID, PhysicalLocator> updatedPLocRows;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.util.BindingMap;
-public class HwvtepUcastMacsRemoteUpdateCommand extends AbstractTransactionCommand {
+public final class HwvtepUcastMacsRemoteUpdateCommand extends AbstractTransactionCommand {
private final Map<UUID, UcastMacsRemote> updatedUMacsRemoteRows;
private final Map<UUID, PhysicalLocator> updatedPLocRows;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import java.lang.Thread.UncaughtExceptionHandler;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
* Copied over as-is from southbound plugin. Good candidate to be common
* when refactoring code.
*/
-public class TransactionInvokerImpl implements TransactionInvoker,TransactionChainListener, Runnable, AutoCloseable,
- Thread.UncaughtExceptionHandler {
+public final class TransactionInvokerImpl implements TransactionInvoker, TransactionChainListener, Runnable,
+ AutoCloseable, UncaughtExceptionHandler {
private static final Logger LOG = LoggerFactory.getLogger(TransactionInvokerImpl.class);
private static final int QUEUE_SIZE = 10000;
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
+ <artifactId>org.osgi.framework</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>odl-aaa-cert</artifactId>
- <version>0.14.10</version>
+ <version>0.15.1</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
-->
<features name="odl-ovsdb-library-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-library" version="${project.version}">
- <feature version="[9,10)">odl-jackson-2.12</feature>
- <feature version="[9,10)">odl-netty-4</feature>
- <feature version="[0.14,1)">odl-aaa-cert</feature>
+ <feature version="[10,11)">odl-jackson-2.12</feature>
+ <feature version="[10,11)">odl-netty-4</feature>
+ <feature version="[0.15,1)">odl-aaa-cert</feature>
<configfile finalname="etc/org.opendaylight.ovsdb.library.cfg">
mvn:org.opendaylight.ovsdb/library/${project.version}/cfg/config
</configfile>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<groupId>org.opendaylight.ovsdb</groupId>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
- <dependency>
- <groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
- </dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
</dependency>
<dependency>
<groupId>io.netty</groupId>
- <artifactId>netty-transport-native-epoll</artifactId>
- <classifier>linux-x86_64</classifier>
+ <artifactId>netty-transport-classes-epoll</artifactId>
</dependency>
<dependency>
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
}, CONNECTION_NOTIFIER_SERVICE);
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private static void handleNewPassiveConnection(final Channel channel) {
if (!channel.isOpen()) {
LOG.warn("Channel {} is not open, skipped further processing of the connection.",channel);
return null;
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private static List<OvsdbClient> getPassiveClientsFromSameNode(final OvsdbClient ovsdbClient) {
List<OvsdbClient> passiveClients = new ArrayList<>();
for (OvsdbClient client : CONNECTIONS.keySet()) {
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>feature-repo-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-artifacts</artifactId>
- <version>8.0.11</version>
+ <version>9.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-southbound-api-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-southbound-api" version="${project.version}">
- <feature version="[8,9)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
- <feature version="[8,9)">odl-mdsal-model-odl-l2-types</feature>
+ <feature version="[9,10)">odl-mdsal-model-draft-clemm-netmod-yang-network-topo-01-minimal</feature>
+ <feature version="[9,10)">odl-mdsal-model-odl-l2-types</feature>
</feature>
</features>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-restconf</artifactId>
- <version>2.0.14</version>
+ <version>3.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>odl-mdsal-apidocs</artifactId>
- <version>2.0.14</version>
+ <version>3.0.0</version>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.infrautils</groupId>
<artifactId>infrautils-artifacts</artifactId>
- <version>2.0.13</version>
+ <version>3.0.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-southbound-impl-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-southbound-impl" version="${project.version}">
- <feature version="[9,10)">odl-jackson-2.12</feature>
- <feature version="[2,3)">odl-infrautils-diagstatus</feature>
- <feature version="[2,3)">odl-infrautils-ready</feature>
+ <feature version="[10,11)">odl-jackson-2.12</feature>
+ <feature version="[3,4)">odl-infrautils-diagstatus</feature>
+ <feature version="[3,4)">odl-infrautils-ready</feature>
<configfile finalname="etc/org.opendaylight.ovsdb.southbound.cfg">
mvn:org.opendaylight.ovsdb/southbound-impl/${project.version}/cfg/config
</configfile>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<name>ODL :: ovsdb :: ${project.artifactId}</name>
<properties>
<sonar.jacoco.itReportPath>../southbound-it/target/jacoco-it.exec</sonar.jacoco.itReportPath>
+ <!-- FIXME: clean up code to pass again -->
+ <odlparent.spotbugs.enforce>false</odlparent.spotbugs.enforce>
</properties>
<dependencies>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-test-utils</artifactId>
</dependency>
+
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <version>3.12.4</version>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito2</artifactId>
+ <version>2.0.9</version>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
+ <version>2.0.9</version>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.ovsdb</groupId>
*/
package org.opendaylight.ovsdb.southbound;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
private DataSchemaContextTree dataSchemaContextTree;
private SchemaContext context;
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
public InstanceIdentifierCodec(final DOMSchemaService schemaService,
final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer) {
schemaService.registerSchemaContextListener(this);
stampInstanceIdentifier(transaction, instanceIdentifier.firstIdentifierOf(Node.class),
instanceIdentifierCodec);
- try {
- ovs.setExternalIds(
- YangUtils.convertYangKeyValueListToMap(externalIds, OpenvswitchExternalIds::getExternalIdKey,
- OpenvswitchExternalIds::getExternalIdValue));
- Mutate<GenericTableSchema> mutate = op.mutate(ovs)
- .addMutation(ovs.getExternalIdsColumn().getSchema(),
- Mutator.INSERT,
- ovs.getExternalIdsColumn().getData());
- transaction.add(mutate);
- } catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB Node external IDs", e);
- }
-
-
+ ovs.setExternalIds(
+ YangUtils.convertYangKeyValueListToMap(externalIds, OpenvswitchExternalIds::requireExternalIdKey,
+ OpenvswitchExternalIds::requireExternalIdValue));
+ Mutate<GenericTableSchema> mutate = op.mutate(ovs)
+ .addMutation(ovs.getExternalIdsColumn().getSchema(),
+ Mutator.INSERT, ovs.getExternalIdsColumn().getData());
+ transaction.add(mutate);
Map<OpenvswitchOtherConfigsKey, OpenvswitchOtherConfigs> otherConfigs =
initialCreateData.getOpenvswitchOtherConfigs();
if (otherConfigs != null) {
- try {
- ovs.setOtherConfig(YangUtils.convertYangKeyValueListToMap(otherConfigs,
- OpenvswitchOtherConfigs::getOtherConfigKey,
- OpenvswitchOtherConfigs::getOtherConfigValue));
- transaction.add(op.mutate(ovs).addMutation(ovs.getOtherConfigColumn().getSchema(),
- Mutator.INSERT,
- ovs.getOtherConfigColumn().getData()));
- } catch (NullPointerException e) {
- LOG.warn("Incomplete OVSDB Node other_config", e);
- }
+ ovs.setOtherConfig(YangUtils.convertYangKeyValueListToMap(otherConfigs,
+ OpenvswitchOtherConfigs::requireOtherConfigKey, OpenvswitchOtherConfigs::requireOtherConfigValue));
+ transaction.add(op.mutate(ovs).addMutation(ovs.getOtherConfigColumn().getSchema(),
+ Mutator.INSERT, ovs.getOtherConfigColumn().getData()));
}
invoke(transaction);
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.UnknownHostException;
reconciliationManager.cancelTerminationPointReconciliation();
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private void handleOwnershipChanged(final EntityOwnershipChange ownershipChange) {
OvsdbConnectionInstance ovsdbConnectionInstance = getConnectionInstanceFromEntity(ownershipChange.getEntity());
LOG.debug("Ovsdb handleOwnershipChanged: {} event received for device {}",
reconciliationManager.enqueue(task);
}
- private static class OvsdbDeviceEntityOwnershipListener implements EntityOwnershipListener {
+ private static final class OvsdbDeviceEntityOwnershipListener implements EntityOwnershipListener {
private final OvsdbConnectionManager cm;
private final EntityOwnershipListenerRegistration listenerRegistration;
/**
* Data-tree change listener for OVSDB.
*/
-public class OvsdbDataTreeChangeListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public final class OvsdbDataTreeChangeListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
/** Our registration. */
private final ListenerRegistration<DataTreeChangeListener<Node>> registration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class OvsdbOperGlobalListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
+public final class OvsdbOperGlobalListener implements ClusteredDataTreeChangeListener<Node>, AutoCloseable {
public static final ConcurrentMap<InstanceIdentifier<Node>, Node> OPER_NODE_CACHE = new ConcurrentHashMap<>();
private static final Logger LOG = LoggerFactory.getLogger(OvsdbOperGlobalListener.class);
// FIXME: get rid of this static
@SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
private static DataBroker db;
+ // FIXME: get rid of this static
+ private static List<String> reconcileBridgeInclusionList = new ArrayList<>();
+ // FIXME: get rid of this static
+ private static List<String> reconcileBridgeExclusionList = new ArrayList<>();
public static DataBroker getDb() {
return db;
private final AtomicBoolean registered = new AtomicBoolean(false);
private ListenerRegistration<SouthboundProvider> operTopologyRegistration;
private final OvsdbDiagStatusProvider ovsdbStatusProvider;
- private static List<String> reconcileBridgeInclusionList = new ArrayList<>();
- private static List<String> reconcileBridgeExclusionList = new ArrayList<>();
private OvsdbUpgradeStateListener ovsdbUpgradeStateListener;
@Inject
}
}
- private static class SouthboundPluginInstanceEntityOwnershipListener implements EntityOwnershipListener {
+ private static final class SouthboundPluginInstanceEntityOwnershipListener implements EntityOwnershipListener {
private final SouthboundProvider sp;
private final EntityOwnershipListenerRegistration listenerRegistration;
}
}
+ @SuppressFBWarnings("EI_EXPOSE_STATIC_REP2")
public static void setBridgesReconciliationInclusionList(final List<String> bridgeList) {
reconcileBridgeInclusionList = bridgeList;
}
+ @SuppressFBWarnings("EI_EXPOSE_STATIC_REP2")
public static void setBridgesReconciliationExclusionList(final List<String> bridgeList) {
reconcileBridgeExclusionList = bridgeList;
}
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
+import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.slf4j.LoggerFactory;
public class BridgeUpdateCommand implements TransactCommand {
-
private static final Logger LOG = LoggerFactory.getLogger(BridgeUpdateCommand.class);
@Override
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void setOpenDaylightExternalIds(final Bridge bridge,
final InstanceIdentifier<OvsdbBridgeAugmentation> iid, final OvsdbBridgeAugmentation ovsdbManagedNode,
final InstanceIdentifierCodec instanceIdentifierCodec) {
bridge.setExternalIds(externalIdMap);
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void setOpenDaylightOtherConfig(final @NonNull Bridge bridge,
final @NonNull OvsdbBridgeAugmentation ovsdbManagedNode) {
try {
String portNamedUuid = "Port_" + SouthboundMapper.getRandomUuid();
Port port = transaction.getTypedRowWrapper(Port.class);
port.setName(ovsdbManagedNode.getBridgeName().getValue());
- port.setInterfaces(Collections.singleton(TransactUtils.extractNamedUuid(interfaceInsert)));
+ port.setInterfaces(Set.of(TransactUtils.extractNamedUuid(interfaceInsert)));
transaction.add(op.insert(port).withId(portNamedUuid));
- bridge.setPorts(Collections.singleton(new UUID(portNamedUuid)));
+ bridge.setPorts(Set.of(new UUID(portNamedUuid)));
}
private static Insert<GenericTableSchema> setInterface(final TransactionBuilder transaction,
final OvsdbBridgeAugmentation ovsdbManagedNode) {
if (ovsdbManagedNode.getFailMode() != null
&& SouthboundConstants.OVSDB_FAIL_MODE_MAP.get(ovsdbManagedNode.getFailMode()) != null) {
- bridge.setFailMode(Collections.singleton(
+ bridge.setFailMode(Set.of(
SouthboundConstants.OVSDB_FAIL_MODE_MAP.get(ovsdbManagedNode.getFailMode())));
}
}
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
instanceIdentifierCodec);
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void execute(final TransactionBuilder transaction,
final Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> updated,
final InstanceIdentifierCodec instanceIdentifierCodec) {
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
instanceIdentifierCodec);
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
final Map<InstanceIdentifier<QosEntries>, QosEntries> createdOrUpdated,
final InstanceIdentifierCodec instanceIdentifierCodec) {
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
instanceIdentifierCodec);
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void execute(final TransactionBuilder transaction, final BridgeOperationalState state,
final Map<InstanceIdentifier<Queues>, Queues> createdOrUpdated,
final InstanceIdentifierCodec instanceIdentifierCodec) {
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import org.slf4j.LoggerFactory;
public class TerminationPointCreateCommand implements TransactCommand {
-
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointCreateCommand.class);
@Override
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void createInterfaceOptions(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void createInterfaceExternalIds(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void createInterfaceOtherConfig(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void createInterfaceLldp(
final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void createInterfaceBfd(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void createPortExternalIds(final OvsdbTerminationPointAugmentation terminationPoint,
final Port port, final String opendaylightIid) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void createPortOtherConfig(
final OvsdbTerminationPointAugmentation terminationPoint,
final Port ovsPort) {
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void updateInterfaceOptions(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void updateInterfaceExternalIds(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void updateInterfaceLldp(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
try {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void updateInterfaceOtherConfig(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void updateInterfaceBfd(final OvsdbTerminationPointAugmentation terminationPoint,
final Interface ovsInterface) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void updatePortExternalIds(final OvsdbTerminationPointAugmentation terminationPoint,
final Port port, final String opendaylightIid) {
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
private static void updatePortOtherConfig(final OvsdbTerminationPointAugmentation terminationPoint,
final Port ovsPort) {
Map<PortOtherConfigsKey, PortOtherConfigs> portOtherConfigs =
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class OvsdbUpgradeStateListener implements ClusteredDataTreeChangeListener<UpgradeConfig>, AutoCloseable {
+public final class OvsdbUpgradeStateListener implements ClusteredDataTreeChangeListener<UpgradeConfig>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbUpgradeStateListener.class);
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.google.common.util.concurrent.UncheckedExecutionException;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
}
}
- @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
- justification = "https://github.com/spotbugs/spotbugs/issues/811")
private static Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
filterTerminationPointsForBridge(NodeKey nodeKey,
Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation>
package org.opendaylight.ovsdb.southbound.transactions.md;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Map;
import java.util.Optional;
import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
private final Map<UUID, AutoAttach> removedAutoAttachRows;
- public OvsdbAutoAttachRemovedCommand(OvsdbConnectionInstance key,
- TableUpdates updates, DatabaseSchema dbSchema) {
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
+ public OvsdbAutoAttachRemovedCommand(OvsdbConnectionInstance key, TableUpdates updates, DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
removedAutoAttachRows = TyperUtils.extractRowsRemoved(AutoAttach.class, getUpdates(), getDbSchema());
}
*/
package org.opendaylight.ovsdb.southbound.transactions.md;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
private final Map<UUID, AutoAttach> updatedAutoAttachRows;
private final Map<UUID, AutoAttach> oldAutoAttachRows;
- public OvsdbAutoAttachUpdateCommand(OvsdbConnectionInstance key,
- TableUpdates updates, DatabaseSchema dbSchema) {
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
+ public OvsdbAutoAttachUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates, DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
updatedAutoAttachRows = TyperUtils.extractRowsUpdated(AutoAttach.class, getUpdates(), getDbSchema());
oldAutoAttachRows = TyperUtils.extractRowsOld(AutoAttach.class, getUpdates(), getDbSchema());
import com.google.common.annotations.VisibleForTesting;
import com.google.common.net.InetAddresses;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
private final List<InstanceIdentifier<Node>> updatedBridges = new ArrayList<>();
private final Map<NodeId, Node> updatedBridgeNodes;
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
public OvsdbBridgeUpdateCommand(InstanceIdentifierCodec instanceIdentifierCodec, OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema,
Map<NodeId, Node> updatedBridgeNodes) {
import static java.util.Objects.requireNonNull;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
private final Map<UUID, Controller> removedControllerRows;
private final Map<UUID, Bridge> updatedBridgeRows;
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
public OvsdbControllerRemovedCommand(InstanceIdentifierCodec instanceIdentifierCodec, OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
package org.opendaylight.ovsdb.southbound.transactions.md;
import com.google.common.annotations.VisibleForTesting;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
private final Map<UUID, Controller> updatedControllerRows;
private final Map<UUID, Bridge> updatedBridgeRows;
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
public OvsdbControllerUpdateCommand(final OvsdbConnectionInstance key,
final TableUpdates updates, final DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.VisibleForTesting;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
private final Map<UUID, OpenVSwitch> updatedOpenVSwitchRows;
private final Map<UUID, Manager> updatedManagerRows;
- public OvsdbManagersRemovedCommand(OvsdbConnectionInstance key,
- TableUpdates updates, DatabaseSchema dbSchema) {
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
+ public OvsdbManagersRemovedCommand(OvsdbConnectionInstance key, TableUpdates updates, DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
updatedOpenVSwitchRows = TyperUtils.extractRowsUpdated(OpenVSwitch.class, getUpdates(), getDbSchema());
oldOpenVSwitchRows = TyperUtils.extractRowsOld(OpenVSwitch.class, getUpdates(), getDbSchema());
package org.opendaylight.ovsdb.southbound.transactions.md;
import com.google.common.annotations.VisibleForTesting;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
private Map<UUID, Manager> updatedManagerRows;
private Map<UUID, OpenVSwitch> updatedOpenVSwitchRows;
- public OvsdbManagersUpdateCommand(OvsdbConnectionInstance key,
- TableUpdates updates, DatabaseSchema dbSchema) {
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
+ public OvsdbManagersUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates, DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
updatedOpenVSwitchRows = TyperUtils.extractRowsUpdated(OpenVSwitch.class, getUpdates(), getDbSchema());
updatedManagerRows = TyperUtils.extractRowsUpdated(Manager.class,getUpdates(), getDbSchema());
package org.opendaylight.ovsdb.southbound.transactions.md;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
}
}
+ @SuppressFBWarnings("DCN_NULLPOINTER_EXCEPTION")
@Override
public void execute(ReadWriteTransaction transaction) {
- for (TransactionCommand command: commands) {
+ for (TransactionCommand command : commands) {
try {
command.execute(transaction);
} catch (NullPointerException | NoSuchElementException | ClassCastException e) {
@Override
public void onSuccess() {
- for (TransactionCommand command: commands) {
+ for (TransactionCommand command : commands) {
command.onSuccess();
}
}
package org.opendaylight.ovsdb.southbound.transactions.md;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
private final Map<UUID, Qos> removedQosRows;
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
public OvsdbQosRemovedCommand(OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
package org.opendaylight.ovsdb.southbound.transactions.md;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
public class OvsdbQosUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbQosUpdateCommand.class);
package org.opendaylight.ovsdb.southbound.transactions.md;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
private final Map<UUID, Queue> removedQueueRows;
- public OvsdbQueueRemovedCommand(OvsdbConnectionInstance key,
- TableUpdates updates, DatabaseSchema dbSchema) {
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
+ public OvsdbQueueRemovedCommand(OvsdbConnectionInstance key, TableUpdates updates, DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
removedQueueRows = TyperUtils.extractRowsRemoved(Queue.class, getUpdates(), getDbSchema());
}
*/
package org.opendaylight.ovsdb.southbound.transactions.md;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
private final Map<UUID, Queue> updatedQueueRows;
private final Map<UUID, Queue> oldQueueRows;
+ @SuppressFBWarnings(value = "MC_OVERRIDABLE_METHOD_CALL_IN_CONSTRUCTOR", justification = "Non-final for mocking")
public OvsdbQueueUpdateCommand(InstanceIdentifierCodec instanceIdentifierCodec, OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class TransactionInvokerImpl implements TransactionInvoker,TransactionChainListener, Runnable, AutoCloseable {
+public final class TransactionInvokerImpl implements TransactionInvoker,TransactionChainListener, Runnable,
+ AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(TransactionInvokerImpl.class);
private static final int QUEUE_SIZE = 10000;
* 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.ovsdb.southbound;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "IID_EXTERNAL_ID_KEY");
when(column.getData()).thenReturn(map);
InstanceIdentifierCodec iidc = mock(InstanceIdentifierCodec.class);
- InstanceIdentifier deserializedIid = InstanceIdentifier.create(Node.class);
+ InstanceIdentifier deserializedIid = InstanceIdentifier.create(NetworkTopology.class);
when(iidc.bindingDeserializerOrNull("IID_EXTERNAL_ID_KEY")).thenReturn(deserializedIid);
OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class, Mockito.RETURNS_DEEP_STUBS);
assertEquals("Incorrect Instance Identifier received", deserializedIid,
map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "IID_EXTERNAL_ID_KEY");
when(column.getData()).thenReturn(map);
InstanceIdentifierCodec iidc = mock(InstanceIdentifierCodec.class);
- InstanceIdentifier deserializedIid = InstanceIdentifier.create(Node.class);
+ InstanceIdentifier deserializedIid = InstanceIdentifier.create(NetworkTopology.class);
when(iidc.bindingDeserializerOrNull("IID_EXTERNAL_ID_KEY")).thenReturn(deserializedIid);
OvsdbConnectionInstance client = mock(OvsdbConnectionInstance.class, Mockito.RETURNS_DEEP_STUBS);
assertEquals("Incorrect Instance Identifier received", deserializedIid,
// if true
externalIdMap.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "test");
InstanceIdentifierCodec iidc = mock(InstanceIdentifierCodec.class);
- InstanceIdentifier iid = InstanceIdentifier.create(Node.class);
+ InstanceIdentifier iid = InstanceIdentifier.create(NetworkTopology.class);
when(iidc.bindingDeserializerOrNull("test")).thenReturn(iid);
assertEquals("Incorrect Instance Identifier received", iid, SouthboundMapper.getInstanceIdentifier(iidc, ovs));
// if false
* 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.ovsdb.southbound.ovsdb.transact;
import static org.junit.Assert.assertEquals;
@RunWith(MockitoJUnitRunner.class)
public class BridgeOperationalStateTest {
private final Node nd = new NodeBuilder().setNodeId(new NodeId("foo")).build();
- private final InstanceIdentifier<?> iid = InstanceIdentifier.create(Topology.class);
-
private final InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(NetworkTopology.class)
.child(Topology.class).child(Node.class);
private final Node brNode = new NodeBuilder().setNodeId(new NodeId("bar")).build();
doReturn(optNode).when(briOperationState).getBridgeNode(any(InstanceIdentifier.class));
OvsdbBridgeAugmentation ovsdbBriAug = mock(OvsdbBridgeAugmentation.class);
doReturn(ovsdbBriAug).when(node).augmentation(OvsdbBridgeAugmentation.class);
- Optional<OvsdbBridgeAugmentation> ovsdbBriAugOptional = briOperationState.getOvsdbBridgeAugmentation(iid);
+ Optional<OvsdbBridgeAugmentation> ovsdbBriAugOptional = briOperationState.getOvsdbBridgeAugmentation(
+ InstanceIdentifier.create(NetworkTopology.class));
assertNotNull(ovsdbBriAugOptional);
assertTrue(ovsdbBriAugOptional.get() instanceof OvsdbBridgeAugmentation);
}
OvsdbTerminationPointAugmentation ovsdbTermPntAug = mock(OvsdbTerminationPointAugmentation.class);
doReturn(ovsdbTermPntAug).when(termPoint).augmentation(OvsdbTerminationPointAugmentation.class);
Optional<OvsdbTerminationPointAugmentation> ovsdbTermPointOpt = briOperationState
- .getOvsdbTerminationPointAugmentation(iid);
+ .getOvsdbTerminationPointAugmentation(InstanceIdentifier.create(NetworkTopology.class));
assertNotNull(ovsdbTermPointOpt);
assertTrue(ovsdbTermPointOpt.get() instanceof OvsdbTerminationPointAugmentation);
}
* 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.ovsdb.southbound.ovsdb.transact;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
* 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.ovsdb.southbound.ovsdb.transact;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
* 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.ovsdb.southbound.transactions.md;
-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.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
* 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.ovsdb.southbound.transactions.md;
-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.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
* 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.ovsdb.southbound.transactions.md;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
+ <artifactId>org.osgi.framework</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
-import org.opendaylight.yangtools.concepts.Builder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.Identifier;
private static final int COUNTER_START = 0;
private int counter = COUNTER_START;
- protected abstract Builder<T> builder();
-
- protected abstract void setKey(Builder<T> builder, String key);
-
- protected abstract void setValue(Builder<T> builder, String value);
-
protected abstract boolean isValueMandatory();
public final T build(final String testName, final String key, final String value) {
- final Builder<T> builder = builder();
- this.counter++;
- if (key != null) {
- setKey(builder, String.format(FORMAT_STR, testName, key, this.counter));
- }
- if (value != null) {
- setValue(builder, String.format(FORMAT_STR, testName, value, this.counter));
- }
- return builder.build();
+ counter++;
+ return build(key == null ? null : String.format(FORMAT_STR, testName, key, counter),
+ value != null ? null : String.format(FORMAT_STR, testName, value, counter));
}
+ abstract @NonNull T build(@Nullable String key, @Nullable String value);
+
public final void reset() {
- this.counter = COUNTER_START;
+ counter = COUNTER_START;
}
}
private static final class SouthboundQueuesExternalIdsBuilder extends KeyValueBuilder<QueuesExternalIds> {
@Override
- protected Builder<QueuesExternalIds> builder() {
- return new QueuesExternalIdsBuilder();
- }
-
- @Override
- protected void setKey(final Builder<QueuesExternalIds> builder, final String key) {
- ((QueuesExternalIdsBuilder) builder).setQueuesExternalIdKey(key);
- }
-
- @Override
- protected void setValue(final Builder<QueuesExternalIds> builder, final String value) {
- ((QueuesExternalIdsBuilder) builder).setQueuesExternalIdValue(value);
+ QueuesExternalIds build(final String key, final String value) {
+ return new QueuesExternalIdsBuilder()
+ .setQueuesExternalIdKey(key)
+ .setQueuesExternalIdValue(value)
+ .build();
}
@Override
private static final class SouthboundQueuesOtherConfigBuilder extends KeyValueBuilder<QueuesOtherConfig> {
@Override
- protected Builder<QueuesOtherConfig> builder() {
- return new QueuesOtherConfigBuilder();
- }
-
- @Override
- protected void setKey(final Builder<QueuesOtherConfig> builder, final String key) {
- ((QueuesOtherConfigBuilder) builder).setQueueOtherConfigKey(key);
- }
-
- @Override
- protected void setValue(final Builder<QueuesOtherConfig> builder, final String value) {
- ((QueuesOtherConfigBuilder) builder).setQueueOtherConfigValue(value);
+ QueuesOtherConfig build(final String key, final String value) {
+ return new QueuesOtherConfigBuilder()
+ .setQueueOtherConfigKey(key)
+ .setQueueOtherConfigValue(value)
+ .build();
}
@Override
private static final class SouthboundQosExternalIdsBuilder extends KeyValueBuilder<QosExternalIds> {
@Override
- protected Builder<QosExternalIds> builder() {
- return new QosExternalIdsBuilder();
- }
-
- @Override
- protected void setKey(final Builder<QosExternalIds> builder, final String key) {
- ((QosExternalIdsBuilder) builder).setQosExternalIdKey(key);
- }
-
- @Override
- protected void setValue(final Builder<QosExternalIds> builder, final String value) {
- ((QosExternalIdsBuilder) builder).setQosExternalIdValue(value);
+ QosExternalIds build(final String key, final String value) {
+ return new QosExternalIdsBuilder()
+ .setQosExternalIdKey(key)
+ .setQosExternalIdValue(value)
+ .build();
}
@Override
private static final class SouthboundQosOtherConfigBuilder extends KeyValueBuilder<QosOtherConfig> {
@Override
- protected Builder<QosOtherConfig> builder() {
- return new QosOtherConfigBuilder();
- }
-
- @Override
- protected void setKey(final Builder<QosOtherConfig> builder, final String key) {
- ((QosOtherConfigBuilder) builder).setOtherConfigKey(key);
- }
-
- @Override
- protected void setValue(final Builder<QosOtherConfig> builder, final String value) {
- ((QosOtherConfigBuilder) builder).setOtherConfigValue(value);
+ QosOtherConfig build(final String key, final String value) {
+ return new QosOtherConfigBuilder()
+ .setOtherConfigKey(key)
+ .setOtherConfigValue(value)
+ .build();
}
@Override
private static final class SouthboundPortExternalIdsBuilder extends KeyValueBuilder<PortExternalIds> {
@Override
- protected Builder<PortExternalIds> builder() {
- return new PortExternalIdsBuilder();
- }
-
- @Override
- protected void setKey(final Builder<PortExternalIds> builder, final String key) {
- ((PortExternalIdsBuilder) builder).setExternalIdKey(key);
- }
-
- @Override
- protected void setValue(final Builder<PortExternalIds> builder, final String value) {
- ((PortExternalIdsBuilder) builder).setExternalIdValue(value);
+ PortExternalIds build(final String key, final String value) {
+ return new PortExternalIdsBuilder()
+ .setExternalIdKey(key)
+ .setExternalIdValue(value)
+ .build();
}
@Override
private static final class SouthboundInterfaceExternalIdsBuilder extends KeyValueBuilder<InterfaceExternalIds> {
@Override
- protected Builder<InterfaceExternalIds> builder() {
- return new InterfaceExternalIdsBuilder();
- }
-
- @Override
- protected void setKey(final Builder<InterfaceExternalIds> builder, final String key) {
- ((InterfaceExternalIdsBuilder) builder).setExternalIdKey(key);
- }
-
- @Override
- protected void setValue(final Builder<InterfaceExternalIds> builder, final String value) {
- ((InterfaceExternalIdsBuilder) builder).setExternalIdValue(value);
+ InterfaceExternalIds build(final String key, final String value) {
+ return new InterfaceExternalIdsBuilder()
+ .setExternalIdKey(key)
+ .setExternalIdValue(value)
+ .build();
}
@Override
private static final class SouthboundInterfaceLldpBuilder extends KeyValueBuilder<InterfaceLldp> {
@Override
- protected Builder<InterfaceLldp> builder() {
- return new InterfaceLldpBuilder();
- }
-
- @Override
- protected void setKey(final Builder<InterfaceLldp> builder, final String key) {
- ((InterfaceLldpBuilder) builder).setLldpKey(key);
- }
-
- @Override
- protected void setValue(final Builder<InterfaceLldp> builder, final String value) {
- ((InterfaceLldpBuilder) builder).setLldpValue(value);
+ InterfaceLldp build(final String key, final String value) {
+ return new InterfaceLldpBuilder()
+ .setLldpKey(key)
+ .setLldpValue(value)
+ .build();
}
@Override
private static final class SouthboundOptionsBuilder extends KeyValueBuilder<Options> {
@Override
- protected Builder<Options> builder() {
- return new OptionsBuilder();
- }
-
- @Override
- protected void setKey(final Builder<Options> builder, final String key) {
- ((OptionsBuilder) builder).setOption(key);
- }
-
- @Override
- protected void setValue(final Builder<Options> builder, final String value) {
- ((OptionsBuilder) builder).setValue(value);
+ Options build(final String key, final String value) {
+ return new OptionsBuilder()
+ .setOption(key)
+ .setValue(value)
+ .build();
}
@Override
private static final class SouthboundInterfaceOtherConfigsBuilder extends KeyValueBuilder<InterfaceOtherConfigs> {
@Override
- protected Builder<InterfaceOtherConfigs> builder() {
- return new InterfaceOtherConfigsBuilder();
- }
-
- @Override
- protected void setKey(final Builder<InterfaceOtherConfigs> builder, final String key) {
- ((InterfaceOtherConfigsBuilder) builder).setOtherConfigKey(key);
- }
-
- @Override
- protected void setValue(final Builder<InterfaceOtherConfigs> builder, final String value) {
- ((InterfaceOtherConfigsBuilder) builder).setOtherConfigValue(value);
+ InterfaceOtherConfigs build(final String key, final String value) {
+ return new InterfaceOtherConfigsBuilder()
+ .setOtherConfigKey(key)
+ .setOtherConfigValue(value)
+ .build();
}
@Override
private static final class SouthboundPortOtherConfigsBuilder extends KeyValueBuilder<PortOtherConfigs> {
@Override
- protected Builder<PortOtherConfigs> builder() {
- return new PortOtherConfigsBuilder();
- }
-
- @Override
- protected void setKey(final Builder<PortOtherConfigs> builder, final String key) {
- ((PortOtherConfigsBuilder) builder).setOtherConfigKey(key);
- }
-
- @Override
- protected void setValue(final Builder<PortOtherConfigs> builder, final String value) {
- ((PortOtherConfigsBuilder) builder).setOtherConfigValue(value);
+ PortOtherConfigs build(final String key, final String value) {
+ return new PortOtherConfigsBuilder()
+ .setOtherConfigKey(key)
+ .setOtherConfigValue(value)
+ .build();
}
@Override
private static final class SouthboundBridgeOtherConfigsBuilder extends KeyValueBuilder<BridgeOtherConfigs> {
@Override
- protected Builder<BridgeOtherConfigs> builder() {
- return new BridgeOtherConfigsBuilder();
- }
-
- @Override
- protected void setKey(final Builder<BridgeOtherConfigs> builder, final String key) {
- ((BridgeOtherConfigsBuilder) builder).setBridgeOtherConfigKey(key);
- }
-
- @Override
- protected void setValue(final Builder<BridgeOtherConfigs> builder, final String value) {
- ((BridgeOtherConfigsBuilder) builder).setBridgeOtherConfigValue(value);
+ BridgeOtherConfigs build(final String key, final String value) {
+ return new BridgeOtherConfigsBuilder()
+ .setBridgeOtherConfigKey(key)
+ .setBridgeOtherConfigValue(value)
+ .build();
}
@Override
private static final class SouthboundBridgeExternalIdsBuilder extends KeyValueBuilder<BridgeExternalIds> {
@Override
- protected Builder<BridgeExternalIds> builder() {
- return new BridgeExternalIdsBuilder();
- }
-
- @Override
- protected void setKey(final Builder<BridgeExternalIds> builder, final String key) {
- ((BridgeExternalIdsBuilder) builder).setBridgeExternalIdKey(key);
- }
-
- @Override
- protected void setValue(final Builder<BridgeExternalIds> builder, final String value) {
- ((BridgeExternalIdsBuilder) builder).setBridgeExternalIdValue(value);
+ BridgeExternalIds build(final String key, final String value) {
+ return new BridgeExternalIdsBuilder()
+ .setBridgeExternalIdKey(key)
+ .setBridgeExternalIdValue(value)
+ .build();
}
@Override
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>karaf4-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<modelVersion>4.0.0</modelVersion>
<dependencies>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
+ <artifactId>org.osgi.framework</artifactId>
</dependency>
</dependencies>
* Once an instance is created one must invoke the registerDataChangeListener method
* with a DataBroker.
*/
-public class NotifyingDataChangeListener implements AutoCloseable, DataTreeChangeListener<DataObject> {
+public final class NotifyingDataChangeListener implements AutoCloseable, DataTreeChangeListener<DataObject> {
private static final Logger LOG = LoggerFactory.getLogger(NotifyingDataChangeListener.class);
private static final int RETRY_WAIT = 100;
private static final int MDSAL_TIMEOUT_OPERATIONAL = 10000;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>single-feature-parent</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>controller-artifacts</artifactId>
- <version>4.0.10</version>
+ <version>5.0.1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
-->
<features name="odl-ovsdb-utils-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0">
<feature name="odl-ovsdb-utils" version="${project.version}">
- <feature version="[4,5)">odl-mdsal-broker</feature>
+ <feature version="[5,6)">odl-mdsal-broker</feature>
</feature>
</features>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
- <artifactId>rfc6991</artifactId>
+ <artifactId>rfc6991-ietf-inet-types</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.mdsal.model</groupId>
</dependency>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
+ <artifactId>org.osgi.framework</artifactId>
<scope>compile</scope>
</dependency>
* 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.ovsdb.utils.ovsdb.it.utils;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
import static org.ops4j.pax.exam.CoreOptions.propagateSystemProperties;
import com.esotericsoftware.yamlbeans.YamlException;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicInteger;
-import org.junit.Assert;
import org.ops4j.pax.exam.Option;
import org.osgi.framework.Bundle;
import org.osgi.framework.FrameworkUtil;
* When DockerOvs does not run docker-compose getOvsdbAddress and getOvsdbPort return the address and port specified in
* the system properties.
*/
-public class DockerOvs implements AutoCloseable {
+public final class DockerOvs implements AutoCloseable {
private static String ENV_USAGE = "Usage:\n"
+ "-Ddocker.run - explicitly configure whether or not DockerOvs should run docker-compose\n"
+ "-Dovsdbserver.ipaddress - specify IP address of ovsdb server - implies -Ddocker.run=false\n"
//At this point we know we're not running docker and the conn type is active - make sure we have what we need
//If we have a server address than we require a port too as those
//are returned in getOvsdbPort() and getOvsdbAddress()
- Assert.assertNotNull("Attempt to connect to previous running ovs but missing -Dovsdbserver.ipaddress\n"
+ assertNotNull("Attempt to connect to previous running ovs but missing -Dovsdbserver.ipaddress\n"
+ ENV_USAGE, envServerAddress);
- Assert.assertNotNull("Attempt to connect to previous running ovs but missing -Dovsdbserver.port\n"
+ assertNotNull("Attempt to connect to previous running ovs but missing -Dovsdbserver.port\n"
+ ENV_USAGE, envServerPort);
}
} else if (0 == ProcUtils.tryProcess(null, 5000, psCmd)) {
LOG.info("DockerOvs.buildDockerCommands docker-compose requires sudo");
} else {
- Assert.fail("docker-compose does not seem to work with or without sudo");
+ fail("docker-compose does not seem to work with or without sudo");
}
if (0 == ProcUtils.tryProcess(null, 5000, dockerPsCmdNoSudo)) {
} else if (0 == ProcUtils.tryProcess(null, 5000, dockerPsCmd)) {
LOG.info("DockerOvs.buildDockerCommands docker requires sudo");
} else {
- Assert.fail("docker does not seem to work with or without sudo");
+ fail("docker does not seem to work with or without sudo");
}
}
*/
private File createTempDockerComposeFile(String yamlFileName) {
Bundle bundle = FrameworkUtil.getBundle(this.getClass());
- Assert.assertNotNull("DockerOvs: bundle is null", bundle);
+ assertNotNull("DockerOvs: bundle is null", bundle);
URL url = bundle.getResource(envDockerComposeFile);
- Assert.assertNotNull("DockerOvs: URL is null", url);
+ assertNotNull("DockerOvs: URL is null", url);
File tmpFile = null;
try {
}
} catch (IOException e) {
- Assert.fail(e.toString());
+ fail(e.toString());
}
return tmpFile;
* 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.ovsdb.utils.ovsdb.it.utils;
+import static org.junit.Assert.assertEquals;
+
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
-import org.junit.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(ProcUtils.class);
private ProcUtils() {
+ // Hidden on purpose
}
/**
* @throws IOException if something goes wrong on the IO end
* @throws InterruptedException If this thread is interrupted
*/
- public static void runProcess(long waitFor, String... words) throws
- IOException, InterruptedException {
+ public static void runProcess(long waitFor, String... words) throws IOException, InterruptedException {
runProcess(waitFor, null, words);
}
public static void runProcess(long waitFor, StringBuilder capturedStdout, String... words)
throws IOException, InterruptedException {
int exitValue = tryProcess(null, waitFor, capturedStdout, words);
- Assert.assertEquals("ProcUtils.runProcess exit code is not 0", 0, exitValue);
+ assertEquals("ProcUtils.runProcess exit code is not 0", 0, exitValue);
}
public static int runProcess(int reserved, long waitFor, StringBuilder capturedStdout, String... words)
public static int tryProcess(String logText, long waitFor, StringBuilder capturedStdout, String... words)
throws IOException, InterruptedException {
- LOG.info("ProcUtils.runProcess {} running \"{}\", waitFor {}",
- logText != null ? logText : "", words, waitFor);
+ final String procName = logText != null ? logText : "";
+ LOG.info("ProcUtils.runProcess {} running \"{}\", waitFor {}", procName, words, waitFor);
Process proc = new ProcessBuilder(words).start();
int exitValue = -1;
exitValue = waitForExitValue(waitFor, proc);
while (stderr.ready()) {
- LOG.warn("ProcUtils.runProcess {} [stderr]: {}",
- logText != null ? logText : "", stderr.readLine());
+ LOG.warn("ProcUtils.runProcess {} [stderr]: {}", procName, stderr.readLine());
}
StringBuilder stdoutStringBuilder = capturedStdout != null ? capturedStdout : new StringBuilder();
stdoutStringBuilder.append(buf, 0, read);
}
- LOG.info("ProcUtils.runProcess {} [stdout]:\n{}",
- logText != null ? logText : "", stdoutStringBuilder.toString());
+ LOG.info("ProcUtils.runProcess {} [stdout]:\n{}", procName, stdoutStringBuilder.toString());
}
return exitValue;
<parent>
<groupId>org.opendaylight.odlparent</groupId>
<artifactId>odlparent-lite</artifactId>
- <version>9.0.13</version>
+ <version>10.0.0</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
<groupId>org.osgi</groupId>
- <artifactId>osgi.core</artifactId>
+ <artifactId>org.osgi.framework</artifactId>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
Code Review / ovsdb.git / commitdiff