diff --git a/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/impl/OpenstackFlowRuleManager.java b/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/impl/OpenstackFlowRuleManager.java
index 5608bce..e1f579e 100644
--- a/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/impl/OpenstackFlowRuleManager.java
+++ b/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/impl/OpenstackFlowRuleManager.java
@@ -24,6 +24,7 @@
 import org.onosproject.core.CoreService;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.Port;
+import org.onosproject.net.PortNumber;
 import org.onosproject.net.device.DeviceService;
 import org.onosproject.net.flow.DefaultFlowRule;
 import org.onosproject.net.flow.DefaultTrafficSelector;
@@ -59,6 +60,8 @@
 import static org.onosproject.openstacknetworking.api.Constants.OPENSTACK_NETWORKING_APP_ID;
 import static org.onosproject.openstacknetworking.api.Constants.PRIORITY_FLAT_JUMP_UPSTREAM_RULE;
 import static org.onosproject.openstacknetworking.api.Constants.STAT_FLAT_OUTBOUND_TABLE;
+import static org.onosproject.openstacknetworking.util.OpenstackNetworkingUtil.structurePortName;
+import static org.onosproject.openstacknode.api.Constants.INTEGRATION_TO_PHYSICAL_PREFIX;
 import static org.onosproject.openstacknode.api.OpenstackNode.NodeType.COMPUTE;
 import static org.slf4j.LoggerFactory.getLogger;
 
@@ -255,50 +258,44 @@
         osNodeService.node(deviceId)
                      .phyIntfs()
                      .forEach(phyInterface ->
-                             setFlatJumpRulesForPhyIntf(deviceId, phyInterface));
+                             setFlatJumpRulesForPatchPort(deviceId, phyInterface));
     }
 
-    private void setFlatJumpRulesForPhyIntf(DeviceId deviceId,
-                                            OpenstackPhyInterface phyInterface) {
-        Optional<Port> phyPort = deviceService.getPorts(deviceId).stream()
-                .filter(port ->
-                        Objects.equals(port.annotations().value(PORT_NAME), phyInterface.intf()))
+    private void setFlatJumpRuleForPatchPort(DeviceId deviceId,
+                                           PortNumber portNumber, short ethType) {
+        TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
+        selector.matchInPort(portNumber)
+                .matchEthType(ethType);
+
+        TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
+        treatment.transition(STAT_FLAT_OUTBOUND_TABLE);
+        FlowRule flowRuleForIp = DefaultFlowRule.builder()
+                .forDevice(deviceId)
+                .withSelector(selector.build())
+                .withTreatment(treatment.build())
+                .withPriority(PRIORITY_FLAT_JUMP_UPSTREAM_RULE)
+                .fromApp(appId)
+                .makePermanent()
+                .forTable(DHCP_TABLE)
+                .build();
+
+        applyRule(flowRuleForIp, true);
+    }
+
+    private void setFlatJumpRulesForPatchPort(DeviceId deviceId,
+                                              OpenstackPhyInterface phyIntf) {
+        Optional<Port> patchPort = deviceService.getPorts(deviceId).stream()
+                .filter(port -> {
+                    String annotPortName = port.annotations().value(PORT_NAME);
+                    String portName = structurePortName(
+                            INTEGRATION_TO_PHYSICAL_PREFIX + phyIntf.network());
+                    return Objects.equals(annotPortName, portName);
+                })
                 .findAny();
 
-        phyPort.ifPresent(port -> {
-            TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
-            selector.matchInPort(port.number())
-                    .matchEthType(Ethernet.TYPE_IPV4);
-
-            TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
-            treatment.transition(STAT_FLAT_OUTBOUND_TABLE);
-            FlowRule flowRuleForIp = DefaultFlowRule.builder()
-                    .forDevice(deviceId)
-                    .withSelector(selector.build())
-                    .withTreatment(treatment.build())
-                    .withPriority(PRIORITY_FLAT_JUMP_UPSTREAM_RULE)
-                    .fromApp(appId)
-                    .makePermanent()
-                    .forTable(DHCP_TABLE)
-                    .build();
-
-            applyRule(flowRuleForIp, true);
-
-            selector = DefaultTrafficSelector.builder();
-            selector.matchInPort(port.number())
-                    .matchEthType(Ethernet.TYPE_ARP);
-
-            FlowRule flowRuleForArp = DefaultFlowRule.builder()
-                    .forDevice(deviceId)
-                    .withSelector(selector.build())
-                    .withTreatment(treatment.build())
-                    .withPriority(PRIORITY_FLAT_JUMP_UPSTREAM_RULE)
-                    .fromApp(appId)
-                    .makePermanent()
-                    .forTable(DHCP_TABLE)
-                    .build();
-
-            applyRule(flowRuleForArp, true);
+        patchPort.ifPresent(port -> {
+            setFlatJumpRuleForPatchPort(deviceId, port.number(), Ethernet.TYPE_IPV4);
+            setFlatJumpRuleForPatchPort(deviceId, port.number(), Ethernet.TYPE_ARP);
         });
     }
 
diff --git a/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/impl/OpenstackSwitchingPhysicalHandler.java b/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/impl/OpenstackSwitchingPhysicalHandler.java
new file mode 100644
index 0000000..6a9686b
--- /dev/null
+++ b/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/impl/OpenstackSwitchingPhysicalHandler.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2019-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.openstacknetworking.impl;
+
+import org.onlab.packet.Ethernet;
+import org.onosproject.cluster.ClusterService;
+import org.onosproject.cluster.LeadershipService;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.mastership.MastershipService;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Port;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.device.DeviceEvent;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.driver.DriverService;
+import org.onosproject.net.flow.DefaultTrafficSelector;
+import org.onosproject.net.flow.DefaultTrafficTreatment;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.openstacknetworking.api.OpenstackFlowRuleService;
+import org.onosproject.openstacknode.api.OpenstackNode;
+import org.onosproject.openstacknode.api.OpenstackNodeService;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ReferenceCardinality;
+import org.slf4j.Logger;
+
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.stream.Collectors;
+
+import static java.util.concurrent.Executors.newSingleThreadExecutor;
+import static org.onlab.util.Tools.groupedThreads;
+import static org.onosproject.net.AnnotationKeys.PORT_NAME;
+import static org.onosproject.openstacknetworking.api.Constants.DHCP_TABLE;
+import static org.onosproject.openstacknetworking.api.Constants.OPENSTACK_NETWORKING_APP_ID;
+import static org.onosproject.openstacknetworking.api.Constants.PRIORITY_FLAT_JUMP_UPSTREAM_RULE;
+import static org.onosproject.openstacknetworking.api.Constants.STAT_FLAT_OUTBOUND_TABLE;
+import static org.onosproject.openstacknetworking.util.OpenstackNetworkingUtil.structurePortName;
+import static org.onosproject.openstacknode.api.Constants.INTEGRATION_TO_PHYSICAL_PREFIX;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Populates switching flow rules on OVS for the physical interfaces.
+ */
+@Component(immediate = true)
+public class OpenstackSwitchingPhysicalHandler {
+
+    private final Logger log = getLogger(getClass());
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY)
+    protected CoreService coreService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY)
+    protected MastershipService mastershipService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY)
+    protected DeviceService deviceService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY)
+    protected DriverService driverService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY)
+    protected ClusterService clusterService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY)
+    protected LeadershipService leadershipService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY)
+    protected OpenstackFlowRuleService osFlowRuleService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY)
+    protected OpenstackNodeService osNodeService;
+
+    private final ExecutorService eventExecutor = newSingleThreadExecutor(
+            groupedThreads(this.getClass().getSimpleName(), "event-handler"));
+    private final InternalDeviceListener internalDeviceListener = new InternalDeviceListener();
+
+    private ApplicationId appId;
+
+    @Activate
+    protected void activate() {
+        appId = coreService.registerApplication(OPENSTACK_NETWORKING_APP_ID);
+        deviceService.addListener(internalDeviceListener);
+
+        log.info("Started");
+    }
+
+    @Deactivate
+    protected void deactivate() {
+        eventExecutor.shutdown();
+        deviceService.removeListener(internalDeviceListener);
+
+        log.info("Stopped");
+    }
+
+    /**
+     * An internal device listener which listens the port events generated from
+     * OVS integration bridge.
+     */
+    private class InternalDeviceListener implements DeviceListener {
+
+        @Override
+        public boolean isRelevant(DeviceEvent event) {
+            Port port = event.port();
+            if (port == null) {
+                return false;
+            }
+
+            OpenstackNode osNode = osNodeService.node(event.subject().id());
+            if (osNode == null) {
+                return false;
+            }
+
+            Set<String> intPatchPorts = osNode.phyIntfs().stream()
+                    .map(pi -> structurePortName(INTEGRATION_TO_PHYSICAL_PREFIX
+                            + pi.network())).collect(Collectors.toSet());
+            String portName = port.annotations().value(PORT_NAME);
+
+            return intPatchPorts.contains(portName);
+        }
+
+        private boolean isRelevantHelper(DeviceEvent event) {
+            return mastershipService.isLocalMaster(event.subject().id());
+        }
+
+        @Override
+        public void event(DeviceEvent event) {
+            log.info("Device event occurred with type {}", event.type());
+
+            switch (event.type()) {
+                case PORT_ADDED:
+                case PORT_UPDATED:
+                    eventExecutor.execute(() -> processPortAddition(event));
+                    break;
+                case PORT_REMOVED:
+                    eventExecutor.execute(() -> processPortRemoval(event));
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        private void processPortAddition(DeviceEvent event) {
+            if (!isRelevantHelper(event)) {
+                return;
+            }
+
+            setFlatJumpRulesForPatchPort(event.subject().id(),
+                    event.port().number(), true);
+        }
+
+        private void processPortRemoval(DeviceEvent event) {
+            if (!isRelevantHelper(event)) {
+                return;
+            }
+
+            setFlatJumpRulesForPatchPort(event.subject().id(),
+                    event.port().number(), false);
+        }
+
+        private void setFlatJumpRulesForPatchPort(DeviceId deviceId,
+                                                  PortNumber portNumber,
+                                                  boolean install) {
+            setFlatJumpRuleForPatchPort(deviceId, portNumber,
+                    Ethernet.TYPE_IPV4, install);
+            setFlatJumpRuleForPatchPort(deviceId, portNumber,
+                    Ethernet.TYPE_ARP, install);
+        }
+
+        private void setFlatJumpRuleForPatchPort(DeviceId deviceId,
+                                                 PortNumber portNumber,
+                                                 short ethType, boolean install) {
+            TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
+            selector.matchInPort(portNumber)
+                    .matchEthType(ethType);
+
+            TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder();
+            treatment.transition(STAT_FLAT_OUTBOUND_TABLE);
+
+            osFlowRuleService.setRule(
+                    appId,
+                    deviceId,
+                    selector.build(),
+                    treatment.build(),
+                    PRIORITY_FLAT_JUMP_UPSTREAM_RULE,
+                    DHCP_TABLE,
+                    install);
+        }
+    }
+}
\ No newline at end of file
diff --git a/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/util/OpenstackNetworkingUtil.java b/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/util/OpenstackNetworkingUtil.java
index 5402ca5..40d07f5 100644
--- a/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/util/OpenstackNetworkingUtil.java
+++ b/apps/openstacknetworking/app/src/main/java/org/onosproject/openstacknetworking/util/OpenstackNetworkingUtil.java
@@ -187,6 +187,7 @@
     private static final int SSH_PORT = 22;
 
     private static final int TAP_PORT_LENGTH = 11;
+    private static final int PORT_NAME_MAX_LENGTH = 15;
 
     /**
      * Prevents object instantiation from external.
@@ -1303,6 +1304,23 @@
     }
 
     /**
+     * Re-structures the OVS port name.
+     * The length of OVS port name should be not large than 15.
+     *
+     * @param portName  original port name
+     * @return re-structured OVS port name
+     */
+    public static String structurePortName(String portName) {
+
+        // The size of OVS port name should not be larger than 15
+        if (portName.length() > PORT_NAME_MAX_LENGTH) {
+            return StringUtils.substring(portName, 0, PORT_NAME_MAX_LENGTH);
+        }
+
+        return portName;
+    }
+
+    /**
      * Builds up and a complete endpoint URL from gateway node.
      *
      * @param node gateway node
diff --git a/apps/openstacknode/api/src/main/java/org/onosproject/openstacknode/api/Constants.java b/apps/openstacknode/api/src/main/java/org/onosproject/openstacknode/api/Constants.java
index 8decf3a..64a29b8 100644
--- a/apps/openstacknode/api/src/main/java/org/onosproject/openstacknode/api/Constants.java
+++ b/apps/openstacknode/api/src/main/java/org/onosproject/openstacknode/api/Constants.java
@@ -40,6 +40,10 @@
     public static final String VLAN_INTF_NAME = "vlanPort";
     public static final String UPLINK_PORT = "uplinkPort";
 
+    public static final String BRIDGE_PREFIX = "br-";
+    public static final String INTEGRATION_TO_PHYSICAL_PREFIX = "int-to-";
+    public static final String PHYSICAL_TO_INTEGRATION_SUFFIX = "-to-int";
+
     public static final String FLAT = "flat";
     public static final String VLAN = "vlan";
     public static final String VXLAN = "vxlan";
diff --git a/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/cli/OpenstackNodeCheckCommand.java b/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/cli/OpenstackNodeCheckCommand.java
index 057f29e..e301c95 100644
--- a/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/cli/OpenstackNodeCheckCommand.java
+++ b/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/cli/OpenstackNodeCheckCommand.java
@@ -32,11 +32,13 @@
 
 import static org.onosproject.net.AnnotationKeys.PORT_NAME;
 import static org.onosproject.openstacknode.api.Constants.GRE_TUNNEL;
-import static org.onosproject.openstacknode.api.Constants.VXLAN_TUNNEL;
 import static org.onosproject.openstacknode.api.Constants.INTEGRATION_BRIDGE;
+import static org.onosproject.openstacknode.api.Constants.INTEGRATION_TO_PHYSICAL_PREFIX;
+import static org.onosproject.openstacknode.api.Constants.VXLAN_TUNNEL;
 import static org.onosproject.openstacknode.api.OpenstackNode.NodeType.CONTROLLER;
 import static org.onosproject.openstacknode.api.OpenstackNode.NodeType.GATEWAY;
 import static org.onosproject.openstacknode.util.OpenstackNodeUtil.getConnectedClient;
+import static org.onosproject.openstacknode.util.OpenstackNodeUtil.structurePortName;
 
 /**
  * Checks detailed node init state.
@@ -106,7 +108,8 @@
                     printPortState(deviceService, osNode.intgBridge(), osNode.vlanIntf());
                 }
                 osNode.phyIntfs().forEach(intf -> {
-                    printPortState(deviceService, osNode.intgBridge(), intf.intf());
+                    printPortState(deviceService, osNode.intgBridge(),
+                            structurePortName(INTEGRATION_TO_PHYSICAL_PREFIX + intf.network()));
                 });
                 if (osNode.type() == GATEWAY) {
                     printPortState(deviceService, osNode.intgBridge(), osNode.uplinkPort());
diff --git a/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/impl/DefaultOpenstackNodeHandler.java b/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/impl/DefaultOpenstackNodeHandler.java
index 01f8e4f..bdd1de2 100644
--- a/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/impl/DefaultOpenstackNodeHandler.java
+++ b/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/impl/DefaultOpenstackNodeHandler.java
@@ -30,10 +30,13 @@
 import org.onosproject.net.Port;
 import org.onosproject.net.behaviour.BridgeConfig;
 import org.onosproject.net.behaviour.BridgeDescription;
+import org.onosproject.net.behaviour.BridgeName;
 import org.onosproject.net.behaviour.ControllerInfo;
 import org.onosproject.net.behaviour.DefaultBridgeDescription;
+import org.onosproject.net.behaviour.DefaultPatchDescription;
 import org.onosproject.net.behaviour.DefaultTunnelDescription;
 import org.onosproject.net.behaviour.InterfaceConfig;
+import org.onosproject.net.behaviour.PatchDescription;
 import org.onosproject.net.behaviour.TunnelDescription;
 import org.onosproject.net.behaviour.TunnelEndPoints;
 import org.onosproject.net.behaviour.TunnelKeys;
@@ -79,11 +82,14 @@
 import static org.onlab.packet.TpPort.tpPort;
 import static org.onlab.util.Tools.groupedThreads;
 import static org.onosproject.net.AnnotationKeys.PORT_NAME;
+import static org.onosproject.openstacknode.api.Constants.BRIDGE_PREFIX;
 import static org.onosproject.openstacknode.api.Constants.GENEVE;
 import static org.onosproject.openstacknode.api.Constants.GENEVE_TUNNEL;
 import static org.onosproject.openstacknode.api.Constants.GRE;
 import static org.onosproject.openstacknode.api.Constants.GRE_TUNNEL;
 import static org.onosproject.openstacknode.api.Constants.INTEGRATION_BRIDGE;
+import static org.onosproject.openstacknode.api.Constants.INTEGRATION_TO_PHYSICAL_PREFIX;
+import static org.onosproject.openstacknode.api.Constants.PHYSICAL_TO_INTEGRATION_SUFFIX;
 import static org.onosproject.openstacknode.api.Constants.TUNNEL_BRIDGE;
 import static org.onosproject.openstacknode.api.Constants.VXLAN;
 import static org.onosproject.openstacknode.api.Constants.VXLAN_TUNNEL;
@@ -105,6 +111,7 @@
 import static org.onosproject.openstacknode.util.OpenstackNodeUtil.getConnectedClient;
 import static org.onosproject.openstacknode.util.OpenstackNodeUtil.getOvsdbClient;
 import static org.onosproject.openstacknode.util.OpenstackNodeUtil.isOvsdbConnected;
+import static org.onosproject.openstacknode.util.OpenstackNodeUtil.structurePortName;
 import static org.slf4j.LoggerFactory.getLogger;
 
 /**
@@ -124,6 +131,7 @@
     private static final String NO_OVSDB_CLIENT_MSG = "Failed to get ovsdb client";
     private static final int DEFAULT_OFPORT = 6653;
     private static final int DPID_BEGIN = 3;
+    private static final int NETWORK_BEGIN = 3;
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY)
     protected CoreService coreService;
@@ -207,9 +215,11 @@
             ovsdbController.connect(osNode.managementIp(), tpPort(ovsdbPortNum));
             return;
         }
+
         if (!deviceService.isAvailable(osNode.intgBridge())) {
             createBridge(osNode, INTEGRATION_BRIDGE, osNode.intgBridge());
         }
+
         if (hasDpdkTunnelBridge(osNode)) {
             createDpdkTunnelBridge(osNode);
         }
@@ -255,12 +265,11 @@
                                 osNode, dpdkintf, ovsdbPortNum, ovsdbController, true));
             }
 
-            osNode.phyIntfs().forEach(i -> {
-                if (!isIntfEnabled(osNode, i.intf())) {
-                    addOrRemoveSystemInterface(osNode, INTEGRATION_BRIDGE,
-                            i.intf(), deviceService, true);
-                }
-            });
+            // provision new physical interfaces on the given node
+            // this includes creating physical bridge, attaching physical port
+            // to physical bridge, adding patch ports to both physical bridge and br-int
+
+            provisionPhysicalInterfaces(osNode);
 
             if (osNode.vlanIntf() != null &&
                     !isIntfEnabled(osNode, osNode.vlanIntf())) {
@@ -354,6 +363,149 @@
         bridgeConfig.addBridge(builder.build());
     }
 
+    private void provisionPhysicalInterfaces(OpenstackNode osNode) {
+        osNode.phyIntfs().forEach(pi -> {
+            String bridgeName = BRIDGE_PREFIX + pi.network();
+            String patchPortName =
+                    structurePortName(INTEGRATION_TO_PHYSICAL_PREFIX + pi.network());
+
+            if (!hasPhyBridge(osNode, bridgeName)) {
+                createPhysicalBridge(osNode, pi);
+                createPhysicalPatchPorts(osNode, pi);
+                attachPhysicalPort(osNode, pi);
+            } else {
+                // in case physical bridge exists, but patch port is missing on br-int,
+                // we will add patch port to connect br-int with physical bridge
+                if (!hasPhyPatchPort(osNode, patchPortName)) {
+                    createPhysicalPatchPorts(osNode, pi);
+                }
+            }
+        });
+    }
+
+    private void cleanPhysicalInterfaces(OpenstackNode osNode) {
+        Device device = deviceService.getDevice(osNode.ovsdb());
+
+        BridgeConfig bridgeConfig = device.as(BridgeConfig.class);
+
+        Set<String> bridgeNames = bridgeConfig.getBridges().stream()
+                .map(BridgeDescription::name).collect(Collectors.toSet());
+
+        Set<String> phyNetworkNames = osNode.phyIntfs().stream()
+                .map(pi -> BRIDGE_PREFIX + pi.network()).collect(Collectors.toSet());
+
+        // we remove existing physical bridges and patch ports, if the physical
+        // bridges are not defined in openstack node
+        bridgeNames.forEach(brName -> {
+            if (!phyNetworkNames.contains(brName) && !brName.equals(INTEGRATION_BRIDGE)) {
+                removePhysicalPatchPorts(osNode, brName.substring(NETWORK_BEGIN));
+                removePhysicalBridge(osNode, brName.substring(NETWORK_BEGIN));
+            }
+        });
+    }
+
+    private void unprovisionPhysicalInterfaces(OpenstackNode osNode) {
+        osNode.phyIntfs().forEach(pi -> {
+            detachPhysicalPort(osNode, pi.network(), pi.intf());
+            removePhysicalPatchPorts(osNode, pi.network());
+            removePhysicalBridge(osNode, pi.network());
+        });
+    }
+
+    private void createPhysicalBridge(OpenstackNode osNode,
+                                      OpenstackPhyInterface phyInterface) {
+        Device device = deviceService.getDevice(osNode.ovsdb());
+
+        String bridgeName = BRIDGE_PREFIX + phyInterface.network();
+
+        BridgeDescription.Builder builder = DefaultBridgeDescription.builder()
+                .name(bridgeName);
+
+        BridgeConfig bridgeConfig = device.as(BridgeConfig.class);
+        bridgeConfig.addBridge(builder.build());
+    }
+
+    private void removePhysicalBridge(OpenstackNode osNode, String network) {
+        Device device = deviceService.getDevice(osNode.ovsdb());
+
+        BridgeName bridgeName = BridgeName.bridgeName(BRIDGE_PREFIX + network);
+
+        BridgeConfig bridgeConfig = device.as(BridgeConfig.class);
+        bridgeConfig.deleteBridge(bridgeName);
+    }
+
+    private void createPhysicalPatchPorts(OpenstackNode osNode,
+                                          OpenstackPhyInterface phyInterface) {
+        Device device = deviceService.getDevice(osNode.ovsdb());
+
+        if (device == null || !device.is(InterfaceConfig.class)) {
+            log.error("Failed to create patch interface on {}", osNode.ovsdb());
+            return;
+        }
+
+        String physicalDeviceId = BRIDGE_PREFIX + phyInterface.network();
+
+        String intToPhyPatchPort = structurePortName(
+                INTEGRATION_TO_PHYSICAL_PREFIX + phyInterface.network());
+        String phyToIntPatchPort = structurePortName(
+                phyInterface.network() + PHYSICAL_TO_INTEGRATION_SUFFIX);
+
+        // integration bridge -> physical bridge
+        PatchDescription intToPhyPatchDesc =
+                DefaultPatchDescription.builder()
+                        .deviceId(INTEGRATION_BRIDGE)
+                        .ifaceName(intToPhyPatchPort)
+                        .peer(phyToIntPatchPort)
+                        .build();
+
+        // physical bridge -> integration bridge
+        PatchDescription phyToIntPatchDesc =
+                DefaultPatchDescription.builder()
+                        .deviceId(physicalDeviceId)
+                        .ifaceName(phyToIntPatchPort)
+                        .peer(intToPhyPatchPort)
+                        .build();
+
+        InterfaceConfig ifaceConfig = device.as(InterfaceConfig.class);
+        ifaceConfig.addPatchMode(INTEGRATION_TO_PHYSICAL_PREFIX +
+                phyInterface.network(), intToPhyPatchDesc);
+        ifaceConfig.addPatchMode(phyInterface.network() +
+                PHYSICAL_TO_INTEGRATION_SUFFIX, phyToIntPatchDesc);
+
+        addOrRemoveSystemInterface(osNode, physicalDeviceId,
+                phyInterface.intf(), deviceService, true);
+    }
+
+    private void removePhysicalPatchPorts(OpenstackNode osNode, String network) {
+        Device device = deviceService.getDevice(osNode.ovsdb());
+
+        if (device == null || !device.is(InterfaceConfig.class)) {
+            log.error("Failed to remove patch interface on {}", osNode.ovsdb());
+            return;
+        }
+
+        String intToPhyPatchPort = structurePortName(
+                INTEGRATION_TO_PHYSICAL_PREFIX + network);
+
+        InterfaceConfig ifaceConfig = device.as(InterfaceConfig.class);
+        ifaceConfig.removePatchMode(intToPhyPatchPort);
+    }
+
+    private void attachPhysicalPort(OpenstackNode osNode,
+                                    OpenstackPhyInterface phyInterface) {
+
+        String physicalDeviceId = BRIDGE_PREFIX + phyInterface.network();
+
+        addOrRemoveSystemInterface(osNode, physicalDeviceId,
+                phyInterface.intf(), deviceService, true);
+    }
+
+    private void detachPhysicalPort(OpenstackNode osNode, String network, String portName) {
+        String physicalDeviceId = BRIDGE_PREFIX + network;
+
+        addOrRemoveSystemInterface(osNode, physicalDeviceId, portName, deviceService, false);
+    }
+
     /**
      * Creates a VXLAN tunnel interface in a given openstack node.
      *
@@ -454,6 +606,20 @@
                                 port.isEnabled());
     }
 
+    private boolean hasPhyBridge(OpenstackNode osNode, String bridgeName) {
+        BridgeConfig bridgeConfig = deviceService.getDevice(osNode.ovsdb()).as(BridgeConfig.class);
+        return bridgeConfig.getBridges().stream().anyMatch(br -> br.name().equals(bridgeName));
+    }
+
+    private boolean hasPhyPatchPort(OpenstackNode osNode, String patchPortName) {
+        List<Port> ports = deviceService.getPorts(osNode.intgBridge());
+        return ports.stream().anyMatch(p -> p.annotations().value(PORT_NAME).equals(patchPortName));
+    }
+
+    private boolean hasPhyIntf(OpenstackNode osNode, String intfName) {
+        BridgeConfig bridgeConfig = deviceService.getDevice(osNode.ovsdb()).as(BridgeConfig.class);
+        return bridgeConfig.getPorts().stream().anyMatch(p -> p.annotations().value(PORT_NAME).equals(intfName));
+    }
 
     private boolean initStateDone(OpenstackNode osNode) {
         if (!isOvsdbConnected(osNode, ovsdbPortNum, ovsdbController, deviceService)) {
@@ -465,6 +631,8 @@
             initStateDone = initStateDone && dpdkTunnelBridgeCreated(osNode);
         }
 
+        cleanPhysicalInterfaces(osNode);
+
         return initStateDone;
     }
 
@@ -495,8 +663,18 @@
             return false;
         }
 
-        for (OpenstackPhyInterface intf : osNode.phyIntfs()) {
-            if (intf != null && !isIntfEnabled(osNode, intf.intf())) {
+        for (OpenstackPhyInterface phyIntf : osNode.phyIntfs()) {
+            if (phyIntf == null) {
+                return false;
+            }
+
+            String bridgeName = BRIDGE_PREFIX + phyIntf.network();
+            String patchPortName = structurePortName(
+                    INTEGRATION_TO_PHYSICAL_PREFIX + phyIntf.network());
+
+            if (!(hasPhyBridge(osNode, bridgeName) &&
+                    hasPhyPatchPort(osNode, patchPortName) &&
+                    hasPhyIntf(osNode, phyIntf.intf()))) {
                 return false;
             }
         }
@@ -504,7 +682,6 @@
         return true;
     }
 
-
     /**
      * Checks whether all requirements for this state are fulfilled or not.
      *
@@ -615,14 +792,6 @@
         }
     }
 
-    private void removePhysicalInterface(OpenstackNode osNode) {
-        osNode.phyIntfs().forEach(phyIntf -> {
-            Optional<DpdkInterface> dpdkIntf = dpdkInterfaceByIntfName(osNode, phyIntf.intf());
-
-            removeInterfaceOnIntegrationBridge(osNode, phyIntf.intf(), dpdkIntf);
-        });
-    }
-
     private Optional<DpdkInterface> dpdkInterfaceByIntfName(OpenstackNode osNode,
                                                             String intf) {
         return osNode.dpdkConfig() == null ? Optional.empty() :
@@ -836,7 +1005,7 @@
                             Objects.equals(portName, GENEVE_TUNNEL) ||
                             Objects.equals(portName, osNode.vlanIntf()) ||
                             Objects.equals(portName, osNode.uplinkPort()) ||
-                            containsPhyIntf(osNode, portName)) ||
+                            containsPatchPort(osNode, portName)) ||
                     containsDpdkIntfs(osNode, portName)) {
                 log.info("Interface {} added or updated to {}",
                         portName, osNode.intgBridge());
@@ -856,7 +1025,7 @@
                             Objects.equals(portName, GENEVE_TUNNEL) ||
                             Objects.equals(portName, osNode.vlanIntf()) ||
                             Objects.equals(portName, osNode.uplinkPort()) ||
-                            containsPhyIntf(osNode, portName)) ||
+                            containsPatchPort(osNode, portName)) ||
                     containsDpdkIntfs(osNode, portName)) {
                 log.warn("Interface {} removed from {}",
                         portName, osNode.intgBridge());
@@ -864,18 +1033,18 @@
             }
         }
 
-
         /**
-         * Checks whether the openstack node contains the given physical interface.
+         * Checks whether the openstack node contains the given patch port.
          *
-         * @param osNode openstack node
-         * @param portName physical interface
-         * @return true if openstack node contains the given physical interface,
-         *          false otherwise
+         * @param osNode    openstack node
+         * @param portName  patch port name
+         * @return true if openstack node contains the given patch port,
+         *         false otherwise
          */
-        private boolean containsPhyIntf(OpenstackNode osNode, String portName) {
+        private boolean containsPatchPort(OpenstackNode osNode, String portName) {
             return osNode.phyIntfs().stream()
-                    .anyMatch(phyInterface -> phyInterface.intf().equals(portName));
+                    .anyMatch(pi -> structurePortName(INTEGRATION_TO_PHYSICAL_PREFIX
+                            + pi.network()).equals(portName));
         }
 
         /**
@@ -895,7 +1064,6 @@
         }
     }
 
-
     /**
      * An internal openstack node listener.
      * The notification is triggered by OpenstackNodeStore.
@@ -942,8 +1110,10 @@
                 return;
             }
 
-            //delete physical interfaces from the node
-            removePhysicalInterface(osNode);
+            // unprovision physical interfaces from the node
+            // this procedure includes detaching physical port from physical bridge,
+            // remove patch ports from br-int, removing physical bridge
+            unprovisionPhysicalInterfaces(osNode);
 
             //delete vlan interface from the node
             removeVlanInterface(osNode);
diff --git a/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/util/OpenstackNodeUtil.java b/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/util/OpenstackNodeUtil.java
index d478bcc..9e5bc0a 100644
--- a/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/util/OpenstackNodeUtil.java
+++ b/apps/openstacknode/app/src/main/java/org/onosproject/openstacknode/util/OpenstackNodeUtil.java
@@ -18,6 +18,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableMap;
+import org.apache.commons.lang3.StringUtils;
 import org.onosproject.net.Device;
 import org.onosproject.net.behaviour.BridgeConfig;
 import org.onosproject.net.behaviour.BridgeName;
@@ -75,6 +76,8 @@
     private static final String DPDK_DEVARGS = "dpdk-devargs";
     private static final String NOT_AVAILABLE = "N/A";
 
+    private static final int PORT_NAME_MAX_LENGTH = 15;
+
     /**
      * Prevents object installation from external.
      */
@@ -297,6 +300,23 @@
     }
 
     /**
+     * Re-structures the OVS port name.
+     * The length of OVS port name should be not large than 15.
+     *
+     * @param portName  original port name
+     * @return re-structured OVS port name
+     */
+    public static String structurePortName(String portName) {
+
+        // The size of OVS port name should not be larger than 15
+        if (portName.length() > PORT_NAME_MAX_LENGTH) {
+            return StringUtils.substring(portName, 0, PORT_NAME_MAX_LENGTH);
+        }
+
+        return portName;
+    }
+
+    /**
      * Obtains the gateway node by openstack node. Note that the gateway
      * node is determined by device's device identifier.
      *