enabling checkstyle checks on build which should prevent
checkstyle violations in future.
Change-Id: I090928f68c18615672681f67ba368ac73271447c
Signed-off-by: Michal Cmarada <michal.cmarada@pantheon.tech>
20 files changed:
</instructions>
</configuration>
</plugin>
</instructions>
</configuration>
</plugin>
+ <plugin>
+ <artifactId>maven-checkstyle-plugin</artifactId>
+ <configuration>
+ <excludes>org/opendaylight/yang/gen/**,**/yang/**</excludes>
+ <consoleOutput>true</consoleOutput>
+ <propertyExpansion>checkstyle.violationSeverity=error</propertyExpansion>
+ </configuration>
+ <executions>
+ <execution>
+ <goals>
+ <goal>check</goal>
+ </goals>
+ <phase>process-sources</phase>
+ </execution>
+ </executions>
+ </plugin>
</plugins>
</build>
</project>
</plugins>
</build>
</project>
return Collections.unmodifiableList(options);
}
return Collections.unmodifiableList(options);
}
- protected boolean hasTunnelOptions(OvsdbTerminationPointAugmentation tpAugmentation, Map<String, String> optionsMap) {
+ protected boolean hasTunnelOptions(OvsdbTerminationPointAugmentation tpAugmentation,
+ Map<String, String> optionsMap) {
Map<String, String> foundOpts = new HashMap<String, String>();
List<Options> options = tpAugmentation.getOptions();
if (options != null) {
for (Options opt : options) {
// skip invalid options
Map<String, String> foundOpts = new HashMap<String, String>();
List<Options> options = tpAugmentation.getOptions();
if (options != null) {
for (Options opt : options) {
// skip invalid options
- if (opt.getOption() == null || opt.getValue() == null)
+ if (opt.getOption() == null || opt.getValue() == null) {
if (optionsMap.containsKey(opt.getOption()) && optionsMap.get(opt.getOption()).equals(opt.getValue())) {
foundOpts.put(opt.getOption(), opt.getValue());
}
if (optionsMap.containsKey(opt.getOption()) && optionsMap.get(opt.getOption()).equals(opt.getValue())) {
foundOpts.put(opt.getOption(), opt.getValue());
}
- * Return the list of {@link Options} valid for this tunnel type
+ * Return the list of {@link Options} valid for this tunnel type.
*
* @return list of {@link Options} for the tunnel, null if not supported
*/
public abstract List<Options> getOptions();
/**
*
* @return list of {@link Options} for the tunnel, null if not supported
*/
public abstract List<Options> getOptions();
/**
- * Check if a TerminationPoint is a tunnel port that meets
+ * Check if a TerminationPoint is a tunnel port that meets.
* requirements
*
* @param tpAugmentation the {@link OvsdbTerminationPointAugmentation}
* requirements
*
* @param tpAugmentation the {@link OvsdbTerminationPointAugmentation}
public abstract PortNumber getPortNumber();
/**
public abstract PortNumber getPortNumber();
/**
- * Get the prefix used to create the tunnel name for any tunnels of this type
+ * Get the prefix used to create the tunnel name for any tunnels of this type.
*
* @return The tunnel prefix
*/
*
* @return The tunnel prefix
*/
+ * Used to properly close running instance.
+ *
* @see java.lang.AutoCloseable#close()
*/
@Override
* @see java.lang.AutoCloseable#close()
*/
@Override
*/
package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
*/
package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
-import javax.annotation.Nonnull;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-
-
import com.google.common.base.Function;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.base.Function;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+
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.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
if (ovsdbNode != null) {
LOG.trace("OVSDB node created: {} \n {}", rootIdentifier, node);
OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
if (ovsdbNode != null) {
LOG.trace("OVSDB node created: {} \n {}", rootIdentifier, node);
- DataObjectModification<OpenvswitchOtherConfigs> ovsOtherConfigModification = getProviderMappingsModification(rootNode);
+ DataObjectModification<OpenvswitchOtherConfigs>
+ ovsOtherConfigModification = getProviderMappingsModification(rootNode);
boolean integrationBridgePresent = false;
if (isProviderPortNameChanged(ovsOtherConfigModification) && ovsdbNode.getManagedNodeEntry() != null) {
String newProviderPortName = getProviderPortName(ovsOtherConfigModification.getDataAfter());
boolean integrationBridgePresent = false;
if (isProviderPortNameChanged(ovsOtherConfigModification) && ovsdbNode.getManagedNodeEntry() != null) {
String newProviderPortName = getProviderPortName(ovsOtherConfigModification.getDataAfter());
LOG.trace("Added Provider port name {} by OVSDB bridge ref {}", newProviderPortName,
mngdNodeEntry.getBridgeRef());
NodeKey managedNodeKey = bridgeRef.getValue().firstKeyOf(Node.class);
LOG.trace("Added Provider port name {} by OVSDB bridge ref {}", newProviderPortName,
mngdNodeEntry.getBridgeRef());
NodeKey managedNodeKey = bridgeRef.getValue().firstKeyOf(Node.class);
- if (intBrSettings != null && managedNodeKey.getNodeId().getValue().equals(intBrSettings.getName())) {
+ if (intBrSettings != null && managedNodeKey.getNodeId().getValue()
+ .equals(intBrSettings.getName())) {
integrationBridgePresent = true;
}
}
integrationBridgePresent = true;
}
}
managerToControllerEntries(ovsdbNode.getManagerEntry()), intBrSettings.getName());
InstanceIdentifier<Node> bridgeNodeIid = NeutronOvsdbIidFactory.nodeIid(
rootIdentifier.firstKeyOf(Topology.class).getTopologyId(), bridge.getNodeId());
managerToControllerEntries(ovsdbNode.getManagerEntry()), intBrSettings.getName());
InstanceIdentifier<Node> bridgeNodeIid = NeutronOvsdbIidFactory.nodeIid(
rootIdentifier.firstKeyOf(Topology.class).getTopologyId(), bridge.getNodeId());
- WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
- wTx.merge(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid, bridge, true);
- Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
+ WriteTransaction writeTx = dataProvider.newWriteOnlyTransaction();
+ writeTx.merge(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid, bridge, true);
+ Futures.addCallback(writeTx.submit(), new FutureCallback<Void>() {
@Override
public void onSuccess(Void result) {
@Override
public void onSuccess(Void result) {
- public void onFailure(Throwable t) {
+ public void onFailure(Throwable throwable) {
LOG.error("Failed to write bridge {}. Message: {}" + bridge.getNodeId().getValue(),
LOG.error("Failed to write bridge {}. Message: {}" + bridge.getNodeId().getValue(),
+ throwable.getMessage());
}
}, MoreExecutors.directExecutor());
}
}
}, MoreExecutors.directExecutor());
}
- * Extracts IP address from URI
+ * Extracts IP address from URI.
*
* @param uri in format protocol:ip:port
* @return IPv4 or IPv6 address as {@link String}.
*
* @param uri in format protocol:ip:port
* @return IPv4 or IPv6 address as {@link String}.
*/
package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
*/
package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
+import com.google.common.base.Optional;
+
import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import java.util.List;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
/**
* Listens on PortByEndpoint created events. port-name is augmented to endpoint and endpoint-l3 (IFF
* they exist in DS).
/**
* Listens on PortByEndpoint created events. port-name is augmented to endpoint and endpoint-l3 (IFF
* they exist in DS).
*/
package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
*/
package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
+import com.google.common.base.Strings;
+
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.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Strings;
-
public class ProviderPhysicalNetworkListener extends DataTreeChangeHandler<ProviderPhysicalNetworkAsL2FloodDomain> {
private static final Logger LOG = LoggerFactory.getLogger(ProviderPhysicalNetworkListener.class);
public class ProviderPhysicalNetworkListener extends DataTreeChangeHandler<ProviderPhysicalNetworkAsL2FloodDomain> {
private static final Logger LOG = LoggerFactory.getLogger(ProviderPhysicalNetworkListener.class);
try {
Segmentation segmentation =
new SegmentationBuilder().setSegmentationId(Integer.valueOf(segmentationId)).build();
try {
Segmentation segmentation =
new SegmentationBuilder().setSegmentationId(Integer.valueOf(segmentationId)).build();
- WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
- wTx.merge(LogicalDatastoreType.CONFIGURATION,
+ WriteTransaction writeTx = dataProvider.newWriteOnlyTransaction();
+ writeTx.merge(LogicalDatastoreType.CONFIGURATION,
IidFactory.l2FloodDomainIid(tenantId, l2FdId).augmentation(Segmentation.class), segmentation);
IidFactory.l2FloodDomainIid(tenantId, l2FdId).augmentation(Segmentation.class), segmentation);
- DataStoreHelper.submitToDs(wTx);
+ DataStoreHelper.submitToDs(writeTx);
} catch (NumberFormatException e) {
LOG.info("Segmentation ID of Neutron Provider Physical Network {} is not a number but is {}.",
l2FdId.getValue(), segmentationId);
} catch (NumberFormatException e) {
LOG.info("Segmentation ID of Neutron Provider Physical Network {} is not a number but is {}.",
l2FdId.getValue(), segmentationId);
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
* When vSwitch is deleted, we loose data in operational DS to determine Iid of
* corresponding NodeId.
*/
* When vSwitch is deleted, we loose data in operational DS to determine Iid of
* corresponding NodeId.
*/
- private static final Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, NodeId> nodeIdByTerminPoint =
+ private static final Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, NodeId> NODE_ID_BY_TERMIN_POINT =
new HashMap<>();
@Override
new HashMap<>();
@Override
OvsdbTerminationPointAugmentation updatedOvsdbTp = rootNode.getDataAfter();
OvsdbBridgeAugmentation ovsdbBridge = getOvsdbBridgeFromTerminationPoint(ovsdbTpIid, dataBroker);
if (origOvsdbTp == null) {
OvsdbTerminationPointAugmentation updatedOvsdbTp = rootNode.getDataAfter();
OvsdbBridgeAugmentation ovsdbBridge = getOvsdbBridgeFromTerminationPoint(ovsdbTpIid, dataBroker);
if (origOvsdbTp == null) {
- nodeIdByTerminPoint.put(ovsdbTpIid,
+ NODE_ID_BY_TERMIN_POINT.put(ovsdbTpIid,
new NodeId(getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker)));
}
processOvsdbBridge(ovsdbBridge, updatedOvsdbTp, ovsdbTpIid);
break;
case DELETE:
new NodeId(getInventoryNodeIdString(ovsdbBridge, ovsdbTpIid, dataBroker)));
}
processOvsdbBridge(ovsdbBridge, updatedOvsdbTp, ovsdbTpIid);
break;
case DELETE:
- processRemovedTp(nodeIdByTerminPoint.get(ovsdbTpIid), origOvsdbTp, ovsdbTpIid);
+ processRemovedTp(NODE_ID_BY_TERMIN_POINT.get(ovsdbTpIid), origOvsdbTp, ovsdbTpIid);
ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
ep = lookupEndpoint(epKey, transaction);
if (ep == null) {
ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
ep = lookupEndpoint(epKey, transaction);
if (ep == null) {
- LOG.warn(
- "TerminationPoint {} with external ID {} is in Neutron Map, but corresponding Endpoint {} isn't in Endpoint Repository",
- ovsdbTp, externalId, epKey);
+ LOG.warn("TerminationPoint {} with external ID {} is in Neutron Map, "
+ + "but corresponding Endpoint {} isn't in Endpoint Repository", ovsdbTp, externalId, epKey);
/**
* If removed termination point was a tunnel port,
/**
* If removed termination point was a tunnel port,
- * removes attached tunnels (namely Vxlan-type) from OVSDB bridge;
- * else removes location info from TP
+ * removes attached tunnels (namely Vxlan-type) from OVSDB bridge,
+ * else removes location info from TP.
*
* @param nodeId {@link NodeId}
* @param ovsdbTp {@link OvsdbTerminationPointAugmentation}
*
* @param nodeId {@link NodeId}
* @param ovsdbTp {@link OvsdbTerminationPointAugmentation}
- * Delete location on EP for given TP
+ * Delete location on EP for given TP.
*
* @param ovsdbTp {@link OvsdbTerminationPointAugmentation}
*/
*
* @param ovsdbTp {@link OvsdbTerminationPointAugmentation}
*/
Endpoint ep = lookupEndpoint(epKey, readOnlyTransaction);
readOnlyTransaction.close();
if (ep == null) {
Endpoint ep = lookupEndpoint(epKey, readOnlyTransaction);
readOnlyTransaction.close();
if (ep == null) {
- LOG.warn(
- "TerminationPoint {} with external ID {} is in Neutron Map, but corresponding Endpoint {} isn't in Endpoint Repository.",
- ovsdbTp, externalId, epKey);
+ LOG.warn("TerminationPoint {} with external ID {} is in Neutron Map,"
+ + " but corresponding Endpoint {} isn't in Endpoint Repository.", ovsdbTp, externalId, epKey);
return;
}
updateEndpointRemoveLocation(ep, dataBroker.newReadWriteTransaction());
return;
}
updateEndpointRemoveLocation(ep, dataBroker.newReadWriteTransaction());
private final PortNumber udpTunnelPort;
private final List<Options> optionsList;
private final PortNumber udpTunnelPort;
private final List<Options> optionsList;
- private static final Class<? extends TunnelTypeBase> tunnelType = TunnelTypeVxlanGpe.class;
+ private static final Class<? extends TunnelTypeBase> TUNNEL_TYPE_VXLAN_GPE = TunnelTypeVxlanGpe.class;
public VxlanGpeTunnelType() {
public VxlanGpeTunnelType() {
- optionsList = createOptionsList(optsMap);
+ optionsList = createOptionsList(OPTS_MAP);
udpTunnelPort = new PortNumber(VXLAN_GPE_PORT_NUMBER);
}
udpTunnelPort = new PortNumber(VXLAN_GPE_PORT_NUMBER);
}
- private static final Map<String, String> optsMap;
+ private static final Map<String, String> OPTS_MAP;
+
static {
Map<String, String> opts = new HashMap<String, String>();
opts.put(VNID_KEY, VNID_VALUE);
static {
Map<String, String> opts = new HashMap<String, String>();
opts.put(VNID_KEY, VNID_VALUE);
opts.put(NSH_NSHC3_KEY, NSH_NSHC3_VALUE);
opts.put(NSH_NSHC4_KEY, NSH_NSHC4_VALUE);
opts.put(DESTPORT_KEY, DESTPORT_VALUE);
opts.put(NSH_NSHC3_KEY, NSH_NSHC3_VALUE);
opts.put(NSH_NSHC4_KEY, NSH_NSHC4_VALUE);
opts.put(DESTPORT_KEY, DESTPORT_VALUE);
- optsMap = Collections.unmodifiableMap(opts);
+ OPTS_MAP = Collections.unmodifiableMap(opts);
@Override
public Class<? extends TunnelTypeBase> getTunnelType() {
@Override
public Class<? extends TunnelTypeBase> getTunnelType() {
+ return TUNNEL_TYPE_VXLAN_GPE;
*/
@Override
public boolean isValidTunnelPort(OvsdbTerminationPointAugmentation tpAugmentation) {
*/
@Override
public boolean isValidTunnelPort(OvsdbTerminationPointAugmentation tpAugmentation) {
- if (hasTunnelOptions(tpAugmentation, optsMap)
+ if (hasTunnelOptions(tpAugmentation, OPTS_MAP)
&& InterfaceTypeVxlan.class.equals(tpAugmentation.getInterfaceType())
&& getDestPort(tpAugmentation).equals(VXLAN_GPE_PORT_NUMBER.toString())) {
return true;
&& InterfaceTypeVxlan.class.equals(tpAugmentation.getInterfaceType())
&& getDestPort(tpAugmentation).equals(VXLAN_GPE_PORT_NUMBER.toString())) {
return true;
/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
/*
* Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
public class VxlanTunnelType extends AbstractTunnelType {
public class VxlanTunnelType extends AbstractTunnelType {
- private static final Map<String, String> optsMap;
- private static final Class<? extends TunnelTypeBase> tunnelType = TunnelTypeVxlan.class;
+ private static final Map<String, String> OPTS_MAP;
+ private static final Class<? extends TunnelTypeBase> TUNNEL_TYPE_VXLAN = TunnelTypeVxlan.class;
private static final Integer VXLAN_PORT_NUMBER = 4789;
private static final String VXLAN_TUNNEL_PREFIX = "vxlan-";
private final PortNumber udpTunnelPort;
private static final Integer VXLAN_PORT_NUMBER = 4789;
private static final String VXLAN_TUNNEL_PREFIX = "vxlan-";
private final PortNumber udpTunnelPort;
Map<String, String> opts = new HashMap<String, String>();
opts.put(VNID_KEY, VNID_VALUE);
opts.put(REMOTE_IP_KEY, REMOTE_IP_VALUE);
Map<String, String> opts = new HashMap<String, String>();
opts.put(VNID_KEY, VNID_VALUE);
opts.put(REMOTE_IP_KEY, REMOTE_IP_VALUE);
- optsMap = Collections.unmodifiableMap(opts);
+ OPTS_MAP = Collections.unmodifiableMap(opts);
}
public VxlanTunnelType() {
}
public VxlanTunnelType() {
- optionsList = createOptionsList(optsMap);
+ optionsList = createOptionsList(OPTS_MAP);
udpTunnelPort = new PortNumber(VXLAN_PORT_NUMBER);
}
udpTunnelPort = new PortNumber(VXLAN_PORT_NUMBER);
}
@Override
public Class<? extends TunnelTypeBase> getTunnelType() {
@Override
public Class<? extends TunnelTypeBase> getTunnelType() {
+ return TUNNEL_TYPE_VXLAN;
*/
@Override
public boolean isValidTunnelPort(OvsdbTerminationPointAugmentation tpAugmentation) {
*/
@Override
public boolean isValidTunnelPort(OvsdbTerminationPointAugmentation tpAugmentation) {
- if (hasTunnelOptions(tpAugmentation, optsMap)
+ if (hasTunnelOptions(tpAugmentation, OPTS_MAP)
&& InterfaceTypeVxlan.class.equals(tpAugmentation.getInterfaceType())
&& (getDestPort(tpAugmentation) == null || getDestPort(tpAugmentation).equals(
VXLAN_PORT_NUMBER.toString()))) {
&& InterfaceTypeVxlan.class.equals(tpAugmentation.getInterfaceType())
&& (getDestPort(tpAugmentation) == null || getDestPort(tpAugmentation).equals(
VXLAN_PORT_NUMBER.toString()))) {
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
import static org.opendaylight.groupbasedpolicy.util.IidFactory.endpointIid;
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
import static org.opendaylight.groupbasedpolicy.util.IidFactory.endpointIid;
+import com.google.common.base.Optional;
+
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import com.google.common.base.Optional;
-
public class EndpointHelper {
public class EndpointHelper {
*/
public static Endpoint lookupEndpoint(EndpointKey epKey, ReadOnlyTransaction transaction) {
*/
public static Endpoint lookupEndpoint(EndpointKey epKey, ReadOnlyTransaction transaction) {
- Optional<Endpoint> optionalEp = readFromDs(LogicalDatastoreType.OPERATIONAL, endpointIid(epKey.getL2Context(),epKey.getMacAddress()), transaction );
+ Optional<Endpoint> optionalEp =
+ readFromDs(LogicalDatastoreType.OPERATIONAL, endpointIid(epKey.getL2Context(), epKey.getMacAddress()),
+ transaction);
if (optionalEp.isPresent()) {
return optionalEp.get();
}
if (optionalEp.isPresent()) {
return optionalEp.get();
}
/**
* Updates an {@link Endpoint} location based on OVSDB Termination point notification.
/**
* Updates an {@link Endpoint} location based on OVSDB Termination point notification.
* Note this updates the datastore directly. It does not use the Endpoint RPC, as this has
* unfortunate side-effects on EndpointL3 augmentations.
*
* Note this updates the datastore directly. It does not use the Endpoint RPC, as this has
* unfortunate side-effects on EndpointL3 augmentations.
*
EndpointBuilder epBuilder = new EndpointBuilder(endpoint);
Endpoint newEp = epBuilder.build();
epBuilder.removeAugmentation(OfOverlayContext.class);
EndpointBuilder epBuilder = new EndpointBuilder(endpoint);
Endpoint newEp = epBuilder.build();
epBuilder.removeAugmentation(OfOverlayContext.class);
- rwTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.endpointIid(newEp.getL2Context(), newEp.getMacAddress()), newEp);
+ rwTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.endpointIid(newEp.getL2Context(), newEp.getMacAddress()),
+ newEp);
DataStoreHelper.submitToDs(rwTx);
}
DataStoreHelper.submitToDs(rwTx);
}
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.submitToDs;
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.submitToDs;
+import com.google.common.base.Optional;
+
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class InventoryHelper {
private static final Logger LOG = LoggerFactory.getLogger(InventoryHelper.class);
private static final String HEX = "0x";
/**
public class InventoryHelper {
private static final Logger LOG = LoggerFactory.getLogger(InventoryHelper.class);
private static final String HEX = "0x";
/**
- * Convert an OpenFlow Datapath ID to a Long
+ * Convert an OpenFlow Datapath ID to a Long.
*
* @param dpid The OpenFlow Datapath ID
* @return The Long representation of the DPID
*
* @param dpid The OpenFlow Datapath ID
* @return The Long representation of the DPID
/**
* Read the {@link OfOverlayNodeConfig} augmentation from the
* Inventory Node, and verify that the tunnel types we need
/**
* Read the {@link OfOverlayNodeConfig} augmentation from the
* Inventory Node, and verify that the tunnel types we need
*
* @param nodeIdString The inventory node id string
* @param requiredTunnelTypes the list of tunnel types
*
* @param nodeIdString The inventory node id string
* @param requiredTunnelTypes the list of tunnel types
- public static InstanceIdentifier<ExternalInterfaces> addOfOverlayExternalPort(NodeId nodeId, NodeConnectorId ncId, DataBroker dataBroker) {
+ public static InstanceIdentifier<ExternalInterfaces> addOfOverlayExternalPort(NodeId nodeId, NodeConnectorId ncId,
+ DataBroker dataBroker) {
InstanceIdentifier<ExternalInterfaces> nodeExternalInterfacesIid = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(nodeId))
.augmentation(OfOverlayNodeConfig.class)
InstanceIdentifier<ExternalInterfaces> nodeExternalInterfacesIid = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(nodeId))
.augmentation(OfOverlayNodeConfig.class)
Set<Tunnel> existingTunnels = new HashSet<Tunnel>();
if (ofConfig != null) {
ofOverlayNodeConfigBuilder = new OfOverlayNodeConfigBuilder(ofConfig);
Set<Tunnel> existingTunnels = new HashSet<Tunnel>();
if (ofConfig != null) {
ofOverlayNodeConfigBuilder = new OfOverlayNodeConfigBuilder(ofConfig);
- if(ofConfig.getTunnel() != null) {
+ if (ofConfig.getTunnel() != null) {
existingTunnels.addAll(ofConfig.getTunnel());
}
} else {
existingTunnels.addAll(ofConfig.getTunnel());
}
} else {
}
OfOverlayNodeConfig newConfig = ofOverlayNodeConfigBuilder.build();
if (addOfOverlayConfig(newConfig, new NodeId(nodeIdString), dataBroker)) {
}
OfOverlayNodeConfig newConfig = ofOverlayNodeConfigBuilder.build();
if (addOfOverlayConfig(newConfig, new NodeId(nodeIdString), dataBroker)) {
- LOG.trace("updateOfOverlayConfig - Added Tunnel: {} to Node: {} at NodeConnector: {}",tunnelBuilder.build(), nodeIdString, nodeConnectorIdString);
- return;
+ LOG.trace("updateOfOverlayConfig - Added Tunnel: {} to Node: {} at NodeConnector: {}",
+ tunnelBuilder.build(), nodeIdString, nodeConnectorIdString);
} else {
LOG.error("updateOfOverlayConfig - could not write OfOverlayNodeConfig: {} to datastore.", newConfig);
}
} else {
LOG.error("updateOfOverlayConfig - could not write OfOverlayNodeConfig: {} to datastore.", newConfig);
}
// runs only if some tunnels were really removed
if (existingTunnels.removeAll(tunnelsToRemove)) {
// runs only if some tunnels were really removed
if (existingTunnels.removeAll(tunnelsToRemove)) {
- ReadWriteTransaction wTx = dataBroker.newReadWriteTransaction();
+ ReadWriteTransaction writeTx = dataBroker.newReadWriteTransaction();
for (Tunnel tunnel : tunnelsToRemove) {
InstanceIdentifier<Tunnel> tunnelIid = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(new NodeId(nodeIdString)))
.augmentation(OfOverlayNodeConfig.class)
.child(Tunnel.class, tunnel.getKey())
.build();
for (Tunnel tunnel : tunnelsToRemove) {
InstanceIdentifier<Tunnel> tunnelIid = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(new NodeId(nodeIdString)))
.augmentation(OfOverlayNodeConfig.class)
.child(Tunnel.class, tunnel.getKey())
.build();
- wTx.delete(LogicalDatastoreType.CONFIGURATION, tunnelIid);
+ writeTx.delete(LogicalDatastoreType.CONFIGURATION, tunnelIid);
LOG.trace("Removing tunnel: {} from node {}",tunnel, nodeIdString);
}
LOG.trace("Removing tunnel: {} from node {}",tunnel, nodeIdString);
}
}
}
private static boolean addOfOverlayConfig(OfOverlayNodeConfig newConfig, NodeId nodeId, DataBroker dataBroker) {
}
}
private static boolean addOfOverlayConfig(OfOverlayNodeConfig newConfig, NodeId nodeId, DataBroker dataBroker) {
- ReadWriteTransaction wTx = dataBroker.newReadWriteTransaction();
+ ReadWriteTransaction writeTx = dataBroker.newReadWriteTransaction();
InstanceIdentifier<OfOverlayNodeConfig> ofOverlayNodeIid = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(nodeId))
.augmentation(OfOverlayNodeConfig.class)
.build();
InstanceIdentifier<OfOverlayNodeConfig> ofOverlayNodeIid = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(nodeId))
.augmentation(OfOverlayNodeConfig.class)
.build();
- wTx.put(LogicalDatastoreType.CONFIGURATION, ofOverlayNodeIid, newConfig, true);
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, ofOverlayNodeIid, newConfig, true);
LOG.trace("Adding tunnel: {} to node {}", newConfig, nodeId.getValue());
LOG.trace("Adding tunnel: {} to node {}", newConfig, nodeId.getValue());
- return submitToDs(wTx);
+ return submitToDs(writeTx);
}
private static boolean addTunnelsOfOverlayConfig(List<Tunnel> tunnels, NodeId nodeId, DataBroker dataBroker) {
}
private static boolean addTunnelsOfOverlayConfig(List<Tunnel> tunnels, NodeId nodeId, DataBroker dataBroker) {
- ReadWriteTransaction wTx = dataBroker.newReadWriteTransaction();
+ ReadWriteTransaction writeTx = dataBroker.newReadWriteTransaction();
for (Tunnel tunnel : tunnels) {
InstanceIdentifier<Tunnel> tunnelIid = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(nodeId))
.augmentation(OfOverlayNodeConfig.class)
.child(Tunnel.class, tunnel.getKey())
.build();
for (Tunnel tunnel : tunnels) {
InstanceIdentifier<Tunnel> tunnelIid = InstanceIdentifier.builder(Nodes.class)
.child(Node.class, new NodeKey(nodeId))
.augmentation(OfOverlayNodeConfig.class)
.child(Tunnel.class, tunnel.getKey())
.build();
- wTx.put(LogicalDatastoreType.CONFIGURATION, tunnelIid, tunnel, true);
+ writeTx.put(LogicalDatastoreType.CONFIGURATION, tunnelIid, tunnel, true);
LOG.trace("Adding tunnel: {} to node {}",tunnel, nodeId.getValue());
}
LOG.trace("Adding tunnel: {} to node {}",tunnel, nodeId.getValue());
}
- return submitToDs(wTx);
+ return submitToDs(writeTx);
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
+import com.google.common.base.Optional;
+
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPortKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPortKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-
public class NeutronHelper {
/**
* This looks up the Endpoint L2 key from an
public class NeutronHelper {
/**
* This looks up the Endpoint L2 key from an
- * operational data store kept in neutron-mapper
+ * operational data store kept in neutron-mapper.
*
* @param externalId The neutron port UUID
* @param dataBroker {@link DataBroker} to use for the transaction
*
* @param externalId The neutron port UUID
* @param dataBroker {@link DataBroker} to use for the transaction
return topologyIid(ovsdbTopologyId).child(Node.class, new NodeKey(nodeId));
}
return topologyIid(ovsdbTopologyId).child(Node.class, new NodeKey(nodeId));
}
+ @SuppressWarnings("checkstyle:LineLength") // Longer lines in this method are caused by long package names.
public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeIid(
org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId nodeId) {
return InstanceIdentifier.builder(Nodes.class)
public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeIid(
org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId nodeId) {
return InstanceIdentifier.builder(Nodes.class)
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.submitToDs;
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.submitToDs;
+import com.google.common.base.Optional;
+
import java.util.ArrayList;
import java.util.List;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbHelper {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbHelper.class);
private static final String OF_PORT = "6653";
/**
* Look up the {@link OvsdbBridgeAugmentation} from the data store
public class OvsdbHelper {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbHelper.class);
private static final String OF_PORT = "6653";
/**
* Look up the {@link OvsdbBridgeAugmentation} from the data store
- * given a child {@link InstanceIdentifier} of {@link OvsdbTerminationPointAugmentation}
+ * given a child {@link InstanceIdentifier} of {@link OvsdbTerminationPointAugmentation}.
*
* @param tpIid The InstanceIdentifier for a child TerminationPoint augmentation
* @param dataBroker the {@link DataBroker}
*
* @param tpIid The InstanceIdentifier for a child TerminationPoint augmentation
* @param dataBroker the {@link DataBroker}
InstanceIdentifier<OvsdbTerminationPointAugmentation> tpIid, DataBroker dataBroker) {
InstanceIdentifier<Node> nodeIid = tpIid.firstIdentifierOf(Node.class);
if (nodeIid != null) {
InstanceIdentifier<OvsdbTerminationPointAugmentation> tpIid, DataBroker dataBroker) {
InstanceIdentifier<Node> nodeIid = tpIid.firstIdentifierOf(Node.class);
if (nodeIid != null) {
- InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbBridgeIid = nodeIid.augmentation(OvsdbBridgeAugmentation.class);
+ InstanceIdentifier<OvsdbBridgeAugmentation>
+ ovsdbBridgeIid = nodeIid.augmentation(OvsdbBridgeAugmentation.class);
if (ovsdbBridgeIid != null) {
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
Optional<OvsdbBridgeAugmentation> ovsdbBridge =
if (ovsdbBridgeIid != null) {
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
Optional<OvsdbBridgeAugmentation> ovsdbBridge =
public static Node getNodeFromBridgeRef(OvsdbBridgeRef bridgeRef, DataBroker dataBroker) {
InstanceIdentifier<Node> nodeIid = bridgeRef.getValue().firstIdentifierOf(Node.class);
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
public static Node getNodeFromBridgeRef(OvsdbBridgeRef bridgeRef, DataBroker dataBroker) {
InstanceIdentifier<Node> nodeIid = bridgeRef.getValue().firstIdentifierOf(Node.class);
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
- Optional<?> node =
- readFromDs(LogicalDatastoreType.OPERATIONAL, nodeIid, transaction );
+ Optional<?> node = readFromDs(LogicalDatastoreType.OPERATIONAL, nodeIid, transaction);
if (node.isPresent()) {
if (node.get() instanceof Node) {
if (node.isPresent()) {
if (node.get() instanceof Node) {
- return (Node)node.get();
+ return (Node) node.get();
public static OvsdbTerminationPointAugmentation getOvsdbTerminationPoint(
InstanceIdentifier<OvsdbTerminationPointAugmentation> tpIid, DataBroker dataBroker) {
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
public static OvsdbTerminationPointAugmentation getOvsdbTerminationPoint(
InstanceIdentifier<OvsdbTerminationPointAugmentation> tpIid, DataBroker dataBroker) {
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
- Optional<OvsdbTerminationPointAugmentation> ovsdbTp =
- readFromDs(LogicalDatastoreType.OPERATIONAL, tpIid, transaction );
+ Optional<OvsdbTerminationPointAugmentation>
+ ovsdbTp = readFromDs(LogicalDatastoreType.OPERATIONAL, tpIid, transaction);
if (ovsdbTp.isPresent()) {
return ovsdbTp.get();
}
if (ovsdbTp.isPresent()) {
return ovsdbTp.get();
}
return tunnelType.getTunnelPrefix() + bridge.getBridgeName().getValue();
}
return tunnelType.getTunnelPrefix() + bridge.getBridgeName().getValue();
}
- public static OvsdbTerminationPointAugmentation buildOvsdbTerminationPointAugmentation(OvsdbBridgeAugmentation bridge,
- List<Options> options, AbstractTunnelType tunnelType) {
+ public static OvsdbTerminationPointAugmentation buildOvsdbTerminationPointAugmentation(
+ OvsdbBridgeAugmentation bridge, List<Options> options, AbstractTunnelType tunnelType) {
OvsdbTerminationPointAugmentationBuilder ovsdbTpBuilder = new OvsdbTerminationPointAugmentationBuilder();
ovsdbTpBuilder.setName(generateTpName(bridge, tunnelType));
ovsdbTpBuilder.setOptions(options);
OvsdbTerminationPointAugmentationBuilder ovsdbTpBuilder = new OvsdbTerminationPointAugmentationBuilder();
ovsdbTpBuilder.setName(generateTpName(bridge, tunnelType));
ovsdbTpBuilder.setOptions(options);
- * Get the manager node for this bridge node
+ * Get the manager node for this bridge node.
*
* @param bridge the bridge node
* @param dataBroker the {@link DataBroker}
*
* @param bridge the bridge node
* @param dataBroker the {@link DataBroker}
*/
public static OvsdbNodeAugmentation getManagerNode(OvsdbBridgeAugmentation bridge, DataBroker dataBroker) {
OvsdbNodeRef bareIId = bridge.getManagedBy();
*/
public static OvsdbNodeAugmentation getManagerNode(OvsdbBridgeAugmentation bridge, DataBroker dataBroker) {
OvsdbNodeRef bareIId = bridge.getManagedBy();
- if(bareIId != null) {
- if(bareIId.getValue().getTargetType().equals(Node.class)) {
+ if (bareIId != null) {
+ if (bareIId.getValue().getTargetType().equals(Node.class)) {
ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
InstanceIdentifier<Node> iid = (InstanceIdentifier<Node>) bareIId.getValue();
Optional<Node> nodeOptional = readFromDs(LogicalDatastoreType.OPERATIONAL, iid, transaction);
ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
InstanceIdentifier<Node> iid = (InstanceIdentifier<Node>) bareIId.getValue();
Optional<Node> nodeOptional = readFromDs(LogicalDatastoreType.OPERATIONAL, iid, transaction);
- if(nodeOptional.isPresent()
- && nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class) != null) {
+ if (nodeOptional.isPresent()
+ && nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class) != null) {
return nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class);
} else {
return nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class);
} else {
- LOG.warn("Could not find ovsdb-node for connection for {}",bridge);
+ LOG.warn("Could not find ovsdb-node for connection for {}", bridge);
- LOG.warn("Bridge 'managedBy' non-ovsdb-node. bridge {} getManagedBy() {}",bridge,bareIId.getValue());
+ LOG.warn("Bridge 'managedBy' non-ovsdb-node. bridge {} getManagedBy() {}", bridge, bareIId.getValue());
}
} else {
LOG.debug("Bridge 'managedBy' is null. bridge {}",bridge);
}
} else {
LOG.debug("Bridge 'managedBy' is null. bridge {}",bridge);
public static Node getTopologyNode(InstanceIdentifier<Node> nodeIid, DataBroker dataBroker) {
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
public static Node getTopologyNode(InstanceIdentifier<Node> nodeIid, DataBroker dataBroker) {
ReadTransaction transaction = dataBroker.newReadOnlyTransaction();
- Optional<Node> nodeOptional =
- readFromDs(LogicalDatastoreType.OPERATIONAL, nodeIid, transaction );
+ Optional<Node> nodeOptional = readFromDs(LogicalDatastoreType.OPERATIONAL, nodeIid, transaction);
if (nodeOptional.isPresent()) {
return nodeOptional.get();
}
if (nodeOptional.isPresent()) {
return nodeOptional.get();
}
*/
public static void createTunnelPort(InstanceIdentifier<Node> nodeIid,
Node node, AbstractTunnelType tunnelType, DataBroker dataBroker) {
*/
public static void createTunnelPort(InstanceIdentifier<Node> nodeIid,
Node node, AbstractTunnelType tunnelType, DataBroker dataBroker) {
- ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
if (bridge == null) {
LOG.warn("No OvsdbBridgeAugmentationfor Node {}", node);
OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
if (bridge == null) {
LOG.warn("No OvsdbBridgeAugmentationfor Node {}", node);
}
OvsdbNodeAugmentation managerNode = getManagerNode(bridge, dataBroker);
}
OvsdbNodeAugmentation managerNode = getManagerNode(bridge, dataBroker);
- if(managerNode == null) {
+ if (managerNode == null) {
LOG.warn("Couldn't create tunnel port for Node {}, no manager", node);
return;
}
List<Options> options = tunnelType.getOptions();
LOG.warn("Couldn't create tunnel port for Node {}, no manager", node);
return;
}
List<Options> options = tunnelType.getOptions();
- OvsdbTerminationPointAugmentation ovsdbTp =
- buildOvsdbTerminationPointAugmentation(bridge,options, tunnelType);
+ OvsdbTerminationPointAugmentation ovsdbTp = buildOvsdbTerminationPointAugmentation(bridge, options, tunnelType);
List<TerminationPoint> tps = buildTerminationPoints(bridge,ovsdbTp, tunnelType);
List<TerminationPoint> tps = buildTerminationPoints(bridge,ovsdbTp, tunnelType);
- OvsdbBridgeAugmentation ovsdbBridgeAugmentation =
- buildOvsdbBridgeAugmentation(bridge,managerNode);
+ OvsdbBridgeAugmentation ovsdbBridgeAugmentation = buildOvsdbBridgeAugmentation(bridge,managerNode);
Node configNode = getNode(node, tps,ovsdbBridgeAugmentation);
LOG.info("About to write nodeId {} node {}",nodeIid,configNode);
Node configNode = getNode(node, tps,ovsdbBridgeAugmentation);
LOG.info("About to write nodeId {} node {}",nodeIid,configNode);
- transaction.merge(LogicalDatastoreType.CONFIGURATION, nodeIid, configNode);
- submitToDs(transaction);
+ ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
+ rwTx.merge(LogicalDatastoreType.CONFIGURATION, nodeIid, configNode);
+ submitToDs(rwTx);
import static org.mockito.Mockito.when;
import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.OvsdbNodeListener.BRIDGE_SEPARATOR;
import static org.mockito.Mockito.when;
import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.OvsdbNodeListener.BRIDGE_SEPARATOR;
-import java.util.Collection;
-import java.util.HashSet;
-
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.CheckedFuture;
+
+import java.util.Collection;
+import java.util.HashSet;
+
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
public class OvsdbNodeListenerTest {
private static final String OVSDB_BRIDGE_NAME = "ovsdbBridgeName";
public class OvsdbNodeListenerTest {
private static final String OVSDB_BRIDGE_NAME = "ovsdbBridgeName";
- private static final String NODE_ID = "nodeId";
- private static final NodeId nodeId = new NodeId(NODE_ID);
- private static final TopologyId topologyId = new TopologyId("topologyId");
+ private static final String NODE_ID_STIRNG = "nodeId";
+ private static final NodeId NODE_ID = new NodeId(NODE_ID_STIRNG);
+ private static final TopologyId TOPOLOGY_ID = new TopologyId("topologyId");
private DataBroker dataBroker;
private IntegrationBridgeSetting integrationBridgeSetting;
private DataBroker dataBroker;
private IntegrationBridgeSetting integrationBridgeSetting;
private ImmutableSet<DataTreeModification<Node>> changes;
private Node nodeBefore;
private Node nodeAfter;
private ImmutableSet<DataTreeModification<Node>> changes;
private Node nodeBefore;
private Node nodeAfter;
- private WriteTransaction wTx;
+ private WriteTransaction writeTx;
private InstanceIdentifier<Node> bridgeNodeIid;
private Node bridge;
private InstanceIdentifier<Node> bridgeNodeIid;
private Node bridge;
.build();
rootNode = mock(DataObjectModification.class);
.build();
rootNode = mock(DataObjectModification.class);
- rootIdentifier = NeutronOvsdbIidFactory.nodeIid(topologyId, nodeId);
+ rootIdentifier = NeutronOvsdbIidFactory.nodeIid(TOPOLOGY_ID, NODE_ID);
DataTreeIdentifier<Node> rootPath =
new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);
DataTreeIdentifier<Node> rootPath =
new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, rootIdentifier);
changes = ImmutableSet.of(change);
bridgeNodeIid = NeutronOvsdbIidFactory.nodeIid(
changes = ImmutableSet.of(change);
bridgeNodeIid = NeutronOvsdbIidFactory.nodeIid(
- rootIdentifier.firstKeyOf(Topology.class).getTopologyId(), nodeId);
+ rootIdentifier.firstKeyOf(Topology.class).getTopologyId(), NODE_ID);
ManagerEntry managerEntry = new ManagerEntryBuilder()
.setTarget(new Uri("something:192.168.50.9:1234"))
ManagerEntry managerEntry = new ManagerEntryBuilder()
.setTarget(new Uri("something:192.168.50.9:1234"))
.addAugmentation(OvsdbNodeAugmentation.class, ovsdbNode)
.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridge).build();
.addAugmentation(OvsdbNodeAugmentation.class, ovsdbNode)
.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridge).build();
- wTx = mock(WriteTransaction.class);
- when(dataBroker.newWriteOnlyTransaction()).thenReturn(wTx);
+ writeTx = mock(WriteTransaction.class);
+ when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTx);
DataObjectModification<OvsdbNodeAugmentation> modifiedOvsdbNode = mock(DataObjectModification.class);
DataObjectModification<OpenvswitchOtherConfigs> ovsOtherConfigModification = mock(DataObjectModification.class);
OpenvswitchOtherConfigs newConfig = new OpenvswitchOtherConfigsBuilder()
.setOtherConfigKey(OvsdbNodeListener.NEUTRON_PROVIDER_MAPPINGS_KEY)
DataObjectModification<OvsdbNodeAugmentation> modifiedOvsdbNode = mock(DataObjectModification.class);
DataObjectModification<OpenvswitchOtherConfigs> ovsOtherConfigModification = mock(DataObjectModification.class);
OpenvswitchOtherConfigs newConfig = new OpenvswitchOtherConfigsBuilder()
.setOtherConfigKey(OvsdbNodeListener.NEUTRON_PROVIDER_MAPPINGS_KEY)
- .setOtherConfigValue("otherConfigValue:" + NODE_ID)
+ .setOtherConfigValue("otherConfigValue:" + NODE_ID_STIRNG)
.build();
when(ovsOtherConfigModification.getDataBefore()).thenReturn(null);
when(ovsOtherConfigModification.getDataAfter()).thenReturn(newConfig);
.build();
when(ovsOtherConfigModification.getDataBefore()).thenReturn(null);
when(ovsOtherConfigModification.getDataAfter()).thenReturn(newConfig);
bridge = new NodeBuilder()
.setNodeId(nodeId)
.build();
bridge = new NodeBuilder()
.setNodeId(nodeId)
.build();
- //doNothing().when(wTx).merge(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid, bridge, true);
+ //doNothing().when(writeTx).merge(LogicalDatastoreType.CONFIGURATION, bridgeNodeIid, bridge, true);
CheckedFuture<Void, TransactionCommitFailedException> fut = mock(CheckedFuture.class);
CheckedFuture<Void, TransactionCommitFailedException> fut = mock(CheckedFuture.class);
- when(wTx.submit()).thenReturn(fut);
+ when(writeTx.submit()).thenReturn(fut);
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
new OvsdbTerminationPointAugmentationBuilder().build();
OvsdbTerminationPointAugmentation ovsdbTerminationPointAugmentation =
new OvsdbTerminationPointAugmentationBuilder().build();
mock(DataObjectModification.class);
OvsdbTerminationPointAugmentation newOvsdbTp = new OvsdbTerminationPointAugmentationBuilder()
mock(DataObjectModification.class);
OvsdbTerminationPointAugmentation newOvsdbTp = new OvsdbTerminationPointAugmentationBuilder()
+ .setName(NODE_ID_STIRNG)
.setOfport(1234L)
.build();
when(modifiedOvsdbTerminationPointAugmentation.getDataAfter()).thenReturn(newOvsdbTp);
.setOfport(1234L)
.build();
when(modifiedOvsdbTerminationPointAugmentation.getDataAfter()).thenReturn(newOvsdbTp);
listener.onDataTreeChanged(changes);
listener.onDataTreeChanged(changes);
- verify(wTx).merge(eq(LogicalDatastoreType.CONFIGURATION), any(InstanceIdentifier.class), any(Node.class), eq(true));
+ verify(writeTx).merge(eq(LogicalDatastoreType.CONFIGURATION), any(InstanceIdentifier.class), any(Node.class),
+ eq(true));
when(dataBroker.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
any(DataTreeChangeListener.class))).thenReturn(registration);
when(dataBroker.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
any(DataTreeChangeListener.class))).thenReturn(registration);
- InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid = InstanceIdentifier.create(
- NetworkTopology.class)
- .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
- .child(Node.class)
- .child(TerminationPoint.class)
- .augmentation(OvsdbTerminationPointAugmentation.class);
ovsdbTp = mock(OvsdbTerminationPointAugmentation.class);
when(ovsdbTp.getInterfaceType()).thenReturn((Class) Object.class);
InterfaceExternalIds externalId = mock(InterfaceExternalIds.class);
ovsdbTp = mock(OvsdbTerminationPointAugmentation.class);
when(ovsdbTp.getInterfaceType()).thenReturn((Class) Object.class);
InterfaceExternalIds externalId = mock(InterfaceExternalIds.class);
mock(DataTreeModification.class);
mockModification = mock(DataObjectModification.class);
doReturn(mockModification).when(mockDataTreeModification).getRootNode();
mock(DataTreeModification.class);
mockModification = mock(DataObjectModification.class);
doReturn(mockModification).when(mockDataTreeModification).getRootNode();
+
+ InstanceIdentifier<OvsdbTerminationPointAugmentation> ovsdbTpIid = InstanceIdentifier.create(
+ NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class)
+ .child(TerminationPoint.class)
+ .augmentation(OvsdbTerminationPointAugmentation.class);
doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, ovsdbTpIid))
.when(mockDataTreeModification).getRootPath();
changeEvent = Collections.singletonList(mockDataTreeModification);
doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, ovsdbTpIid))
.when(mockDataTreeModification).getRootPath();
changeEvent = Collections.singletonList(mockDataTreeModification);
private List<Options> nshOptions = null;
private List<Options> ofOverlayOptions = null;
private List<Options> nshOptions = null;
private List<Options> ofOverlayOptions = null;
- @Before
- public void setUp() throws Exception {
+
+ @Before public void setUp() throws Exception {
nshOptions = new ArrayList<Options>();
ofOverlayOptions = new ArrayList<Options>();
OptionsBuilder ob = new OptionsBuilder();
nshOptions = new ArrayList<Options>();
ofOverlayOptions = new ArrayList<Options>();
OptionsBuilder ob = new OptionsBuilder();
- ob.setOption(VNID_KEY)
- .setValue(VNID_VALUE);
+ ob.setOption(VNID_KEY).setValue(VNID_VALUE);
nshOptions.add(ob.build());
ofOverlayOptions.add(ob.build());
ob = new OptionsBuilder();
nshOptions.add(ob.build());
ofOverlayOptions.add(ob.build());
ob = new OptionsBuilder();
- ob.setOption(REMOTE_IP_KEY)
- .setValue(REMOTE_IP_VALUE);
+ ob.setOption(REMOTE_IP_KEY).setValue(REMOTE_IP_VALUE);
nshOptions.add(ob.build());
ofOverlayOptions.add(ob.build());
ob = new OptionsBuilder();
nshOptions.add(ob.build());
ofOverlayOptions.add(ob.build());
ob = new OptionsBuilder();
- ob.setOption(NSH_NSI_KEY)
- .setValue(NSH_NSI_VALUE);
+ ob.setOption(NSH_NSI_KEY).setValue(NSH_NSI_VALUE);
nshOptions.add(ob.build());
ob = new OptionsBuilder();
nshOptions.add(ob.build());
ob = new OptionsBuilder();
- ob.setOption(NSH_NSP_KEY)
- .setValue(NSH_NSP_VALUE);
+ ob.setOption(NSH_NSP_KEY).setValue(NSH_NSP_VALUE);
nshOptions.add(ob.build());
ob = new OptionsBuilder();
nshOptions.add(ob.build());
ob = new OptionsBuilder();
- ob.setOption(NSH_NSHC1_KEY)
- .setValue(NSH_NSHC1_VALUE);
+ ob.setOption(NSH_NSHC1_KEY).setValue(NSH_NSHC1_VALUE);
nshOptions.add(ob.build());
ob = new OptionsBuilder();
nshOptions.add(ob.build());
ob = new OptionsBuilder();
- ob.setOption(NSH_NSHC2_KEY)
- .setValue(NSH_NSHC2_VALUE);
+ ob.setOption(NSH_NSHC2_KEY).setValue(NSH_NSHC2_VALUE);
nshOptions.add(ob.build());
ob = new OptionsBuilder();
nshOptions.add(ob.build());
ob = new OptionsBuilder();
- ob.setOption(NSH_NSHC3_KEY)
- .setValue(NSH_NSHC3_VALUE);
+ ob.setOption(NSH_NSHC3_KEY).setValue(NSH_NSHC3_VALUE);
nshOptions.add(ob.build());
ob = new OptionsBuilder();
nshOptions.add(ob.build());
ob = new OptionsBuilder();
- ob.setOption(NSH_NSHC4_KEY)
- .setValue(NSH_NSHC4_VALUE);
+ ob.setOption(NSH_NSHC4_KEY).setValue(NSH_NSHC4_VALUE);
nshOptions.add(ob.build());
ob = new OptionsBuilder();
nshOptions.add(ob.build());
ob = new OptionsBuilder();
- ob.setOption(DESTPORT_KEY)
- .setValue(DESTPORT_VALUE);
+ ob.setOption(DESTPORT_KEY).setValue(DESTPORT_VALUE);
nshOptions.add(ob.build());
}
nshOptions.add(ob.build());
}
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.util.Collections;
-
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
+
+import java.util.Collections;
+
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
@SuppressWarnings({"unchecked", "rawtypes"})
@Test
public void testUpdateOfOverlayConfig() throws Exception {
@SuppressWarnings({"unchecked", "rawtypes"})
@Test
public void testUpdateOfOverlayConfig() throws Exception {
- IpAddress ip = mock(IpAddress.class);
- String nodeConnectorIdString = "nodeConnectorIdString";
AbstractTunnelType tunnelType = mock(AbstractTunnelType.class);
when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
AbstractTunnelType tunnelType = mock(AbstractTunnelType.class);
when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
CheckedFuture<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(submitFuture);
CheckedFuture<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(submitFuture);
+ IpAddress ip = mock(IpAddress.class);
+ String nodeConnectorIdString = "nodeConnectorIdString";
InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker);
verify(writeTransaction).submit();
}
InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker);
verify(writeTransaction).submit();
}
@SuppressWarnings("unchecked")
@Test
public void testUpdateOfOverlayConfig_OfConfigNull() throws Exception {
@SuppressWarnings("unchecked")
@Test
public void testUpdateOfOverlayConfig_OfConfigNull() throws Exception {
- IpAddress ip = mock(IpAddress.class);
- String nodeConnectorIdString = "nodeConnectorIdString";
- AbstractTunnelType tunnelType = mock(AbstractTunnelType.class);
-
when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
.thenReturn(nodeConfigFuture);
when(nodeConfigOptional.isPresent()).thenReturn(false);
when(writeTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
.thenReturn(nodeConfigFuture);
when(nodeConfigOptional.isPresent()).thenReturn(false);
CheckedFuture<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(submitFuture);
CheckedFuture<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(submitFuture);
+ IpAddress ip = mock(IpAddress.class);
+ String nodeConnectorIdString = "nodeConnectorIdString";
+ AbstractTunnelType tunnelType = mock(AbstractTunnelType.class);
InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker);
verify(writeTransaction).submit();
}
InventoryHelper.updateOfOverlayConfig(ip, nodeIdString, nodeConnectorIdString, tunnelType, dataBroker);
verify(writeTransaction).submit();
}
InstanceIdentifier<ExternalGatewayAsL3Endpoint> iid =
NeutronOvsdbIidFactory.neutronGbpExternalGatewayIidWildcard();
assertNotNull(iid);
InstanceIdentifier<ExternalGatewayAsL3Endpoint> iid =
NeutronOvsdbIidFactory.neutronGbpExternalGatewayIidWildcard();
assertNotNull(iid);
- Class<?>[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class, ExternalGatewaysAsL3Endpoints.class,
+ Class<?>[] expectedTypes =
+ {Mappings.class, NeutronByGbpMappings.class, ExternalGatewaysAsL3Endpoints.class,
ExternalGatewayAsL3Endpoint.class};
assertPathArgumentTypes(iid.getPathArguments(), expectedTypes);
assertEquals(ExternalGatewayAsL3Endpoint.class, iid.getTargetType());
ExternalGatewayAsL3Endpoint.class};
assertPathArgumentTypes(iid.getPathArguments(), expectedTypes);
assertEquals(ExternalGatewayAsL3Endpoint.class, iid.getTargetType());
InstanceIdentifier<EndpointByPort> iid = NeutronOvsdbIidFactory.endpointByPortIid(new UniqueId(portId));
assertNotNull(iid);
Class<?>[] expectedTypes =
InstanceIdentifier<EndpointByPort> iid = NeutronOvsdbIidFactory.endpointByPortIid(new UniqueId(portId));
assertNotNull(iid);
Class<?>[] expectedTypes =
- {Mappings.class, GbpByNeutronMappings.class, EndpointsByPorts.class, EndpointByPort.class};
+ {Mappings.class, GbpByNeutronMappings.class, EndpointsByPorts.class, EndpointByPort.class};
assertPathArgumentTypes(iid.getPathArguments(), expectedTypes);
assertEquals(EndpointByPort.class, iid.getTargetType());
assertFalse(iid.isWildcarded());
assertPathArgumentTypes(iid.getPathArguments(), expectedTypes);
assertEquals(EndpointByPort.class, iid.getTargetType());
assertFalse(iid.isWildcarded());
public void test_NeutronGbpMappingsIidWildcard() {
InstanceIdentifier<NeutronByGbpMappings> iid = NeutronOvsdbIidFactory.neutronGbpMappingsIidWildcard();
assertNotNull(iid);
public void test_NeutronGbpMappingsIidWildcard() {
InstanceIdentifier<NeutronByGbpMappings> iid = NeutronOvsdbIidFactory.neutronGbpMappingsIidWildcard();
assertNotNull(iid);
Class<?>[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class};
assertPathArgumentTypes(iid.getPathArguments(), expectedTypes);
assertEquals(NeutronByGbpMappings.class, iid.getTargetType());
Class<?>[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class};
assertPathArgumentTypes(iid.getPathArguments(), expectedTypes);
assertEquals(NeutronByGbpMappings.class, iid.getTargetType());
NeutronOvsdbIidFactory.nodeIid(nodeId);
assertNotNull(iid);
Class<?>[] expectedTypes =
NeutronOvsdbIidFactory.nodeIid(nodeId);
assertNotNull(iid);
Class<?>[] expectedTypes =
- {Nodes.class, org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class};
+ {Nodes.class, org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class};
assertPathArgumentTypes(iid.getPathArguments(), expectedTypes);
assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class,
iid.getTargetType());
assertPathArgumentTypes(iid.getPathArguments(), expectedTypes);
assertEquals(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class,
iid.getTargetType());
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
Code Review / groupbasedpolicy.git / commitdiff