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)