[ONOS-3804] [ONOS-3805] Initial L3 flowrules setup for Compute/Gateway nodes and PNAT Handler for OpenstackRouting
- Performs app refactoring (openstackrouting and openstackswitching)
- Implements L3 REST call corresponding openstackRouter and openstackRouterInterface.
- Implements initail L3 rules population to compute/gateway node.
- Implements PNAT rules population corresponding packet-in event.
- Fixs comments and javadocs.
- Rebases on master.
Change-Id: I5ad68810f50dc977737d30c43150c892b978b7cb
diff --git a/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackPnatHandler.java b/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackPnatHandler.java
index 40eed7f..65b8a5f 100644
--- a/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackPnatHandler.java
+++ b/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackPnatHandler.java
@@ -17,24 +17,29 @@
import org.onlab.packet.Ethernet;
import org.onlab.packet.IPv4;
+import org.onlab.packet.Ip4Address;
import org.onlab.packet.MacAddress;
import org.onlab.packet.TCP;
import org.onlab.packet.UDP;
import org.onosproject.net.DeviceId;
-import org.onosproject.net.PortNumber;
+import org.onosproject.net.Port;
import org.onosproject.net.flow.DefaultTrafficTreatment;
import org.onosproject.net.flow.TrafficTreatment;
import org.onosproject.net.packet.DefaultOutboundPacket;
import org.onosproject.net.packet.InboundPacket;
import org.onosproject.net.packet.PacketContext;
import org.onosproject.net.packet.PacketService;
+import org.onosproject.openstacknetworking.OpenstackNetwork;
+import org.onosproject.openstacknetworking.OpenstackNetworkingService;
import org.onosproject.openstacknetworking.OpenstackPort;
+import org.onosproject.openstacknetworking.OpenstackRouter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.ByteBuffer;
import static com.google.common.base.Preconditions.checkNotNull;
+import static org.onlab.osgi.DefaultServiceDirectory.getService;
/**
@@ -50,13 +55,20 @@
private final OpenstackRoutingRulePopulator rulePopulator;
private final int portNum;
private final OpenstackPort openstackPort;
+ private final Port port;
+
+ private static final String DEVICE_OWNER_ROUTER_INTERFACE = "network:router_interface";
+ // TODO: This will be replaced to get the information from openstacknetworkingservice.
+ private static final MacAddress GATEWAYMAC = MacAddress.valueOf("1f:1f:1f:1f:1f:1f");
+ private static final MacAddress EXTERNAL_INTERFACE_MAC = MacAddress.valueOf("00:00:00:00:00:11");
OpenstackPnatHandler(OpenstackRoutingRulePopulator rulePopulator, PacketContext context,
- int portNum, OpenstackPort openstackPort) {
+ int portNum, OpenstackPort openstackPort, Port port) {
this.rulePopulator = checkNotNull(rulePopulator);
this.context = checkNotNull(context);
this.portNum = checkNotNull(portNum);
this.openstackPort = checkNotNull(openstackPort);
+ this.port = checkNotNull(port);
}
@Override
@@ -70,14 +82,41 @@
return;
}
- packetOut(inboundPacket, portNum);
+ OpenstackRouter router = getOpenstackRouter(openstackPort);
rulePopulator.populatePnatFlowRules(inboundPacket, openstackPort, portNum,
- getExternalInterfaceMacAddress(), getExternalRouterMacAddress());
+ getExternalIp(router), getExternalInterfaceMacAddress(), getExternalRouterMacAddress());
+
+ packetOut((Ethernet) ethernet.clone(), inboundPacket.receivedFrom().deviceId(), portNum, router);
}
- private void packetOut(InboundPacket inboundPacket, int portNum) {
- Ethernet ethernet = checkNotNull(inboundPacket.parsed());
+ private OpenstackRouter getOpenstackRouter(OpenstackPort openstackPort) {
+ OpenstackNetworkingService networkingService = getService(OpenstackNetworkingService.class);
+ OpenstackNetwork network = networkingService.network(openstackPort.networkId());
+
+ OpenstackPort port = networkingService.ports()
+ .stream()
+ .filter(p -> p.deviceOwner().equals(DEVICE_OWNER_ROUTER_INTERFACE))
+ .filter(p -> checkSameSubnet(p, openstackPort))
+ .findAny()
+ .orElse(null);
+
+ return checkNotNull(networkingService.router(port.deviceId()));
+ }
+
+ private boolean checkSameSubnet(OpenstackPort p, OpenstackPort openstackPort) {
+ String key1 = checkNotNull(p.fixedIps().keySet().stream().findFirst().orElse(null)).toString();
+ String key2 = checkNotNull(openstackPort.fixedIps().keySet().stream().findFirst().orElse(null)).toString();
+ return key1.equals(key2) ? true : false;
+ }
+
+ private Ip4Address getExternalIp(OpenstackRouter router) {
+ return router.gatewayExternalInfo().externalFixedIps().values().stream().findAny().orElse(null);
+ }
+
+ private void packetOut(Ethernet ethernet, DeviceId deviceId, int portNum, OpenstackRouter router) {
+ PacketService packetService = getService(PacketService.class);
+
IPv4 iPacket = (IPv4) ethernet.getPayload();
TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
@@ -98,31 +137,27 @@
iPacket.setPayload(udpPacket);
break;
default:
- break;
+ log.error("Temporally, this method can process UDP and TCP protocol.");
+ return;
}
+ iPacket.setSourceAddress(getExternalIp(router).toString());
iPacket.resetChecksum();
- iPacket.setPayload(ethernet);
+ iPacket.setParent(ethernet);
ethernet.setSourceMACAddress(getExternalInterfaceMacAddress())
.setDestinationMACAddress(getExternalRouterMacAddress());
ethernet.resetChecksum();
- treatment.setOutput(getExternalPort(inboundPacket.receivedFrom().deviceId()));
+ treatment.setOutput(port.number());
- packetService.emit(new DefaultOutboundPacket(inboundPacket.receivedFrom().deviceId(),
- treatment.build(), ByteBuffer.wrap(ethernet.serialize())));
+ packetService.emit(new DefaultOutboundPacket(deviceId, treatment.build(),
+ ByteBuffer.wrap(ethernet.serialize())));
}
- private PortNumber getExternalPort(DeviceId deviceId) {
- // TODO
- return null;
- }
private MacAddress getExternalInterfaceMacAddress() {
- // TODO
- return null;
+ return EXTERNAL_INTERFACE_MAC;
}
private MacAddress getExternalRouterMacAddress() {
- // TODO
- return null;
+ return GATEWAYMAC;
}
}
\ No newline at end of file
diff --git a/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackRoutingManager.java b/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackRoutingManager.java
index 2ea5935..ab8c386 100644
--- a/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackRoutingManager.java
+++ b/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackRoutingManager.java
@@ -29,6 +29,8 @@
import org.onlab.packet.MacAddress;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Port;
import org.onosproject.net.device.DeviceService;
import org.onosproject.net.driver.DriverService;
import org.onosproject.net.flowobjective.FlowObjectiveService;
@@ -55,14 +57,14 @@
import static com.google.common.base.Preconditions.checkNotNull;
import static org.onlab.util.Tools.groupedThreads;
-@Service
@Component(immediate = true)
+@Service
/**
* Populates flow rules about L3 functionality for VMs in Openstack.
*/
public class OpenstackRoutingManager implements OpenstackRoutingService {
- private final Logger log = LoggerFactory
- .getLogger(getClass());
+
+ private final Logger log = LoggerFactory.getLogger(getClass());
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected CoreService coreService;
@@ -86,6 +88,12 @@
private Map<String, OpenstackRouterInterface> routerInterfaceMap = Maps.newHashMap();
private Map<Integer, String> portNumMap = initPortNumMap();
private static final String APP_ID = "org.onosproject.openstackrouting";
+ private static final String PORT_NAME = "portName";
+ private static final String DEVICE_OWNER_ROUTER_INTERFACE = "network:router_interface";
+
+ // TODO: This will be replaced to get the information from openstackswitchingservice.
+ private static final String EXTERNAL_INTERFACE_NAME = "veth0";
+
private Map<Integer, String> initPortNumMap() {
Map<Integer, String> map = Maps.newHashMap();
for (int i = 1024; i < 65535; i++) {
@@ -104,7 +112,7 @@
protected void activate() {
appId = coreService.registerApplication(APP_ID);
packetService.addProcessor(internalPacketProcessor, PacketProcessor.director(1));
-
+ reloadInitL3Rules();
log.info("onos-openstackrouting started");
}
@@ -150,7 +158,7 @@
routerInterfaceMap.putIfAbsent(routerInterface.portId(), routerInterface);
List<OpenstackRouterInterface> routerInterfaces = Lists.newArrayList();
routerInterfaces.add(routerInterface);
- checkExternalConnection(getOpenstackRouter(routerInterface.tenantId()), routerInterfaces);
+ checkExternalConnection(getOpenstackRouter(routerInterface.portId()), routerInterfaces);
}
@Override
@@ -160,6 +168,27 @@
rulePopulator.removeExternalRules(routerInterface);
routerInterfaceMap.remove(routerInterface.portId());
}
+
+ private void reloadInitL3Rules() {
+ openstackService.ports()
+ .stream()
+ .filter(p -> p.deviceOwner().equals(DEVICE_OWNER_ROUTER_INTERFACE))
+ .forEach(p -> {
+ OpenstackRouterInterface routerInterface = portToRouterInterface(p);
+ updateRouterInterface(routerInterface);
+ });
+ }
+
+ private OpenstackRouterInterface portToRouterInterface(OpenstackPort p) {
+ OpenstackRouterInterface.Builder osBuilder = new OpenstackRouterInterface.Builder()
+ .id(checkNotNull(p.id()))
+ .tenantId(checkNotNull(openstackService.network(p.networkId()).tenantId()))
+ .subnetId(checkNotNull(p.fixedIps().keySet().stream().findFirst().orElse(null)).toString())
+ .portId(checkNotNull(p.deviceId()));
+
+ return osBuilder.build();
+ }
+
private class InternalPacketProcessor implements PacketProcessor {
@Override
@@ -183,10 +212,15 @@
break;
default:
int portNum = getPortNum(ethernet.getSourceMAC(), iPacket.getDestinationAddress());
+ Port port = getExternalPort(pkt.receivedFrom().deviceId(), EXTERNAL_INTERFACE_NAME);
+ if (port == null) {
+ log.warn("There`s no external interface");
+ break;
+ }
OpenstackPort openstackPort = getOpenstackPort(ethernet.getSourceMAC(),
Ip4Address.valueOf(iPacket.getSourceAddress()));
l3EventExecutorService.execute(new OpenstackPnatHandler(rulePopulator, context,
- portNum, openstackPort));
+ portNum, openstackPort, port));
break;
}
@@ -201,24 +235,30 @@
}
}
+ private Port getExternalPort(DeviceId deviceId, String interfaceName) {
+ return deviceService.getPorts(deviceId)
+ .stream()
+ .filter(p -> p.annotations().value(PORT_NAME).equals(interfaceName))
+ .findAny()
+ .orElse(null);
+ }
+
private void checkExternalConnection(OpenstackRouter router,
Collection<OpenstackRouterInterface> routerInterfaces) {
checkNotNull(router, "Router can not be null");
- checkNotNull(routerInterfaces, "RouterInterfaces can not be null");
+ checkNotNull(routerInterfaces, "routerInterfaces can not be null");
Ip4Address externalIp = router.gatewayExternalInfo().externalFixedIps()
.values().stream().findFirst().orElse(null);
if ((externalIp == null) || (!router.gatewayExternalInfo().isEnablePnat())) {
- log.debug("Failed to set pnat configuration");
+ log.debug("Not satisfied to set pnat configuration");
return;
}
- routerInterfaces.forEach(routerInterface -> {
- initiateL3Rule(router, routerInterface);
- });
+ routerInterfaces.forEach(routerInterface -> initiateL3Rule(router, routerInterface));
}
private void initiateL3Rule(OpenstackRouter router, OpenstackRouterInterface routerInterface) {
long vni = Long.parseLong(openstackService.network(openstackService
- .port(routerInterface.portId()).networkId()).segmentId());
+ .port(routerInterface.id()).networkId()).segmentId());
OpenstackRoutingRulePopulator rulePopulator = new OpenstackRoutingRulePopulator(appId,
openstackService, flowObjectiveService, deviceService, driverService);
rulePopulator.populateExternalRules(vni, router, routerInterface);
@@ -229,15 +269,15 @@
.collect(Collectors.toList());
}
- private OpenstackRouter getOpenstackRouter(String tenantId) {
+ private OpenstackRouter getOpenstackRouter(String id) {
return openstackService.routers().stream().filter(r ->
- r.tenantId().equals(tenantId)).findFirst().orElse(null);
+ r.id().equals(id)).findAny().orElse(null);
}
private OpenstackPort getOpenstackPort(MacAddress sourceMac, Ip4Address ip4Address) {
- OpenstackPort openstackPort = openstackService.ports("").stream()
+ OpenstackPort openstackPort = openstackService.ports().stream()
.filter(p -> p.macAddress().equals(sourceMac)).findFirst().orElse(null);
- return openstackPort.fixedIps().values().stream().findFirst().orElse(null)
+ return checkNotNull(openstackPort.fixedIps().values().stream().findFirst().orElse(null))
.equals(ip4Address) ? openstackPort : null;
}
diff --git a/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackRoutingRulePopulator.java b/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackRoutingRulePopulator.java
index dc10216..cc0fecd 100644
--- a/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackRoutingRulePopulator.java
+++ b/apps/openstacknetworking/openstackrouting/src/main/java/org/onosproject/openstacknetworking/routing/OpenstackRoutingRulePopulator.java
@@ -51,6 +51,7 @@
import org.onosproject.openstacknetworking.OpenstackPort;
import org.onosproject.openstacknetworking.OpenstackRouter;
import org.onosproject.openstacknetworking.OpenstackRouterInterface;
+import org.onosproject.openstacknetworking.OpenstackSubnet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -63,19 +64,22 @@
*/
public class OpenstackRoutingRulePopulator {
- private static Logger log = LoggerFactory
- .getLogger(OpenstackRoutingRulePopulator.class);
- private ApplicationId appId;
- private FlowObjectiveService flowObjectiveService;
- private OpenstackNetworkingService openstackService;
- private DeviceService deviceService;
- private DriverService driverService;
+ private final Logger log = LoggerFactory.getLogger(getClass());
- public static final String PORTNAME_PREFIX_VM = "tap";
- public static final String PORTNAME_PREFIX_ROUTER = "qr";
- public static final String PORTNAME_PREFIX_TUNNEL = "vxlan";
- public static final String PORTNAME = "portName";
+ private final ApplicationId appId;
+ private final FlowObjectiveService flowObjectiveService;
+ private final OpenstackNetworkingService openstackService;
+ private final DeviceService deviceService;
+ private final DriverService driverService;
+ private static final String PORTNAME_PREFIX_VM = "tap";
+ private static final String PORTNAME_PREFIX_ROUTER = "qr";
+ private static final String PORTNAME_PREFIX_TUNNEL = "vxlan";
+ private static final String PORTNAME = "portName";
+
+ private static final String PORTNOTNULL = "Port can not be null";
+ private static final String TUNNEL_DESTINATION = "tunnelDst";
+ private static final String DEVICE_ANNOTATION_CHANNELID = "channelId";
private static final int ROUTING_RULE_PRIORITY = 25000;
private static final int PNAT_RULE_PRIORITY = 24000;
private static final int PNAT_TIMEOUT = 120;
@@ -90,8 +94,17 @@
private OpenstackRouterInterface routerInterface;
// TODO: This will be replaced to get the information from openstackswitchingservice.
- private static final String EXTERNAL_INTERFACE_NAME = "eth3";
+ private static final String EXTERNAL_INTERFACE_NAME = "veth0";
+ /**
+ * The constructor of openstackRoutingRulePopulator.
+ *
+ * @param appId Caller`s appId
+ * @param openstackService OpenstackNetworkingService
+ * @param flowObjectiveService FlowObjectiveService
+ * @param deviceService DeviceService
+ * @param driverService DriverService
+ */
public OpenstackRoutingRulePopulator(ApplicationId appId, OpenstackNetworkingService openstackService,
FlowObjectiveService flowObjectiveService,
DeviceService deviceService, DriverService driverService) {
@@ -102,8 +115,18 @@
this.driverService = driverService;
}
+ /**
+ * Populates flow rules for Pnat configurations.
+ * @param inboundPacket Packet-in event packet
+ * @param openstackPort Target VM information
+ * @param portNum Pnat port number
+ * @param externalIp
+ * @param externalInterfaceMacAddress Gateway external interface macaddress
+ * @param externalRouterMacAddress Outer(physical) router`s macaddress
+ */
public void populatePnatFlowRules(InboundPacket inboundPacket, OpenstackPort openstackPort, int portNum,
- MacAddress externalInterfaceMacAddress, MacAddress externalRouterMacAddress) {
+ Ip4Address externalIp, MacAddress externalInterfaceMacAddress,
+ MacAddress externalRouterMacAddress) {
this.inboundPacket = inboundPacket;
this.openstackPort = openstackPort;
this.portNum = portNum;
@@ -112,11 +135,11 @@
long vni = getVni(openstackPort);
- populatePnatIncomingFlowRules(vni);
- populatePnatOutgoingFlowRules(vni);
+ populatePnatIncomingFlowRules(vni, externalIp);
+ populatePnatOutgoingFlowRules(vni, externalIp);
}
- private void populatePnatOutgoingFlowRules(long vni) {
+ private void populatePnatOutgoingFlowRules(long vni, Ip4Address externalIp) {
IPv4 iPacket = (IPv4) inboundPacket.parsed().getPayload();
TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder();
@@ -128,27 +151,27 @@
TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder();
tBuilder.setEthSrc(externalInterface)
- .setEthDst(externalRouter);
+ .setEthDst(externalRouter)
+ .setIpSrc(externalIp);
switch (iPacket.getProtocol()) {
case IPv4.PROTOCOL_TCP:
TCP tcpPacket = (TCP) iPacket.getPayload();
sBuilder.matchTcpSrc(TpPort.tpPort(tcpPacket.getSourcePort()))
.matchTcpDst(TpPort.tpPort(tcpPacket.getDestinationPort()));
- tBuilder.setTcpDst(TpPort.tpPort(portNum));
+ tBuilder.setTcpSrc(TpPort.tpPort(portNum));
break;
case IPv4.PROTOCOL_UDP:
UDP udpPacket = (UDP) iPacket.getPayload();
- sBuilder.matchUdpDst(TpPort.tpPort(udpPacket.getSourcePort()))
+ sBuilder.matchUdpSrc(TpPort.tpPort(udpPacket.getSourcePort()))
.matchUdpDst(TpPort.tpPort(udpPacket.getDestinationPort()));
- tBuilder.setUdpDst(TpPort.tpPort(portNum));
+ tBuilder.setUdpSrc(TpPort.tpPort(portNum));
break;
default:
break;
}
- Port port = getPortNumOfExternalInterface();
- checkNotNull(port, "Port can not be null");
+ Port port = checkNotNull(getPortNumOfExternalInterface(), PORTNOTNULL);
tBuilder.setOutput(port.number());
ForwardingObjective fo = DefaultForwardingObjective.builder()
@@ -165,18 +188,19 @@
private Port getPortNumOfExternalInterface() {
return deviceService.getPorts(inboundPacket.receivedFrom().deviceId()).stream()
- .filter(p -> p.annotations().value("portName").equals(EXTERNAL_INTERFACE_NAME))
+ .filter(p -> p.annotations().value(PORTNAME).equals(EXTERNAL_INTERFACE_NAME))
.findAny().orElse(null);
}
- private void populatePnatIncomingFlowRules(long vni) {
+ private void populatePnatIncomingFlowRules(long vni, Ip4Address externalIp) {
IPv4 iPacket = (IPv4) inboundPacket.parsed().getPayload();
DeviceId deviceId = inboundPacket.receivedFrom().deviceId();
TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder();
sBuilder.matchEthType(Ethernet.TYPE_IPV4)
.matchIPProtocol(iPacket.getProtocol())
+ .matchIPDst(IpPrefix.valueOf(externalIp, 32))
.matchIPSrc(IpPrefix.valueOf(iPacket.getDestinationAddress(), 32));
TrafficTreatment.Builder tBuilder = DefaultTrafficTreatment.builder();
@@ -225,7 +249,7 @@
ExtensionTreatmentType.ExtensionTreatmentTypes.NICIRA_SET_TUNNEL_DST.type());
try {
- extensionInstruction.setPropertyValue("tunnelDst", hostIp);
+ extensionInstruction.setPropertyValue(TUNNEL_DESTINATION, hostIp);
} catch (ExtensionPropertyException e) {
log.error("Error setting Nicira extension setting {}", e);
}
@@ -235,7 +259,7 @@
private PortNumber getTunnelPort(DeviceId deviceId) {
Port port = deviceService.getPorts(deviceId).stream()
- .filter(p -> p.annotations().value("portName").equals(PORTNAME_PREFIX_TUNNEL))
+ .filter(p -> p.annotations().value(PORTNAME).equals(PORTNAME_PREFIX_TUNNEL))
.findAny().orElse(null);
if (port == null) {
@@ -246,6 +270,13 @@
}
+ /**
+ * Populates flow rules from openstackComputeNode to GatewayNode.
+ *
+ * @param vni Target network
+ * @param router corresponding router
+ * @param routerInterface corresponding routerInterface
+ */
public void populateExternalRules(long vni, OpenstackRouter router,
OpenstackRouterInterface routerInterface) {
this.router = router;
@@ -284,11 +315,6 @@
StreamSupport.stream(deviceService.getAvailableDevices().spliterator(), false)
.filter(d -> !checkGatewayNode(d.id()))
.forEach(d -> populateRuleToGateway(d, gatewayDevice, vni));
- /*deviceService.getAvailableDevices().forEach(d -> {
- if (!checkGatewayNode(d.id())) {
- populateRuleToGateway(d, gatewayDevice, vni);
- }
- });*/
}
private void populateRuleToGateway(Device d, Device gatewayDevice, long vni) {
@@ -313,34 +339,40 @@
}
private Ip4Address getIPAddressforDevice(Device device) {
- return Ip4Address.valueOf(device.annotations().value("channelId").split(":")[0]);
+ return Ip4Address.valueOf(device.annotations().value(DEVICE_ANNOTATION_CHANNELID).split(":")[0]);
}
private Device getGatewayNode() {
- final Device[] device = new Device[1];
- deviceService.getAvailableDevices().forEach(d -> {
- if (checkGatewayNode(d.id())) {
- device[0] = d;
- }
- });
- return device[0];
+ return checkNotNull(StreamSupport.stream(deviceService.getAvailableDevices().spliterator(), false)
+ .filter(d -> checkGatewayNode(d.id()))
+ .findAny()
+ .orElse(null));
}
private boolean checkGatewayNode(DeviceId deviceId) {
return !deviceService.getPorts(deviceId).stream().anyMatch(port ->
- port.annotations().value("portName").startsWith(PORTNAME_PREFIX_ROUTER) ||
- port.annotations().value("portName").startsWith(PORTNAME_PREFIX_VM));
+ port.annotations().value(PORTNAME).startsWith(PORTNAME_PREFIX_ROUTER) ||
+ port.annotations().value(PORTNAME).startsWith(PORTNAME_PREFIX_VM));
}
private long getVni(OpenstackPort openstackPort) {
return Long.parseLong(openstackService.network(openstackPort.networkId()).segmentId());
}
+ private long getVni(OpenstackSubnet openstackSubnet) {
+ return Long.parseLong(openstackService.network(openstackSubnet.networkId()).segmentId());
+ }
+
+ /**
+ * Remove flow rules for external connection.
+ *
+ * @param routerInterface Corresponding routerInterface
+ */
public void removeExternalRules(OpenstackRouterInterface routerInterface) {
- OpenstackPort openstackPort = openstackService.port(routerInterface.portId());
+ OpenstackSubnet openstackSubnet = openstackService.subnet(routerInterface.subnetId());
TrafficSelector.Builder sBuilder = DefaultTrafficSelector.builder();
sBuilder.matchEthType(Ethernet.TYPE_IPV4)
- .matchTunnelId(getVni(openstackPort))
+ .matchTunnelId(getVni(openstackSubnet))
.matchEthDst(GATEWAYMAC);
StreamSupport.stream(deviceService.getAvailableDevices().spliterator(), false)