diff --git a/apps/openstacknode/src/main/java/org/onosproject/openstacknode/OpenstackNodeManager.java b/apps/openstacknode/src/main/java/org/onosproject/openstacknode/OpenstackNodeManager.java
index 165e665..c011fc3 100644
--- a/apps/openstacknode/src/main/java/org/onosproject/openstacknode/OpenstackNodeManager.java
+++ b/apps/openstacknode/src/main/java/org/onosproject/openstacknode/OpenstackNodeManager.java
@@ -35,8 +35,10 @@
 import org.onosproject.net.DeviceId;
 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.DefaultTunnelDescription;
 import org.onosproject.net.behaviour.TunnelConfig;
 import org.onosproject.net.behaviour.TunnelDescription;
@@ -399,7 +401,16 @@
         try {
             DriverHandler handler = driverService.createHandler(node.ovsdbId());
             BridgeConfig bridgeConfig =  handler.behaviour(BridgeConfig.class);
-            bridgeConfig.addBridge(BridgeName.bridgeName(DEFAULT_BRIDGE), dpid, controllers);
+
+            BridgeDescription bridgeDesc = DefaultBridgeDescription.builder()
+                    .name(DEFAULT_BRIDGE)
+                    .failMode(BridgeDescription.FailMode.SECURE)
+                    .datapathId(dpid)
+                    .disableInBand()
+                    .controllers(controllers)
+                    .build();
+
+            bridgeConfig.addBridge(bridgeDesc);
         } catch (ItemNotFoundException e) {
             log.warn("Failed to create integration bridge on {}", node.ovsdbId());
         }
diff --git a/apps/vtn/vtnmgr/src/main/java/org/onosproject/vtn/manager/impl/VtnManager.java b/apps/vtn/vtnmgr/src/main/java/org/onosproject/vtn/manager/impl/VtnManager.java
index 8f46dbe..2b794dc 100644
--- a/apps/vtn/vtnmgr/src/main/java/org/onosproject/vtn/manager/impl/VtnManager.java
+++ b/apps/vtn/vtnmgr/src/main/java/org/onosproject/vtn/manager/impl/VtnManager.java
@@ -715,24 +715,17 @@
                 .filter(d -> !("ovsdb:" + ipAddress).equals(d.id().toString()))
                 .forEach(d -> {
                     DriverHandler handler = driverService.createHandler(d.id());
-                    BridgeConfig bridgeConfig = handler
-                            .behaviour(BridgeConfig.class);
-                    Collection<BridgeDescription> bridgeDescriptions = bridgeConfig
-                            .getBridges();
-                    Iterator<BridgeDescription> it = bridgeDescriptions
-                            .iterator();
-                    while (it.hasNext()) {
-                        BridgeDescription sw = it.next();
-                        if (sw.bridgeName().name().equals(VtnConfig.DEFAULT_BRIDGE_NAME)) {
-                            List<Port> ports = deviceService.getPorts(sw.deviceId());
-                            ports.stream()
-                                    .filter(p -> p.annotations().value(AnnotationKeys.PORT_NAME)
-                                            .equalsIgnoreCase(tunnelName))
-                                    .forEach(p -> {
-                                l2ForwardService.programTunnelOut(sw.deviceId(),
-                                                                  segmentationId, p.number(),
-                                                                  dstMac, type, ipAddress);
-                            });
+                    BridgeConfig bridgeConfig = handler.behaviour(BridgeConfig.class);
+                    Collection<BridgeDescription> bridgeDescriptions = bridgeConfig.getBridges();
+                    for (BridgeDescription sw : bridgeDescriptions) {
+                        if (sw.name().equals(VtnConfig.DEFAULT_BRIDGE_NAME) &&
+                                sw.deviceId().isPresent()) {
+                            List<Port> ports = deviceService.getPorts(sw.deviceId().get());
+                            ports.stream().filter(p -> p.annotations().value(AnnotationKeys.PORT_NAME)
+                                    .equalsIgnoreCase(tunnelName))
+                                    .forEach(p -> l2ForwardService.programTunnelOut(
+                                            sw.deviceId().get(), segmentationId, p.number(),
+                                            dstMac, type, ipAddress));
                             break;
                         }
                     }
diff --git a/apps/vtn/vtnmgr/src/main/java/org/onosproject/vtn/util/VtnConfig.java b/apps/vtn/vtnmgr/src/main/java/org/onosproject/vtn/util/VtnConfig.java
index 3341779..7301a46 100644
--- a/apps/vtn/vtnmgr/src/main/java/org/onosproject/vtn/util/VtnConfig.java
+++ b/apps/vtn/vtnmgr/src/main/java/org/onosproject/vtn/util/VtnConfig.java
@@ -23,7 +23,9 @@
 import org.onosproject.net.DefaultAnnotations;
 import org.onosproject.net.PortNumber;
 import org.onosproject.net.behaviour.BridgeConfig;
+import org.onosproject.net.behaviour.BridgeDescription;
 import org.onosproject.net.behaviour.BridgeName;
+import org.onosproject.net.behaviour.DefaultBridgeDescription;
 import org.onosproject.net.behaviour.DefaultTunnelDescription;
 import org.onosproject.net.behaviour.IpTunnelEndPoint;
 import org.onosproject.net.behaviour.TunnelConfig;
@@ -62,7 +64,16 @@
      */
     public static void applyBridgeConfig(DriverHandler handler, String dpid, String exPortName) {
         BridgeConfig bridgeConfig = handler.behaviour(BridgeConfig.class);
-        bridgeConfig.addBridge(BridgeName.bridgeName(DEFAULT_BRIDGE_NAME), dpid, exPortName);
+        BridgeDescription bridgeDesc = DefaultBridgeDescription.builder()
+                .name(DEFAULT_BRIDGE_NAME)
+                .failMode(BridgeDescription.FailMode.SECURE)
+                .datapathId(dpid)
+                .disableInBand()
+                .enableLocalController()
+                .build();
+
+        bridgeConfig.addBridge(bridgeDesc);
+        bridgeConfig.addPort(BridgeName.bridgeName(DEFAULT_BRIDGE_NAME), exPortName);
     }
 
     /**
diff --git a/core/api/src/main/java/org/onosproject/net/behaviour/BridgeConfig.java b/core/api/src/main/java/org/onosproject/net/behaviour/BridgeConfig.java
index 1461db3..3b47079 100644
--- a/core/api/src/main/java/org/onosproject/net/behaviour/BridgeConfig.java
+++ b/core/api/src/main/java/org/onosproject/net/behaviour/BridgeConfig.java
@@ -31,31 +31,45 @@
     /**
      * Add a bridge.
      *
+     * @deprecated version 1.7.0 - Hummingbird
      * @param bridgeName bridge name
      */
+    @Deprecated
     void addBridge(BridgeName bridgeName);
 
     /**
      * Adds a bridge with given bridge name, dpid and exPortName.
      *
+     * @deprecated version 1.7.0 - Hummingbird
      * @param bridgeName bridge name
      * @param dpid dpid
      * @param exPortName external port name
      */
+    @Deprecated
     void addBridge(BridgeName bridgeName, String dpid, String exPortName);
 
     /**
      * Adds a bridge with given bridge name and dpid, and sets the controller
      * of the bridge with given controllers.
      *
+     * @deprecated version 1.7.0 - Hummingbird
      * @param bridgeName bridge name
      * @param dpid dpid
      * @param controllers list of controller
      * @return true if succeeds, fail otherwise
      */
+    @Deprecated
     boolean addBridge(BridgeName bridgeName, String dpid, List<ControllerInfo> controllers);
 
     /**
+     * Adds a bridge with a given description.
+     *
+     * @param bridgeDescription bridge description
+     * @return true if succeeds, or false
+     */
+    boolean addBridge(BridgeDescription bridgeDescription);
+
+    /**
      * Remove a bridge.
      *
      * @param bridgeName bridge name
diff --git a/core/api/src/main/java/org/onosproject/net/behaviour/BridgeDescription.java b/core/api/src/main/java/org/onosproject/net/behaviour/BridgeDescription.java
index e945ade..a8c0832 100644
--- a/core/api/src/main/java/org/onosproject/net/behaviour/BridgeDescription.java
+++ b/core/api/src/main/java/org/onosproject/net/behaviour/BridgeDescription.java
@@ -18,29 +18,140 @@
 import org.onosproject.net.Description;
 import org.onosproject.net.DeviceId;
 
+import java.util.List;
+import java.util.Optional;
+
 /**
- * The abstraction of bridge in OVSDB protocol.
+ * The abstraction of a bridge. Bridge represents an Ethernet switch with no or
+ * multiple OpenFlow controllers. Only OVSDB device provides bridge config behavior
+ * now and the bridge description is based on OVSDB schema.
  */
 public interface BridgeDescription extends Description {
 
+    enum FailMode {
+        /**
+         * The bridge will not set up flows on its own when the controller
+         * connection fails or no controllers are defined.
+         */
+        SECURE,
+        /**
+         * The bridge will take over responsibility of setting up flows.
+         */
+        STANDALONE
+    }
+
     /**
      * Returns bridge name.
      *
      * @return bridge name
      */
-    BridgeName bridgeName();
+    String name();
 
     /**
-     * Returns controller identifier that this bridge belongs to.
+     * Returns OpenFlow controllers of the bridge.
+     * If it's empty, then no OpenFlow controllers are used for the bridge.
      *
-     * @return controller identifier
+     * @return set of controllers
      */
-    DeviceId cotrollerDeviceId();
+    List<ControllerInfo> controllers();
 
     /**
-     * Returns bridge identifier .
+     * Returns whether to use local controller as an OpenFlow controller of the
+     * bridge if no controllers are specified.
      *
-     * @return bridge identifier
+     * @return true to set local controller, false otherwise
      */
-    DeviceId deviceId();
+    boolean enableLocalController();
+
+    /**
+     * Returns fail mode of the bridge.
+     * If it's not set, the default setting of the bridge is used.
+     *
+     * @return fail mode
+     */
+    Optional<FailMode> failMode();
+
+    /**
+     * Returns OpenFlow datapath ID of the bridge. Valid only if OpenFlow controller
+     * is configured for the bridge.
+     *
+     * @return datapath id
+     */
+    Optional<String> datapathId();
+
+    /**
+     * Returns OpenFlow device ID. Valid only if OpenFlow controller is configured
+     * for the bridge.
+     *
+     * @return device id
+     */
+    Optional<DeviceId> deviceId();
+
+    /**
+     * Returns in band control is enabled or not. If set to true, disable in-band
+     * control on the bridge regardless of controller and manager settings.
+     * If it's not set, the default setting of the bridge is used.
+     *
+     * @return true if in-band is disabled, false if in-band is enabled
+     */
+    Optional<Boolean> disableInBand();
+
+    /**
+     * Builder of bridge description entities.
+     */
+    interface Builder {
+
+        /**
+         * Returns bridge description builder with a given name.
+         *
+         * @param name bridge name
+         * @return bridge description builder
+         */
+        Builder name(String name);
+
+        /**
+         * Returns bridge description builder with given controllers.
+         *
+         * @param controllers set of controllers
+         * @return bridge description builder
+         */
+        Builder controllers(List<ControllerInfo> controllers);
+
+        /**
+         * Returns bridge description builder with local controller enabled.
+         *
+         * @return bridge description builder
+         */
+        Builder enableLocalController();
+
+        /**
+         * Returns bridge description builder with a given fail mode.
+         *
+         * @param failMode fail mode
+         * @return bridge description builder
+         */
+        Builder failMode(FailMode failMode);
+
+        /**
+         * Returns bridge description builder with a given datapath ID.
+         *
+         * @param datapathId datapath id
+         * @return bridge description builder
+         */
+        Builder datapathId(String datapathId);
+
+        /**
+         * Returns bridge description builder with in-band control disabled.
+         *
+         * @return bridge description builder
+         */
+        Builder disableInBand();
+
+        /**
+         * Builds an immutable bridge description.
+         *
+         * @return bridge description
+         */
+        BridgeDescription build();
+    }
 }
diff --git a/core/api/src/main/java/org/onosproject/net/behaviour/DefaultBridgeDescription.java b/core/api/src/main/java/org/onosproject/net/behaviour/DefaultBridgeDescription.java
index 6bd73a8..f35b646 100644
--- a/core/api/src/main/java/org/onosproject/net/behaviour/DefaultBridgeDescription.java
+++ b/core/api/src/main/java/org/onosproject/net/behaviour/DefaultBridgeDescription.java
@@ -15,73 +15,158 @@
  */
 package org.onosproject.net.behaviour;
 
-import java.util.Objects;
-
-import org.onosproject.net.AbstractDescription;
+import com.google.common.base.Strings;
+import com.google.common.collect.Lists;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.SparseAnnotations;
 
-import com.google.common.base.MoreObjects;
+import java.util.List;
+import java.util.Optional;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
 
 /**
  * The default implementation of bridge.
  */
-public final class DefaultBridgeDescription extends AbstractDescription
-        implements BridgeDescription {
+public final class DefaultBridgeDescription implements BridgeDescription {
 
-    private final BridgeName name;
-    private final DeviceId deviceId;
-    private final DeviceId controllerId;
+    private final String name;
 
-    public DefaultBridgeDescription(BridgeName name, DeviceId controllerId,
-                                    DeviceId deviceId,
-                                    SparseAnnotations... annotations) {
-        super(annotations);
-        this.name = name;
-        this.deviceId = deviceId;
-        this.controllerId = controllerId;
+    /* Optional OpenFlow configurations */
+    private final List<ControllerInfo> controllers;
+    private final boolean enableLocalController;
+    private final Optional<FailMode> failMode;
+    private final Optional<String> datapathId;
+    private final Optional<Boolean> disableInBand;
+
+    /* Adds more configurations */
+
+    private DefaultBridgeDescription(String name,
+                                     List<ControllerInfo> controllers,
+                                     boolean enableLocalController,
+                                     Optional<FailMode> failMode,
+                                     Optional<String> datapathId,
+                                     Optional<Boolean> disableInBand) {
+        this.name = checkNotNull(name);
+        this.controllers = controllers;
+        this.enableLocalController = enableLocalController;
+        this.failMode = failMode;
+        this.datapathId = datapathId;
+        this.disableInBand = disableInBand;
     }
 
     @Override
-    public BridgeName bridgeName() {
+    public SparseAnnotations annotations() {
+        return null;
+    }
+
+    @Override
+    public String name() {
         return name;
     }
 
     @Override
-    public DeviceId deviceId() {
-        return deviceId;
+    public List<ControllerInfo> controllers() {
+        return controllers;
     }
 
     @Override
-    public DeviceId cotrollerDeviceId() {
-        return controllerId;
+    public boolean enableLocalController() {
+        return enableLocalController;
     }
 
     @Override
-    public int hashCode() {
-        return Objects.hash(name, deviceId, controllerId);
+    public Optional<FailMode> failMode() {
+        return failMode;
     }
 
     @Override
-    public boolean equals(Object obj) {
-        if (this == obj) {
-            return true;
+    public Optional<String> datapathId() {
+        return datapathId;
+    }
+
+    @Override
+    public Optional<DeviceId> deviceId() {
+        if (datapathId.isPresent()) {
+            return Optional.of(DeviceId.deviceId("of:" + datapathId.get()));
+        } else {
+            return Optional.empty();
         }
-        if (obj instanceof DefaultBridgeDescription) {
-            final DefaultBridgeDescription that = (DefaultBridgeDescription) obj;
-            return this.getClass() == that.getClass()
-                    && Objects.equals(this.name, that.name)
-                    && Objects.equals(this.deviceId, that.deviceId)
-                    && Objects.equals(this.controllerId, that.controllerId);
-        }
-        return false;
     }
 
     @Override
-    public String toString() {
-        return MoreObjects.toStringHelper(getClass()).add("name", name)
-                .add("deviceId", deviceId).add("controllerId", controllerId)
-                .toString();
+    public Optional<Boolean> disableInBand() {
+        return disableInBand;
     }
 
+    /**
+     * Creates and returns a new builder instance.
+     *
+     * @return new builder
+     */
+    public static BridgeDescription.Builder builder() {
+        return new Builder();
+    }
+
+    public static final class Builder implements BridgeDescription.Builder {
+
+        private String name;
+        private List<ControllerInfo> controllers = Lists.newArrayList();
+        private boolean enableLocalController = false;
+        private Optional<FailMode> failMode = Optional.empty();
+        private Optional<String> datapathId = Optional.empty();
+        private Optional<Boolean> disableInBand = Optional.empty();
+
+        private Builder() {
+        }
+
+        @Override
+        public BridgeDescription build() {
+            return new DefaultBridgeDescription(name, controllers,
+                                                enableLocalController,
+                                                failMode,
+                                                datapathId,
+                                                disableInBand);
+        }
+
+        @Override
+        public Builder name(String name) {
+            checkArgument(!Strings.isNullOrEmpty(name));
+            this.name = name;
+            return this;
+        }
+
+        @Override
+        public Builder controllers(List<ControllerInfo> controllers) {
+            if (controllers != null) {
+                this.controllers = Lists.newArrayList(controllers);
+            }
+            return this;
+        }
+
+        @Override
+        public Builder enableLocalController() {
+            this.enableLocalController = true;
+            return this;
+        }
+
+        @Override
+        public Builder failMode(FailMode failMode) {
+            this.failMode = Optional.ofNullable(failMode);
+            return this;
+        }
+
+        @Override
+        public Builder datapathId(String datapathId) {
+            this.datapathId = Optional.ofNullable(datapathId);
+            return this;
+        }
+
+        @Override
+        public Builder disableInBand() {
+            this.disableInBand = Optional.of(Boolean.TRUE);
+            return this;
+        }
+    }
 }
diff --git a/drivers/ovsdb/src/main/java/org/onosproject/drivers/ovsdb/OvsdbBridgeConfig.java b/drivers/ovsdb/src/main/java/org/onosproject/drivers/ovsdb/OvsdbBridgeConfig.java
index 20209bb..5022799 100644
--- a/drivers/ovsdb/src/main/java/org/onosproject/drivers/ovsdb/OvsdbBridgeConfig.java
+++ b/drivers/ovsdb/src/main/java/org/onosproject/drivers/ovsdb/OvsdbBridgeConfig.java
@@ -49,48 +49,74 @@
 public class OvsdbBridgeConfig extends AbstractHandlerBehaviour
         implements BridgeConfig {
 
+    @Deprecated
     @Override
     public void addBridge(BridgeName bridgeName) {
-        DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        clientService.createBridge(bridgeName.name());
+        BridgeDescription bridgeDesc = DefaultBridgeDescription.builder()
+                .name(bridgeName.name())
+                .build();
+
+        addBridge(bridgeDesc);
     }
 
+    @Deprecated
     @Override
     public void addBridge(BridgeName bridgeName, String dpid, String exPortName) {
-        DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        clientService.createBridge(bridgeName.name(), dpid, exPortName);
+        BridgeDescription bridgeDesc = DefaultBridgeDescription.builder()
+                .name(bridgeName.name())
+                .failMode(BridgeDescription.FailMode.SECURE)
+                .datapathId(dpid)
+                .disableInBand()
+                .enableLocalController()
+                .build();
+
+        addBridge(bridgeDesc);
+
+        OvsdbClientService client = getOvsdbClientService(handler());
+        client.createPort(bridgeName.name(), exPortName);
+    }
+
+    @Deprecated
+    @Override
+    public boolean addBridge(BridgeName bridgeName, String dpid, List<ControllerInfo> controllers) {
+        BridgeDescription bridgeDesc = DefaultBridgeDescription.builder()
+                .name(bridgeName.name())
+                .failMode(BridgeDescription.FailMode.SECURE)
+                .datapathId(dpid)
+                .disableInBand()
+                .controllers(controllers)
+                .build();
+
+        return addBridge(bridgeDesc);
     }
 
     @Override
-    public boolean addBridge(BridgeName bridgeName, String dpid, List<ControllerInfo> controllers) {
-        DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        return clientService.createBridge(bridgeName.name(), dpid, controllers);
+    public boolean addBridge(BridgeDescription bridgeDesc) {
+        OvsdbClientService client = getOvsdbClientService(handler());
+
+        OvsdbBridge.Builder bridgeBuilder = OvsdbBridge.builder(bridgeDesc);
+        if (bridgeDesc.enableLocalController()) {
+            bridgeBuilder.controller(client.localController());
+        }
+        return client.createBridge(bridgeBuilder.build());
     }
 
     @Override
     public void deleteBridge(BridgeName bridgeName) {
-        DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        clientService.dropBridge(bridgeName.name());
+        OvsdbClientService client = getOvsdbClientService(handler());
+        client.dropBridge(bridgeName.name());
     }
 
     @Override
     public Collection<BridgeDescription> getBridges() {
-        DriverHandler handler = handler();
-        DeviceId deviceId = handler.data().deviceId();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        Set<OvsdbBridge> bridges = clientService.getBridges();
+        OvsdbClientService client = getOvsdbClientService(handler());
+        Set<OvsdbBridge> bridges = client.getBridges();
 
         return bridges.stream()
-                .map(x -> new DefaultBridgeDescription(
-                                BridgeName.bridgeName(x.bridgeName().value()),
-                                deviceId,
-                                DeviceId.deviceId("of:" + x.datapathId().value())
-                        )
-                )
+                .map(bridge -> DefaultBridgeDescription.builder()
+                        .name(bridge.name())
+                        .datapathId(bridge.datapathId().get())
+                        .build())
                 .collect(Collectors.toSet());
     }
 
@@ -98,49 +124,42 @@
     @Deprecated
     @Override
     public void addPort(PortDescription port) {
-        DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        Set<OvsdbBridge> ovsdbSet = clientService.getBridges();
+        OvsdbClientService client = getOvsdbClientService(handler());
+        Set<OvsdbBridge> ovsdbSet = client.getBridges();
         if (ovsdbSet != null && ovsdbSet.size() > 0) {
             OvsdbBridge bridge = ovsdbSet.iterator().next();
-            clientService.createPort(bridge.bridgeName().value(), port
-                    .portNumber().toString());
+            client.createPort(bridge.name(), port.portNumber().toString());
         }
     }
 
     @Override
     public void addPort(BridgeName bridgeName, String portName) {
-        DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        clientService.createPort(bridgeName.name(), portName);
+        OvsdbClientService client = getOvsdbClientService(handler());
+        client.createPort(bridgeName.name(), portName);
     }
 
     //Deprecated from version 1.5.0 - Falcon
     @Deprecated
     @Override
     public void deletePort(PortDescription port) {
-        DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        Set<OvsdbBridge> ovsdbSet = clientService.getBridges();
+        OvsdbClientService client = getOvsdbClientService(handler());
+        Set<OvsdbBridge> ovsdbSet = client.getBridges();
         if (ovsdbSet != null && ovsdbSet.size() > 0) {
             OvsdbBridge bridge = ovsdbSet.iterator().next();
-            clientService.dropPort(bridge.bridgeName().value(), port
-                    .portNumber().toString());
+            client.dropPort(bridge.name(), port.portNumber().toString());
         }
     }
 
     @Override
     public void deletePort(BridgeName bridgeName, String portName) {
-        DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        clientService.dropPort(bridgeName.name(), portName);
+        OvsdbClientService client = getOvsdbClientService(handler());
+        client.dropPort(bridgeName.name(), portName);
     }
 
     @Override
     public Collection<PortDescription> getPorts() {
-        DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        Set<OvsdbPort> ports = clientService.getPorts();
+        OvsdbClientService client = getOvsdbClientService(handler());
+        Set<OvsdbPort> ports = client.getPorts();
 
         return ports.stream()
                 .map(x -> new DefaultPortDescription(
@@ -174,8 +193,8 @@
     @Override
     public Set<PortNumber> getPortNumbers() {
         DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        Set<OvsdbPort> ports = clientService.getPorts();
+        OvsdbClientService client = getOvsdbClientService(handler);
+        Set<OvsdbPort> ports = client.getPorts();
 
         return ports.stream()
                 .map(x -> PortNumber.portNumber(
@@ -190,8 +209,8 @@
     public List<PortNumber> getLocalPorts(Iterable<String> ifaceIds) {
         List<PortNumber> ports = new ArrayList<>();
         DriverHandler handler = handler();
-        OvsdbClientService clientService = getOvsdbClientService(handler);
-        Set<OvsdbPort> ovsdbSet = clientService.getLocalPorts(ifaceIds);
+        OvsdbClientService client = getOvsdbClientService(handler);
+        Set<OvsdbPort> ovsdbSet = client.getLocalPorts(ifaceIds);
         ovsdbSet.forEach(o -> {
             PortNumber port = PortNumber.portNumber(o.portNumber().value(),
                                                     o.portName().value());
diff --git a/drivers/ovsdb/src/main/java/org/onosproject/drivers/ovsdb/OvsdbControllerConfig.java b/drivers/ovsdb/src/main/java/org/onosproject/drivers/ovsdb/OvsdbControllerConfig.java
index 5b42b2d..9597169 100644
--- a/drivers/ovsdb/src/main/java/org/onosproject/drivers/ovsdb/OvsdbControllerConfig.java
+++ b/drivers/ovsdb/src/main/java/org/onosproject/drivers/ovsdb/OvsdbControllerConfig.java
@@ -36,6 +36,7 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkState;
 import static org.onlab.util.Tools.delay;
 
@@ -96,7 +97,9 @@
     }
 
     private static boolean dpidMatches(OvsdbBridge bridge, DeviceId deviceId) {
-        String bridgeDpid = "of:" + bridge.datapathId().value();
+        checkArgument(bridge.datapathId().isPresent());
+
+        String bridgeDpid = "of:" + bridge.datapathId().get();
         String ofDpid = deviceId.toString();
         return bridgeDpid.equals(ofDpid);
     }
diff --git a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridge.java b/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridge.java
index 73d7dd8..00eb375 100644
--- a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridge.java
+++ b/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridge.java
@@ -15,32 +15,55 @@
  */
 package org.onosproject.ovsdb.controller;
 
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import org.onosproject.net.behaviour.BridgeDescription;
+import org.onosproject.net.behaviour.BridgeDescription.FailMode;
+import org.onosproject.net.behaviour.ControllerInfo;
+
 import static com.google.common.base.MoreObjects.toStringHelper;
+import static org.onosproject.ovsdb.controller.OvsdbConstant.DATAPATH_ID;
+import static org.onosproject.ovsdb.controller.OvsdbConstant.DISABLE_INBAND;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
 import static com.google.common.base.Preconditions.checkNotNull;
 
-import java.util.Objects;
-
 /**
- * The class representing an ovsdb bridge.
+ * The class representing an OVSDB bridge.
  * This class is immutable.
  */
 public final class OvsdbBridge {
 
-    private final OvsdbBridgeName bridgeName;
-    private final OvsdbDatapathId datapathId;
+    private final String name;
+
+    /* OpenFlow properties */
+    private final Optional<FailMode> failMode;
+    private final List<ControllerInfo> controllers;
+
+    /* Adds more properties */
+
+    /* other optional configs */
+    private final Map<String, String> otherConfigs;
 
     /**
-     * Constructor from an OvsdbBridgeName bridgeName and an OvsdbDatapathId
-     * datapathId.
+     * Default constructor.
      *
-     * @param bridgeName the bridgeName to use
-     * @param datapathId the datapathId to use
+     * @param name name of the bridge
+     * @param failMode openflow controller fail mode policy
+     * @param controllers list of openflow controllers
+     * @param otherConfigs other configs
      */
-    public OvsdbBridge(OvsdbBridgeName bridgeName, OvsdbDatapathId datapathId) {
-        checkNotNull(bridgeName, "bridgeName is not null");
-        checkNotNull(datapathId, "datapathId is not null");
-        this.bridgeName = bridgeName;
-        this.datapathId = datapathId;
+    private OvsdbBridge(String name, Optional<FailMode> failMode,
+                       List<ControllerInfo> controllers,
+                       Map<String, String> otherConfigs) {
+        this.name = checkNotNull(name);
+        this.failMode = failMode;
+        this.controllers = controllers;
+        this.otherConfigs = otherConfigs;
     }
 
     /**
@@ -48,22 +71,49 @@
      *
      * @return the bridge name of bridge
      */
-    public OvsdbBridgeName bridgeName() {
-        return bridgeName;
+    public String name() {
+        return name;
+    }
+
+    /**
+     * Returns the controllers of the bridge.
+     *
+     * @return list of controllers
+     */
+    public List<ControllerInfo> controllers() {
+        return controllers;
+    }
+
+    /**
+     * Returns fail mode of the bridge.
+     *
+     * @return fail mode
+     */
+    public Optional<FailMode> failMode() {
+        return failMode;
+    }
+
+    /**
+     * Returns other configurations of the bridge.
+     *
+     * @return map of configurations
+     */
+    public Map<String, String> otherConfigs() {
+        return otherConfigs;
     }
 
     /**
      * Gets the datapathId of bridge.
      *
-     * @return datapathId the datapathId to use
+     * @return datapath id; null if not used
      */
-    public OvsdbDatapathId datapathId() {
-        return datapathId;
+    public Optional<String> datapathId() {
+        return Optional.ofNullable(otherConfigs.get(DATAPATH_ID));
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(bridgeName, datapathId);
+        return Objects.hash(name);
     }
 
     @Override
@@ -73,16 +123,154 @@
         }
         if (obj instanceof OvsdbBridge) {
             final OvsdbBridge otherOvsdbBridge = (OvsdbBridge) obj;
-            return Objects.equals(this.bridgeName, otherOvsdbBridge.bridgeName)
-                    && Objects.equals(this.datapathId,
-                                      otherOvsdbBridge.datapathId);
+            return Objects.equals(this.name, otherOvsdbBridge.name);
         }
         return false;
     }
 
     @Override
     public String toString() {
-        return toStringHelper(this).add("bridgeName", bridgeName.value())
-                .add("datapathId", datapathId.value()).toString();
+        return toStringHelper(this)
+                .add("bridgeName", name)
+                .add("failMode", failMode)
+                .add("controllers", controllers)
+                .add("otherConfigs", otherConfigs)
+                .toString();
+    }
+
+    /**
+     * Returns a new builder instance.
+     *
+     * @return ovsdb bridge builder
+     */
+    public static OvsdbBridge.Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Returns OVSDB bridge object with a given bridge description.
+     *
+     * @param bridgeDesc bridge description
+     * @return ovsdb bridge
+     */
+    public static OvsdbBridge.Builder builder(BridgeDescription bridgeDesc) {
+        return new Builder(bridgeDesc);
+    }
+
+    /**
+     * Builder of OVSDB bridge entities.
+     */
+    public static final class Builder {
+        private String name;
+        private Optional<FailMode> failMode = Optional.empty();
+        private List<ControllerInfo> controllers = Lists.newArrayList();
+        private Map<String, String> otherConfigs = Maps.newHashMap();
+
+        private Builder() {
+        }
+
+        /**
+         * Constructs OVSDB bridge builder with a given bridge description.
+         *
+         * @param bridgeDesc bridge description
+         */
+        private Builder(BridgeDescription bridgeDesc) {
+            if (bridgeDesc.datapathId().isPresent()) {
+                otherConfigs.put(DATAPATH_ID, bridgeDesc.datapathId().get());
+            }
+            if (bridgeDesc.disableInBand().isPresent()) {
+                otherConfigs.put(DISABLE_INBAND,
+                                 bridgeDesc.disableInBand().get().toString());
+            }
+
+            this.name = bridgeDesc.name();
+            this.failMode = bridgeDesc.failMode();
+            this.controllers = Lists.newArrayList(bridgeDesc.controllers());
+        }
+
+        /**
+         * Builds an immutable OVSDB bridge.
+         *
+         * @return ovsdb bridge
+         */
+        public OvsdbBridge build() {
+            return new OvsdbBridge(name, failMode, controllers, otherConfigs);
+        }
+
+        /**
+         * Returns OVSDB bridge builder with a given name.
+         *
+         * @param name name of the bridge
+         * @return ovsdb bridge builder
+         */
+        public Builder name(String name) {
+            this.name = name;
+            return this;
+        }
+
+        /**
+         * Returns OVSDB bridge builder with a given fail mode.
+         *
+         * @param failMode fail mode
+         * @return ovsdb bridge builder
+         */
+        public Builder failMode(FailMode failMode) {
+            this.failMode = Optional.ofNullable(failMode);
+            return this;
+        }
+
+        /**
+         * Returns OVSDB bridge builder with given controllers.
+         *
+         * @param controllers list of controllers
+         * @return ovsdb bridge builder
+         */
+        public Builder controllers(List<ControllerInfo> controllers) {
+            this.controllers = Lists.newArrayList(controllers);
+            return this;
+        }
+
+        /**
+         * Returns OVSDB bridge builder with a given controller.
+         *
+         * @param controller controller
+         * @return ovsdb bridge builder
+         */
+        public Builder controller(ControllerInfo controller) {
+            this.controllers = Lists.newArrayList(controller);
+            return this;
+        }
+
+        /**
+         * Returns OVSDB bridge builder with given configs.
+         *
+         * @param otherConfigs other configs
+         * @return ovsdb bridge builder
+         */
+        public Builder otherConfigs(Map<String, String> otherConfigs) {
+            this.otherConfigs = Maps.newHashMap(otherConfigs);
+            return this;
+        }
+
+        /**
+         * Returns OVSDB bridge builder with a given datapath ID.
+         *
+         * @param datapathId datapath id
+         * @return ovsdb bridge builder
+         */
+        public Builder datapathId(String datapathId) {
+            otherConfigs.put(DATAPATH_ID, datapathId);
+            return this;
+        }
+
+        /**
+         * Returns OVSDB bridge builder with a given disable in-band config.
+         *
+         * @return ovsdb bridge builder
+         */
+        public Builder disableInBand() {
+            otherConfigs.put(DATAPATH_ID, Boolean.TRUE.toString());
+            return this;
+        }
     }
 }
diff --git a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridgeName.java b/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridgeName.java
deleted file mode 100644
index dc905bb..0000000
--- a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbBridgeName.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright 2015-present Open Networking Laboratory
- *
- * 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.ovsdb.controller;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Objects;
-
-/**
- * The class representing a bridge name.
- * This class is immutable.
- */
-public final class OvsdbBridgeName {
-
-    private final String value;
-
-    /**
-     * Constructor from a String.
-     *
-     * @param value the bridge name to use
-     */
-    public OvsdbBridgeName(String value) {
-        checkNotNull(value, "value is not null");
-        this.value = value;
-    }
-
-    /**
-     * Gets the value of bridge name.
-     *
-     * @return the value of the bridge name
-     */
-    public String value() {
-        return value;
-    }
-
-    @Override
-    public int hashCode() {
-        return value.hashCode();
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj) {
-            return true;
-        }
-        if (obj instanceof OvsdbBridgeName) {
-            final OvsdbBridgeName otherBridgeName = (OvsdbBridgeName) obj;
-            return Objects.equals(this.value, otherBridgeName.value);
-        }
-        return false;
-    }
-
-    @Override
-    public String toString() {
-        return toStringHelper(this).add("value", value).toString();
-    }
-
-}
diff --git a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbClientService.java b/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbClientService.java
index 8db1dbc..bf91497 100644
--- a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbClientService.java
+++ b/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbClientService.java
@@ -72,31 +72,45 @@
     /**
      * Creates a bridge.
      *
+     * @deprecated version 1.7.0 - Hummingbird
      * @param bridgeName bridge name
      */
+    @Deprecated
     void createBridge(String bridgeName);
 
     /**
      * Creates a bridge.
      *
+     * @deprecated version 1.7.0 - Hummingbird
      * @param bridgeName bridge name
      * @param dpid data path id
      * @param exPortName external port name
      */
+    @Deprecated
     void createBridge(String bridgeName, String dpid, String exPortName);
 
     /**
      * Creates a bridge with given name and dpid.
      * Sets the bridge's controller with given controllers.
      *
+     * @deprecated version 1.7.0 - Hummingbird
      * @param bridgeName bridge name
      * @param dpid data path id
      * @param controllers controllers
      * @return true if bridge creation is successful, false otherwise
      */
+    @Deprecated
     boolean createBridge(String bridgeName, String dpid, List<ControllerInfo> controllers);
 
     /**
+     * Creates a bridge with a given bridge description.
+     *
+     * @param ovsdbBridge ovsdb bridge description
+     * @return true if bridge creation is successful, otherwise false
+     */
+    boolean createBridge(OvsdbBridge ovsdbBridge);
+
+    /**
      * Drops a bridge.
      *
      * @param bridgeName bridge name
@@ -119,6 +133,15 @@
     Set<ControllerInfo> getControllers(DeviceId openflowDeviceId);
 
     /**
+     * Returns local controller information.
+     * The connection is a TCP connection to the local ONOS instance's IP
+     * and the default OpenFlow port.
+     *
+     * @return local controller
+     */
+    ControllerInfo localController();
+
+    /**
      * Sets the Controllers for the specified bridge.
      * <p>
      * This method will replace the existing controller list with the new controller
diff --git a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbConstant.java b/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbConstant.java
index c1d00a1..5bca1f9 100644
--- a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbConstant.java
+++ b/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/OvsdbConstant.java
@@ -29,40 +29,46 @@
     private OvsdbConstant() {
     }
 
+    /** Common column names. */
+    public static final String UUID = "_uuid";
+
     /** Ovsdb database Open_vSwitch. */
     public static final String DATABASENAME = "Open_vSwitch";
 
-    /** Ovsdb table Bridge. */
+    /** Open_vSwitch table. */
+    public static final String BRIDGES = "bridges";
+
+    /** Bridge table. */
     public static final String BRIDGE = "Bridge";
+    public static final String PORTS = "ports";
+    // other configs
+    public static final String DATAPATH_ID = "datapath-id";
+    public static final String DISABLE_INBAND = "disable-in-band";
 
-    /** Ovsdb table Interface. */
+    /** Interface table. */
     public static final String INTERFACE = "Interface";
+    // type
+    public static final String TYPEVXLAN = "vxlan";
+    // virtual machine identifiers
+    public static final String EXTERNAL_ID_INTERFACE_ID = "iface-id";
+    public static final String EXTERNAL_ID_VM_MAC = "attached-mac";
 
-    /** Ovsdb table Controller. */
+    /** Controller table. */
     public static final String CONTROLLER = "Controller";
 
-    /** Ovsdb table Port. */
+    /** Port table. */
     public static final String PORT = "Port";
 
     /** Ovsdb bridge name. */
+    // TODO remove this particular bridge name from OVSDB provider
     public static final String INTEGRATION_BRIDGE = "br-int";
 
-    /** Ovsdb vxlan tunnel type. */
-    public static final String TYPEVXLAN = "vxlan";
-
     /** Openflow version. */
     public static final String OPENFLOW13 = "OpenFlow13";
 
-    /** Ovsdb external_id_interface_id.. */
-    public static final String EXTERNAL_ID_INTERFACE_ID = "iface-id";
-
-    /** Ovsdb external_id_vm_mac. */
-    public static final String EXTERNAL_ID_VM_MAC = "attached-mac";
-
     /** Openflow port. */
     public static final int OFPORT = 6653;
 
     /** Ovsdb port. */
     public static final int OVSDBPORT = 6640;
-
 }
diff --git a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/DefaultOvsdbClient.java b/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/DefaultOvsdbClient.java
index 3649866..cbb94ac 100644
--- a/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/DefaultOvsdbClient.java
+++ b/protocols/ovsdb/api/src/main/java/org/onosproject/ovsdb/controller/driver/DefaultOvsdbClient.java
@@ -17,7 +17,6 @@
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.google.common.base.Function;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
@@ -29,12 +28,10 @@
 
 import org.onlab.packet.IpAddress;
 import org.onosproject.net.DeviceId;
+import org.onosproject.net.behaviour.BridgeDescription;
 import org.onosproject.net.behaviour.ControllerInfo;
 import org.onosproject.ovsdb.controller.OvsdbBridge;
-import org.onosproject.ovsdb.controller.OvsdbBridgeName;
 import org.onosproject.ovsdb.controller.OvsdbClientService;
-import org.onosproject.ovsdb.controller.OvsdbConstant;
-import org.onosproject.ovsdb.controller.OvsdbDatapathId;
 import org.onosproject.ovsdb.controller.OvsdbNodeId;
 import org.onosproject.ovsdb.controller.OvsdbPort;
 import org.onosproject.ovsdb.controller.OvsdbPortName;
@@ -43,7 +40,6 @@
 import org.onosproject.ovsdb.controller.OvsdbStore;
 import org.onosproject.ovsdb.controller.OvsdbTableStore;
 import org.onosproject.ovsdb.controller.OvsdbTunnel;
-import org.onosproject.ovsdb.rfc.exception.BridgeCreateException;
 import org.onosproject.ovsdb.rfc.jsonrpc.Callback;
 import org.onosproject.ovsdb.rfc.message.OperationResult;
 import org.onosproject.ovsdb.rfc.message.TableUpdates;
@@ -77,7 +73,6 @@
 import java.net.InetSocketAddress;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
@@ -88,28 +83,24 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
+import static org.onosproject.ovsdb.controller.OvsdbConstant.*;
+
 /**
  * An representation of an ovsdb client.
  */
-public class DefaultOvsdbClient
-        implements OvsdbProviderService, OvsdbClientService {
+public class DefaultOvsdbClient implements OvsdbProviderService, OvsdbClientService {
 
-    private final Logger log = LoggerFactory
-            .getLogger(DefaultOvsdbClient.class);
+    private final Logger log = LoggerFactory.getLogger(DefaultOvsdbClient.class);
 
     private Channel channel;
-
     private OvsdbAgent agent;
     private boolean connected;
     private OvsdbNodeId nodeId;
     private Callback monitorCallBack;
-
     private OvsdbStore ovsdbStore = new OvsdbStore();
 
     private final Map<String, String> requestMethod = Maps.newHashMap();
-    private final Map<String, SettableFuture<? extends Object>> requestResult = Maps
-            .newHashMap();
-
+    private final Map<String, SettableFuture<? extends Object>> requestResult = Maps.newHashMap();
     private final Map<String, DatabaseSchema> schema = Maps.newHashMap();
     private final Set<OvsdbTunnel> ovsdbTunnels = new HashSet<OvsdbTunnel>();
 
@@ -245,11 +236,9 @@
 
     @Override
     public String getPortUuid(String portName, String bridgeUuid) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
 
-        Row bridgeRow = getRow(OvsdbConstant.DATABASENAME,
-                               OvsdbConstant.BRIDGE, bridgeUuid);
-
+        Row bridgeRow = getRow(DATABASENAME, BRIDGE, bridgeUuid);
         Bridge bridge = (Bridge) TableGenerator.getTable(dbSchema, bridgeRow,
                                                          OvsdbTable.BRIDGE);
         if (bridge != null) {
@@ -262,27 +251,23 @@
             }
 
             for (Uuid uuid : ports) {
-                Row portRow = getRow(OvsdbConstant.DATABASENAME,
-                                     OvsdbConstant.PORT, uuid.value());
+                Row portRow = getRow(DATABASENAME, PORT, uuid.value());
                 Port port = (Port) TableGenerator.getTable(dbSchema, portRow,
                                                            OvsdbTable.PORT);
                 if (port != null && portName.equalsIgnoreCase(port.getName())) {
                     return uuid.value();
                 }
             }
-
         }
         return null;
     }
 
     @Override
     public String getInterfaceUuid(String portUuid, String portName) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
 
-        Row portRow = getRow(OvsdbConstant.DATABASENAME, OvsdbConstant.PORT,
-                             portUuid);
-        Port port = (Port) TableGenerator.getTable(dbSchema, portRow,
-                                                   OvsdbTable.PORT);
+        Row portRow = getRow(DATABASENAME, PORT, portUuid);
+        Port port = (Port) TableGenerator.getTable(dbSchema, portRow, OvsdbTable.PORT);
 
         if (port != null) {
             OvsdbSet setInterfaces = (OvsdbSet) port.getInterfacesColumn().data();
@@ -295,26 +280,22 @@
             }
 
             for (Uuid uuid : interfaces) {
-                Row intfRow = getRow(OvsdbConstant.DATABASENAME,
-                                     OvsdbConstant.INTERFACE, uuid.value());
+                Row intfRow = getRow(DATABASENAME, INTERFACE, uuid.value());
                 Interface intf = (Interface) TableGenerator
                         .getTable(dbSchema, intfRow, OvsdbTable.INTERFACE);
                 if (intf != null && portName.equalsIgnoreCase(intf.getName())) {
                     return uuid.value();
                 }
             }
-
         }
-
         return null;
     }
 
     @Override
     public String getBridgeUuid(String bridgeName) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
 
-        OvsdbRowStore rowStore = getRowStore(OvsdbConstant.DATABASENAME,
-                                             OvsdbConstant.BRIDGE);
+        OvsdbRowStore rowStore = getRowStore(DATABASENAME, BRIDGE);
         if (rowStore == null) {
             log.debug("The bridge uuid is null");
             return null;
@@ -328,23 +309,18 @@
 
         for (String uuid : bridgeTableRows.keySet()) {
             Bridge bridge = (Bridge) TableGenerator
-                    .getTable(dbSchema, bridgeTableRows.get(uuid),
-                              OvsdbTable.BRIDGE);
-
+                    .getTable(dbSchema, bridgeTableRows.get(uuid), OvsdbTable.BRIDGE);
             if (bridge.getName().equals(bridgeName)) {
                 return uuid;
             }
-
         }
         return null;
     }
 
     @Override
-    public String getControllerUuid(String controllerName,
-                                    String controllerTarget) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
-        OvsdbRowStore rowStore = getRowStore(OvsdbConstant.DATABASENAME,
-                                             OvsdbConstant.CONTROLLER);
+    public String getControllerUuid(String controllerName, String controllerTarget) {
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
+        OvsdbRowStore rowStore = getRowStore(DATABASENAME, CONTROLLER);
         if (rowStore == null) {
             log.debug("The controller uuid is null");
             return null;
@@ -353,7 +329,6 @@
         ConcurrentMap<String, Row> controllerTableRows = rowStore.getRowStore();
         if (controllerTableRows != null) {
             for (String uuid : controllerTableRows.keySet()) {
-
                 Controller controller = (Controller) TableGenerator
                         .getTable(dbSchema, controllerTableRows.get(uuid),
                                   OvsdbTable.CONTROLLER);
@@ -361,7 +336,6 @@
                 if (target.equalsIgnoreCase(controllerTarget)) {
                     return uuid;
                 }
-
             }
         }
         return null;
@@ -369,8 +343,7 @@
 
     @Override
     public String getOvsUuid(String dbName) {
-        OvsdbRowStore rowStore = getRowStore(OvsdbConstant.DATABASENAME,
-                                             OvsdbConstant.DATABASENAME);
+        OvsdbRowStore rowStore = getRowStore(DATABASENAME, DATABASENAME);
         if (rowStore == null) {
             log.debug("The bridge uuid is null");
             return null;
@@ -392,26 +365,19 @@
     public void createPort(String bridgeName, String portName) {
         String bridgeUuid = getBridgeUuid(bridgeName);
         if (bridgeUuid == null) {
-            log.error("Can't find bridge {} in {}", bridgeName,
-                      nodeId.getIpAddress());
+            log.error("Can't find bridge {} in {}", bridgeName, nodeId.getIpAddress());
             return;
         }
 
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
         String portUuid = getPortUuid(portName, bridgeUuid);
-
-        Port port = (Port) TableGenerator
-                .createTable(dbSchema, OvsdbTable.PORT);
-
+        Port port = (Port) TableGenerator.createTable(dbSchema, OvsdbTable.PORT);
         port.setName(portName);
         if (portUuid == null) {
-            insertConfig(OvsdbConstant.PORT, "_uuid", OvsdbConstant.BRIDGE,
-                         "ports", bridgeUuid, port.getRow());
+            insertConfig(PORT, UUID, BRIDGE, PORTS, bridgeUuid, port.getRow());
         } else {
-            updateConfig(OvsdbConstant.PORT, "_uuid", portUuid, port.getRow());
+            updateConfig(PORT, UUID, portUuid, port.getRow());
         }
-
-        return;
     }
 
     @Override
@@ -425,220 +391,103 @@
         String portUuid = getPortUuid(portName, bridgeUuid);
         if (portUuid != null) {
             log.info("Port {} delete", portName);
-            deleteConfig(OvsdbConstant.PORT, "_uuid", portUuid,
-                         OvsdbConstant.BRIDGE, "ports");
+            deleteConfig(PORT, UUID, portUuid, BRIDGE, PORTS);
         }
     }
 
+    @Deprecated
     @Override
     public void createBridge(String bridgeName) {
-        log.debug("create bridge {}", bridgeName);
+        OvsdbBridge ovsdbBridge = OvsdbBridge.builder()
+                .name(bridgeName)
+                .build();
 
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
-        if (dbSchema == null) {
-            log.warn("The schema is null");
-            return;
-        }
-
-        Bridge bridge = (Bridge) TableGenerator.createTable(dbSchema,
-                                                            OvsdbTable.BRIDGE);
-        if (bridge == null) {
-            log.debug("Can not create bridge");
-            return;
-        }
-
-        Set<String> failModes = new HashSet<>();
-        failModes.add("secure");
-        bridge.setFailMode(failModes);
-
-        Set<String> protocols = new HashSet<>();
-        protocols.add(OvsdbConstant.OPENFLOW13);
-        bridge.setProtocols(protocols);
-
-        String ovsUuid = getOvsUuid(OvsdbConstant.DATABASENAME);
-        if (ovsUuid == null) {
-            log.warn("The Open_vSwitch is null");
-            return;
-        }
-
-        Map<String, String> options = new HashMap<>();
-        options.put("disable-in-band", "true");
-        bridge.setOtherConfig(options);
-
-        String bridgeUuid = getBridgeUuid(bridgeName);
-        if (bridgeUuid == null) {
-            log.debug("Create a new bridge");
-
-            bridge.setName(bridgeName);
-            bridgeUuid = insertConfig(OvsdbConstant.BRIDGE, "_uuid",
-                                      OvsdbConstant.DATABASENAME, "bridges",
-                                      ovsUuid, bridge.getRow());
-
-            if (bridgeUuid != null) {
-                Port port = (Port) TableGenerator.createTable(dbSchema,
-                                                              OvsdbTable.PORT);
-                if (port != null) {
-                    log.debug("the port is not null");
-                    port.setName(bridgeName);
-
-                    insertConfig(OvsdbConstant.PORT, "_uuid", "Bridge", "ports", bridgeUuid,
-                                 port.getRow());
-                }
-            } else {
-                String message = BridgeCreateException.createMessage(ovsUuid);
-                throw new BridgeCreateException(message);
-            }
-
-        } else {
-            log.info("Update a bridge");
-            updateConfig(OvsdbConstant.BRIDGE, "_uuid", bridgeUuid, bridge.getRow());
-        }
-
-        setControllerAuto(bridgeUuid);
-        log.info("Create bridge success");
+        createBridge(ovsdbBridge);
     }
 
+    @Deprecated
     @Override
     public void createBridge(String bridgeName, String dpid, String exPortName) {
-        log.debug("create bridge {}", bridgeName);
+        OvsdbBridge ovsdbBridge = OvsdbBridge.builder()
+                .name(bridgeName)
+                .failMode(BridgeDescription.FailMode.SECURE)
+                .datapathId(dpid)
+                .disableInBand()
+                .controllers(Lists.newArrayList(localController()))
+                .build();
 
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
-        if (dbSchema == null) {
-            log.warn("The schema is null");
-            return;
-        }
+        createBridge(ovsdbBridge);
 
-        Bridge bridge = (Bridge) TableGenerator.createTable(dbSchema,
-                                                            OvsdbTable.BRIDGE);
-        if (bridge == null) {
-            log.debug("Can not create bridge");
-            return;
-        }
-
-        Set<String> failModes = new HashSet<>();
-        failModes.add("secure");
-        bridge.setFailMode(failModes);
-
-        Set<String> protocols = new HashSet<>();
-        protocols.add(OvsdbConstant.OPENFLOW13);
-        bridge.setProtocols(protocols);
-
-        String ovsUuid = getOvsUuid(OvsdbConstant.DATABASENAME);
-        if (ovsUuid == null) {
-            log.warn("The Open_vSwitch is null");
-            return;
-        }
-
-        Map<String, String> options = new HashMap<>();
-        options.put("disable-in-band", "true");
-        if (dpid != null) {
-            options.put("datapath-id", dpid);
-        }
-        bridge.setOtherConfig(options);
-
-        String bridgeUuid = getBridgeUuid(bridgeName);
-        if (bridgeUuid == null) {
-            log.debug("Create a new bridge");
-
-            bridge.setName(bridgeName);
-            bridgeUuid = insertConfig(OvsdbConstant.BRIDGE, "_uuid",
-                                      OvsdbConstant.DATABASENAME, "bridges",
-                                      ovsUuid, bridge.getRow());
-
-            if (bridgeUuid != null) {
-                Port port = (Port) TableGenerator.createTable(dbSchema,
-                                                              OvsdbTable.PORT);
-                if (port != null) {
-                    log.debug("the port is not null");
-                    port.setName(bridgeName);
-
-                    insertConfig(OvsdbConstant.PORT, "_uuid", "Bridge", "ports", bridgeUuid,
-                                 port.getRow());
-                }
-            } else {
-                String message = BridgeCreateException.createMessage(ovsUuid);
-                throw new BridgeCreateException(message);
-            }
-
-        } else {
-            log.info("Update a bridge");
-            updateConfig(OvsdbConstant.BRIDGE, "_uuid", bridgeUuid, bridge.getRow());
-        }
-        // Create external port
         if (exPortName != null) {
             createPort(bridgeName, exPortName);
         }
+    }
 
-        setControllerAuto(bridgeUuid);
-        log.info("Create bridge success");
+    @Deprecated
+    @Override
+    public boolean createBridge(String bridgeName, String dpid, List<ControllerInfo> controllers) {
+        OvsdbBridge ovsdbBridge = OvsdbBridge.builder()
+                .name(bridgeName)
+                .failMode(BridgeDescription.FailMode.SECURE)
+                .datapathId(dpid)
+                .disableInBand()
+                .controllers(controllers)
+                .build();
+
+        return createBridge(ovsdbBridge);
     }
 
     @Override
-    public boolean createBridge(String bridgeName, String dpid, List<ControllerInfo> controllers) {
-
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
-        String ovsUuid = getOvsUuid(OvsdbConstant.DATABASENAME);
+    public boolean createBridge(OvsdbBridge ovsdbBridge) {
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
+        String ovsUuid = getOvsUuid(DATABASENAME);
 
         if (dbSchema == null || ovsUuid == null) {
-            log.warn("Couldn't find database Open_vSwitch");
+            log.error("Can't find database Open_vSwitch");
             return false;
         }
 
         Bridge bridge = (Bridge) TableGenerator.createTable(dbSchema, OvsdbTable.BRIDGE);
-        Set<String> failMode = new HashSet<>(Arrays.asList("secure"));
-        bridge.setFailMode(failMode);
+        bridge.setOtherConfig(ovsdbBridge.otherConfigs());
 
-        Set<String> protocols = new HashSet<>(Arrays.asList(OvsdbConstant.OPENFLOW13));
-        bridge.setProtocols(protocols);
-
-        Map<String, String> options = new HashMap<>();
-        options.put("disable-in-band", "true");
-        if (dpid != null) {
-            options.put("datapath-id", dpid);
+        if (ovsdbBridge.failMode().isPresent()) {
+            String failMode = ovsdbBridge.failMode().get().name().toLowerCase();
+            bridge.setFailMode(Sets.newHashSet(failMode));
         }
-        bridge.setOtherConfig(options);
 
-        String bridgeUuid = getBridgeUuid(bridgeName);
+        String bridgeUuid = getBridgeUuid(ovsdbBridge.name());
         if (bridgeUuid == null) {
-            bridge.setName(bridgeName);
-            bridgeUuid = insertConfig(OvsdbConstant.BRIDGE, "_uuid",
-                                      OvsdbConstant.DATABASENAME, "bridges",
-                                      ovsUuid, bridge.getRow());
+            bridge.setName(ovsdbBridge.name());
+            bridgeUuid = insertConfig(
+                    BRIDGE, UUID, DATABASENAME, BRIDGES,
+                    ovsUuid, bridge.getRow());
         } else {
-            updateConfig(OvsdbConstant.BRIDGE, "_uuid", bridgeUuid, bridge.getRow());
+            // update the bridge if it's already existing
+            updateConfig(BRIDGE, UUID, bridgeUuid, bridge.getRow());
         }
 
-        if (bridgeUuid != null) {
-            createPort(bridgeName, bridgeName);
-        } else {
-            log.warn("Failed to create bridge {} on {}", bridgeName, nodeId.toString());
+        if (bridgeUuid == null) {
+            log.warn("Failed to create bridge {} on {}", ovsdbBridge.name(), nodeId);
             return false;
         }
 
-        setControllersWithUuid(Uuid.uuid(bridgeUuid), controllers);
+        createPort(ovsdbBridge.name(), ovsdbBridge.name());
+        setControllersWithUuid(Uuid.uuid(bridgeUuid), ovsdbBridge.controllers());
+
+        log.info("Created bridge {}", ovsdbBridge.name());
         return true;
     }
 
-    /**
-     * Sets the bridge's controller automatically.
-     * <p/>
-     * The connection is a TCP connection to the local ONOS instance's IP
-     * and the default OpenFlow port.
-     *
-     * @param bridgeUuid bridge uuid
-     */
-    private void setControllerAuto(String bridgeUuid) {
-        IpAddress ipAddress = IpAddress.valueOf(((InetSocketAddress) channel.localAddress()).getAddress());
-        ControllerInfo controllerInfo = new ControllerInfo(ipAddress, OvsdbConstant.OFPORT, "tcp");
-        log.debug("Automatically setting controller for bridge {} to {}",
-                  bridgeUuid, controllerInfo.target());
-        setControllersWithUuid(Uuid.uuid(bridgeUuid), ImmutableList.of(controllerInfo));
+    @Override
+    public ControllerInfo localController() {
+        IpAddress ipAddress = IpAddress.valueOf(((InetSocketAddress)
+                channel.localAddress()).getAddress());
+        return new ControllerInfo(ipAddress, OFPORT, "tcp");
     }
 
     @Override
     public void setControllersWithUuid(Uuid bridgeUuid, List<ControllerInfo> controllers) {
-
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
         if (dbSchema == null) {
             log.debug("There is no schema");
             return;
@@ -662,31 +511,27 @@
                 removeControllers.add(controller);
             }
         });
-        OvsdbRowStore controllerRowStore = getRowStore(OvsdbConstant.DATABASENAME,
-                                                       OvsdbConstant.CONTROLLER);
+        OvsdbRowStore controllerRowStore = getRowStore(DATABASENAME, CONTROLLER);
         if (controllerRowStore == null) {
             log.debug("There is no controller table");
             return;
         }
 
-        removeControllers.forEach(c -> deleteConfig(OvsdbConstant.CONTROLLER, "_uuid", c.getRow().uuid().value(),
-                                                    OvsdbConstant.BRIDGE, "controller"));
-
+        removeControllers.forEach(c -> deleteConfig(CONTROLLER, UUID, c.getRow().uuid().value(),
+                                                    BRIDGE, "controller"));
         newControllers.stream().map(c -> {
             Controller controller = (Controller) TableGenerator
                     .createTable(dbSchema, OvsdbTable.CONTROLLER);
             controller.setTarget(c.target());
             return controller;
         }).forEach(c -> {
-            String uuid = insertConfig(OvsdbConstant.CONTROLLER, "_uuid",
-                                       OvsdbConstant.BRIDGE, "controller", bridgeUuid.value(),
+            String uuid = insertConfig(CONTROLLER, UUID, BRIDGE, "controller", bridgeUuid.value(),
                                        c.getRow());
             newControllerUuids.add(Uuid.uuid(uuid));
 
         });
 
-        OvsdbRowStore rowStore = getRowStore(OvsdbConstant.DATABASENAME,
-                                             OvsdbConstant.BRIDGE);
+        OvsdbRowStore rowStore = getRowStore(DATABASENAME, BRIDGE);
         if (rowStore == null) {
             log.debug("There is no bridge table");
             return;
@@ -695,7 +540,7 @@
         Row bridgeRow = rowStore.getRow(bridgeUuid.value());
         Bridge bridge = (Bridge) TableGenerator.getTable(dbSchema, bridgeRow, OvsdbTable.BRIDGE);
         bridge.setController(OvsdbSet.ovsdbSet(newControllerUuids));
-        updateConfig(OvsdbConstant.BRIDGE, "_uuid", bridgeUuid.value(), bridge.getRow());
+        updateConfig(BRIDGE, UUID, bridgeUuid.value(), bridge.getRow());
     }
 
     @Override
@@ -710,13 +555,11 @@
             log.warn("Could not find bridge in node", nodeId.getIpAddress());
             return;
         }
-        deleteConfig(OvsdbConstant.BRIDGE, "_uuid", bridgeUuid,
-                     OvsdbConstant.DATABASENAME, "bridges");
+        deleteConfig(BRIDGE, UUID, bridgeUuid, DATABASENAME, "bridges");
     }
 
     @Override
     public boolean createTunnel(String bridgeName, String portName, String tunnelType, Map<String, String> options) {
-
         String bridgeUuid  = getBridgeUuid(bridgeName);
         if (bridgeUuid == null) {
             log.warn("Couldn't find bridge {} in {}", bridgeName, nodeId.getIpAddress());
@@ -730,7 +573,7 @@
         }
 
         ArrayList<Operation> operations = Lists.newArrayList();
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
 
         // insert a new port to the port table
         Port port = (Port) TableGenerator.createTable(dbSchema, OvsdbTable.PORT);
@@ -740,8 +583,8 @@
         operations.add(portInsert);
 
         // update the bridge table
-        Condition condition = ConditionUtil.isEqual("_uuid", Uuid.uuid(bridgeUuid));
-        Mutation mutation = MutationUtil.insert("ports", Uuid.uuid("Port"));
+        Condition condition = ConditionUtil.isEqual(UUID, Uuid.uuid(bridgeUuid));
+        Mutation mutation = MutationUtil.insert(PORTS, Uuid.uuid("Port"));
         List<Condition> conditions = new ArrayList<>(Arrays.asList(condition));
         List<Mutation> mutations = new ArrayList<>(Arrays.asList(mutation));
         operations.add(new Mutate(dbSchema.getTableSchema("Bridge"), conditions, mutations));
@@ -754,15 +597,15 @@
         Insert intfInsert = new Insert(dbSchema.getTableSchema("Interface"), "Interface", intf.getRow());
         operations.add(intfInsert);
 
-        transactConfig(OvsdbConstant.DATABASENAME, operations);
+        transactConfig(DATABASENAME, operations);
         return true;
     }
 
     @Override
     public void dropTunnel(IpAddress srcIp, IpAddress dstIp) {
-        String bridgeName = OvsdbConstant.INTEGRATION_BRIDGE;
-        String portName = getTunnelName(OvsdbConstant.TYPEVXLAN, dstIp);
-        String bridgeUuid = getBridgeUuid(OvsdbConstant.INTEGRATION_BRIDGE);
+        String bridgeName = INTEGRATION_BRIDGE;
+        String portName = getTunnelName(TYPEVXLAN, dstIp);
+        String bridgeUuid = getBridgeUuid(INTEGRATION_BRIDGE);
         if (bridgeUuid == null) {
             log.warn("Could not find bridge {} in {}", bridgeName,
                      nodeId.getIpAddress());
@@ -772,11 +615,8 @@
         String portUuid = getPortUuid(portName, bridgeUuid);
         if (portUuid != null) {
             log.info("Delete tunnel");
-            deleteConfig(OvsdbConstant.PORT, "_uuid", portUuid,
-                         OvsdbConstant.BRIDGE, "ports");
+            deleteConfig(PORT, UUID, portUuid, BRIDGE, PORTS);
         }
-
-        return;
     }
 
     /**
@@ -791,7 +631,7 @@
     private void deleteConfig(String childTableName, String childColumnName,
                               String childUuid, String parentTableName,
                               String parentColumnName) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
         TableSchema childTableSchema = dbSchema.getTableSchema(childTableName);
 
         ArrayList<Operation> operations = Lists.newArrayList();
@@ -817,9 +657,7 @@
         conditions.add(condition);
         Delete del = new Delete(childTableSchema, conditions);
         operations.add(del);
-        transactConfig(OvsdbConstant.DATABASENAME, operations);
-
-        return;
+        transactConfig(DATABASENAME, operations);
     }
 
     /**
@@ -832,7 +670,7 @@
      */
     private void updateConfig(String tableName, String columnName, String uuid,
                               Row row) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
         TableSchema tableSchema = dbSchema.getTableSchema(tableName);
 
         List<Condition> conditions = Lists.newArrayList();
@@ -844,7 +682,7 @@
         ArrayList<Operation> operations = Lists.newArrayList();
         operations.add(update);
 
-        transactConfig(OvsdbConstant.DATABASENAME, operations);
+        transactConfig(DATABASENAME, operations);
     }
 
     /**
@@ -861,7 +699,7 @@
     private String insertConfig(String childTableName, String childColumnName,
                                 String parentTableName, String parentColumnName,
                                 String parentUuid, Row row) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
         TableSchema tableSchema = dbSchema.getTableSchema(childTableName);
 
         Insert insert = new Insert(tableSchema, childTableName, row);
@@ -881,32 +719,27 @@
             mutations.add(mutation);
 
             List<Condition> conditions = Lists.newArrayList();
-            Condition condition = ConditionUtil.isEqual("_uuid",
-                                                       Uuid.uuid(parentUuid));
+            Condition condition = ConditionUtil.isEqual(UUID, Uuid.uuid(parentUuid));
             conditions.add(condition);
 
             Mutate op = new Mutate(parentTableSchema, conditions, mutations);
             operations.add(op);
         }
-        if (childTableName.equalsIgnoreCase(OvsdbConstant.PORT)) {
-            log.info("Handle port insert");
-            Insert intfInsert = handlePortInsertTable(OvsdbConstant.INTERFACE,
-                                                      row);
+        if (childTableName.equalsIgnoreCase(PORT)) {
+            log.debug("Handle port insert");
+            Insert intfInsert = handlePortInsertTable(INTERFACE, row);
 
             if (intfInsert != null) {
                 operations.add(intfInsert);
             }
 
             Insert ins = (Insert) operations.get(0);
-            ins.getRow().put("interfaces",
-                             Uuid.uuid(OvsdbConstant.INTERFACE));
+            ins.getRow().put("interfaces", Uuid.uuid(INTERFACE));
         }
 
         List<OperationResult> results;
         try {
-            results = transactConfig(OvsdbConstant.DATABASENAME, operations)
-                    .get();
-
+            results = transactConfig(DATABASENAME, operations).get();
             return results.get(0).getUuid().value();
         } catch (InterruptedException e) {
             log.warn("Interrupted while waiting to get result");
@@ -926,30 +759,23 @@
      * @return insert, empty if null
      */
     private Insert handlePortInsertTable(String tableName, Row portRow) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
 
-        TableSchema portTableSchema = dbSchema
-                .getTableSchema(OvsdbConstant.PORT);
+        TableSchema portTableSchema = dbSchema.getTableSchema(PORT);
         ColumnSchema portColumnSchema = portTableSchema.getColumnSchema("name");
 
         String portName = (String) portRow.getColumn(portColumnSchema.name()).data();
-
-        Interface inf = (Interface) TableGenerator
-                .createTable(dbSchema, OvsdbTable.INTERFACE);
-
+        Interface inf = (Interface) TableGenerator.createTable(dbSchema, OvsdbTable.INTERFACE);
         inf.setName(portName);
 
-        TableSchema intfTableSchema = dbSchema
-                .getTableSchema(OvsdbConstant.INTERFACE);
-        Insert insert = new Insert(intfTableSchema, OvsdbConstant.INTERFACE,
-                                   inf.getRow());
-        return insert;
+        TableSchema intfTableSchema = dbSchema.getTableSchema(INTERFACE);
+        return new Insert(intfTableSchema, INTERFACE, inf.getRow());
     }
 
     /**
      * Gets tunnel name.
      *
-     * @param tunnelType
+     * @param tunnelType tunnel type
      * @param dstIp      the remote ip address
      * @return tunnel name
      */
@@ -966,20 +792,15 @@
         if (databaseSchema == null) {
             List<String> dbNames = new ArrayList<String>();
             dbNames.add(dbName);
-            Function<JsonNode, DatabaseSchema> rowFunction = new Function<JsonNode, DatabaseSchema>() {
-                @Override
-                public DatabaseSchema apply(JsonNode input) {
-                    log.info("Get ovsdb database schema {}", dbName);
-                    DatabaseSchema dbSchema = FromJsonUtil
-                            .jsonNodeToDbSchema(dbName, input);
-                    if (dbSchema == null) {
-                        log.debug("Get ovsdb database schema error");
-                        return null;
-                    }
-                    schema.put(dbName, dbSchema);
-
-                    return dbSchema;
+            Function<JsonNode, DatabaseSchema> rowFunction = input -> {
+                log.debug("Get ovsdb database schema {}", dbName);
+                DatabaseSchema dbSchema = FromJsonUtil.jsonNodeToDbSchema(dbName, input);
+                if (dbSchema == null) {
+                    log.debug("Get ovsdb database schema error");
+                    return null;
                 }
+                schema.put(dbName, dbSchema);
+                return dbSchema;
             };
 
             ListenableFuture<JsonNode> input = getSchema(dbNames);
@@ -999,18 +820,14 @@
         }
         DatabaseSchema dbSchema = schema.get(dbName);
         if (dbSchema != null) {
-            Function<JsonNode, TableUpdates> rowFunction = new Function<JsonNode, TableUpdates>() {
-                @Override
-                public TableUpdates apply(JsonNode input) {
-                    log.info("Get table updates");
-                    TableUpdates updates = FromJsonUtil
-                            .jsonNodeToTableUpdates(input, dbSchema);
-                    if (updates == null) {
-                        log.debug("Get table updates error");
-                        return null;
-                    }
-                    return updates;
+            Function<JsonNode, TableUpdates> rowFunction = input -> {
+                log.debug("Get table updates");
+                TableUpdates updates = FromJsonUtil.jsonNodeToTableUpdates(input, dbSchema);
+                if (updates == null) {
+                    log.debug("Get table updates error");
+                    return null;
                 }
+                return updates;
             };
             return Futures.transform(monitor(dbSchema, id), rowFunction);
         }
@@ -1026,18 +843,15 @@
         DatabaseSchema dbSchema = schema.get(dbName);
         if (dbSchema != null) {
             Function<List<JsonNode>, List<OperationResult>> rowFunction = (input -> {
-                log.info("Get ovsdb operation result");
-                List<OperationResult> result = FromJsonUtil
-                        .jsonNodeToOperationResult(input, operations);
-
+                log.debug("Get ovsdb operation result");
+                List<OperationResult> result = FromJsonUtil.jsonNodeToOperationResult(input, operations);
                 if (result == null) {
                     log.debug("The operation result is null");
                     return null;
                 }
                 return result;
             });
-            return Futures.transform(transact(dbSchema, operations),
-                                     rowFunction);
+            return Futures.transform(transact(dbSchema, operations), rowFunction);
         }
         return null;
     }
@@ -1053,7 +867,6 @@
 
         channel.writeAndFlush(getSchemaString);
         return sf;
-
     }
 
     @Override
@@ -1067,7 +880,6 @@
 
         channel.writeAndFlush(echoString);
         return sf;
-
     }
 
     @Override
@@ -1083,7 +895,6 @@
 
         channel.writeAndFlush(monitorString);
         return sf;
-
     }
 
     @Override
@@ -1097,7 +908,6 @@
 
         channel.writeAndFlush(listDbsString);
         return sf;
-
     }
 
     @Override
@@ -1113,7 +923,6 @@
 
         channel.writeAndFlush(transactString);
         return sf;
-
     }
 
     @SuppressWarnings({"rawtypes", "unchecked"})
@@ -1127,12 +936,7 @@
             return;
         }
         String methodName = requestMethod.get(requestId);
-
-        Object result;
-        result = FromJsonUtil.jsonResultParser(response, methodName);
-
-        sf.set(result);
-        return;
+        sf.set(FromJsonUtil.jsonResultParser(response, methodName));
     }
 
     @Override
@@ -1143,12 +947,8 @@
 
             String replyString = FromJsonUtil.getEchoRequestStr(requestJson);
             channel.writeAndFlush(replyString);
-
-            return;
         } else {
-            FromJsonUtil
-                    .jsonCallbackRequestParser(requestJson, monitorCallBack);
-            return;
+            FromJsonUtil.jsonCallbackRequestParser(requestJson, monitorCallBack);
         }
     }
 
@@ -1164,19 +964,18 @@
 
     @Override
     public Set<OvsdbBridge> getBridges() {
-        Set<OvsdbBridge> ovsdbBridges = new HashSet<OvsdbBridge>();
-        OvsdbTableStore tableStore = getTableStore(OvsdbConstant.DATABASENAME);
+        Set<OvsdbBridge> ovsdbBridges = new HashSet<>();
+        OvsdbTableStore tableStore = getTableStore(DATABASENAME);
         if (tableStore == null) {
             return null;
         }
-        OvsdbRowStore rowStore = tableStore.getRows(OvsdbConstant.BRIDGE);
+        OvsdbRowStore rowStore = tableStore.getRows(BRIDGE);
         if (rowStore == null) {
             return null;
         }
         ConcurrentMap<String, Row> rows = rowStore.getRowStore();
         for (String uuid : rows.keySet()) {
-            Row row = getRow(OvsdbConstant.DATABASENAME, OvsdbConstant.BRIDGE,
-                             uuid);
+            Row row = getRow(DATABASENAME, BRIDGE, uuid);
             OvsdbBridge ovsdbBridge = getOvsdbBridge(row);
             if (ovsdbBridge != null) {
                 ovsdbBridges.add(ovsdbBridge);
@@ -1197,19 +996,17 @@
             log.warn("bad list of controllers");
             return null;
         }
-        return controllers.stream().
-                map(controller -> new ControllerInfo(
-                        (String) controller.getTargetColumn()
-                                .data())).collect(Collectors.toSet());
+        return controllers.stream().map(controller -> new ControllerInfo(
+                (String) controller.getTargetColumn()
+                        .data())).collect(Collectors.toSet());
     }
 
     private List<Controller> getControllers(Uuid bridgeUuid) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
         if (dbSchema == null) {
             return null;
         }
-        OvsdbRowStore rowStore = getRowStore(OvsdbConstant.DATABASENAME,
-                                             OvsdbConstant.BRIDGE);
+        OvsdbRowStore rowStore = getRowStore(DATABASENAME, BRIDGE);
         if (rowStore == null) {
             log.debug("There is no bridge table");
             return null;
@@ -1224,10 +1021,8 @@
                 .data().getClass());
         Set<Uuid> controllerUuids = (Set<Uuid>) ((OvsdbSet) bridge
                 .getControllerColumn().data()).set();
-//        Set<String> controllerUuidStrings = (Set<String>) bridge.getControllerColumn().data();
 
-        OvsdbRowStore controllerRowStore = getRowStore(OvsdbConstant.DATABASENAME,
-                                                       OvsdbConstant.CONTROLLER);
+        OvsdbRowStore controllerRowStore = getRowStore(DATABASENAME, CONTROLLER);
         if (controllerRowStore == null) {
             log.debug("There is no controller table");
             return null;
@@ -1248,12 +1043,11 @@
 
 
     private Uuid getBridgeUuid(DeviceId openflowDeviceId) {
-        DatabaseSchema dbSchema = schema.get(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = schema.get(DATABASENAME);
         if (dbSchema == null) {
             return null;
         }
-        OvsdbRowStore rowStore = getRowStore(OvsdbConstant.DATABASENAME,
-                                             OvsdbConstant.BRIDGE);
+        OvsdbRowStore rowStore = getRowStore(DATABASENAME, BRIDGE);
         if (rowStore == null) {
             log.debug("There is no bridge table");
             return null;
@@ -1262,10 +1056,12 @@
         ConcurrentMap<String, Row> bridgeTableRows = rowStore.getRowStore();
         final AtomicReference<Uuid> uuid = new AtomicReference<>();
         for (Map.Entry<String, Row> entry : bridgeTableRows.entrySet()) {
-            Bridge b = (Bridge) TableGenerator.getTable(dbSchema,
-                                                        entry.getValue(),
-                                                        OvsdbTable.BRIDGE);
-            if (matchesDpid(b, openflowDeviceId)) {
+            Bridge bridge = (Bridge) TableGenerator.getTable(
+                    dbSchema,
+                    entry.getValue(),
+                    OvsdbTable.BRIDGE);
+
+            if (matchesDpid(bridge, openflowDeviceId)) {
                 uuid.set(Uuid.uuid(entry.getKey()));
                 break;
             }
@@ -1274,7 +1070,6 @@
             log.debug("There is no bridge for {}", openflowDeviceId);
         }
         return uuid.get();
-
     }
 
     private static boolean matchesDpid(Bridge b, DeviceId deviceId) {
@@ -1286,19 +1081,18 @@
 
     @Override
     public Set<OvsdbPort> getPorts() {
-        Set<OvsdbPort> ovsdbPorts = new HashSet<OvsdbPort>();
-        OvsdbTableStore tableStore = getTableStore(OvsdbConstant.DATABASENAME);
+        Set<OvsdbPort> ovsdbPorts = new HashSet<>();
+        OvsdbTableStore tableStore = getTableStore(DATABASENAME);
         if (tableStore == null) {
             return null;
         }
-        OvsdbRowStore rowStore = tableStore.getRows(OvsdbConstant.INTERFACE);
+        OvsdbRowStore rowStore = tableStore.getRows(INTERFACE);
         if (rowStore == null) {
             return null;
         }
         ConcurrentMap<String, Row> rows = rowStore.getRowStore();
         for (String uuid : rows.keySet()) {
-            Row row = getRow(OvsdbConstant.DATABASENAME,
-                             OvsdbConstant.INTERFACE, uuid);
+            Row row = getRow(DATABASENAME, INTERFACE, uuid);
             OvsdbPort ovsdbPort = getOvsdbPort(row);
             if (ovsdbPort != null) {
                 ovsdbPorts.add(ovsdbPort);
@@ -1312,9 +1106,8 @@
         return schema.get(dbName);
     }
 
-    //Gets ovsdb port.
     private OvsdbPort getOvsdbPort(Row row) {
-        DatabaseSchema dbSchema = getDatabaseSchema(OvsdbConstant.DATABASENAME);
+        DatabaseSchema dbSchema = getDatabaseSchema(DATABASENAME);
         Interface intf = (Interface) TableGenerator
                 .getTable(dbSchema, row, OvsdbTable.INTERFACE);
         if (intf == null) {
@@ -1325,17 +1118,12 @@
         if ((ofPort < 0) || (portName == null)) {
             return null;
         }
-
-        OvsdbPort ovsdbPort = new OvsdbPort(new OvsdbPortNumber(ofPort),
-                                            new OvsdbPortName(portName));
-        return ovsdbPort;
+        return new OvsdbPort(new OvsdbPortNumber(ofPort), new OvsdbPortName(portName));
     }
 
-    ////Gets ovsdb bridge.
     private OvsdbBridge getOvsdbBridge(Row row) {
-        DatabaseSchema dbSchema = getDatabaseSchema(OvsdbConstant.DATABASENAME);
-        Bridge bridge = (Bridge) TableGenerator.getTable(dbSchema, row,
-                                                         OvsdbTable.BRIDGE);
+        DatabaseSchema dbSchema = getDatabaseSchema(DATABASENAME);
+        Bridge bridge = (Bridge) TableGenerator.getTable(dbSchema, row, OvsdbTable.BRIDGE);
         if (bridge == null) {
             return null;
         }
@@ -1351,18 +1139,14 @@
         if ((datapathId == null) || (bridgeName == null)) {
             return null;
         }
-
-        OvsdbBridge ovsdbBridge = new OvsdbBridge(new OvsdbBridgeName(bridgeName),
-                                                  new OvsdbDatapathId(datapathId));
-        return ovsdbBridge;
+        return OvsdbBridge.builder().name(bridgeName).datapathId(datapathId).build();
     }
 
-    //Gets ofPort in the interface.
     private long getOfPort(Interface intf) {
         OvsdbSet ofPortSet = (OvsdbSet) intf.getOpenFlowPortColumn().data();
         @SuppressWarnings("unchecked")
         Set<Integer> ofPorts = ofPortSet.set();
-        while (ofPorts == null || ofPorts.size() <= 0) {
+        if (ofPorts == null || ofPorts.size() <= 0) {
             log.debug("The ofport is null in {}", intf.getName());
             return -1;
         }
@@ -1373,41 +1157,38 @@
 
     @Override
     public Set<OvsdbPort> getLocalPorts(Iterable<String> ifaceids) {
-        Set<OvsdbPort> ovsdbPorts = new HashSet<OvsdbPort>();
-        OvsdbTableStore tableStore = getTableStore(OvsdbConstant.DATABASENAME);
+        Set<OvsdbPort> ovsdbPorts = new HashSet<>();
+        OvsdbTableStore tableStore = getTableStore(DATABASENAME);
         if (tableStore == null) {
             return null;
         }
-        OvsdbRowStore rowStore = tableStore.getRows(OvsdbConstant.INTERFACE);
+        OvsdbRowStore rowStore = tableStore.getRows(INTERFACE);
         if (rowStore == null) {
             return null;
         }
         ConcurrentMap<String, Row> rows = rowStore.getRowStore();
         for (String uuid : rows.keySet()) {
-            Row row = getRow(OvsdbConstant.DATABASENAME,
-                             OvsdbConstant.INTERFACE, uuid);
-            DatabaseSchema dbSchema = getDatabaseSchema(OvsdbConstant.DATABASENAME);
+            Row row = getRow(DATABASENAME, INTERFACE, uuid);
+            DatabaseSchema dbSchema = getDatabaseSchema(DATABASENAME);
             Interface intf = (Interface) TableGenerator
                     .getTable(dbSchema, row, OvsdbTable.INTERFACE);
             if (intf == null || getIfaceid(intf) == null) {
                 continue;
             }
             String portName = intf.getName();
+            if (portName == null) {
+                continue;
+            }
             Set<String> ifaceidSet = Sets.newHashSet(ifaceids);
-            if (portName.startsWith("vxlan")
-                    || !ifaceidSet.contains(getIfaceid(intf))) {
+            if (portName.startsWith(TYPEVXLAN) || !ifaceidSet.contains(getIfaceid(intf))) {
                 continue;
             }
             long ofPort = getOfPort(intf);
-            if ((ofPort < 0) || (portName == null)) {
+            if (ofPort < 0) {
                 continue;
             }
-
-            OvsdbPort ovsdbPort = new OvsdbPort(new OvsdbPortNumber(ofPort),
-                                                new OvsdbPortName(portName));
-            if (ovsdbPort != null) {
-                ovsdbPorts.add(ovsdbPort);
-            }
+            ovsdbPorts.add(new OvsdbPort(new OvsdbPortNumber(ofPort),
+                                         new OvsdbPortName(portName)));
         }
         return ovsdbPorts;
     }
@@ -1420,8 +1201,7 @@
             log.warn("The external_ids is null");
             return null;
         }
-        String ifaceid = externalIds
-                .get(OvsdbConstant.EXTERNAL_ID_INTERFACE_ID);
+        String ifaceid = externalIds.get(EXTERNAL_ID_INTERFACE_ID);
         if (ifaceid == null) {
             log.warn("The ifaceid is null");
             return null;
diff --git a/protocols/ovsdb/api/src/test/java/org/onosproject/ovsdb/controller/driver/OvsdbClientServiceAdapter.java b/protocols/ovsdb/api/src/test/java/org/onosproject/ovsdb/controller/driver/OvsdbClientServiceAdapter.java
index a1f719c..c0aaf91 100644
--- a/protocols/ovsdb/api/src/test/java/org/onosproject/ovsdb/controller/driver/OvsdbClientServiceAdapter.java
+++ b/protocols/ovsdb/api/src/test/java/org/onosproject/ovsdb/controller/driver/OvsdbClientServiceAdapter.java
@@ -74,6 +74,11 @@
     }
 
     @Override
+    public boolean createBridge(OvsdbBridge ovsdbBridge) {
+        return true;
+    }
+
+    @Override
     public void dropBridge(String bridgeName) {
 
     }
@@ -89,6 +94,11 @@
     }
 
     @Override
+    public ControllerInfo localController() {
+        return null;
+    }
+
+    @Override
     public void setControllersWithUuid(Uuid bridgeUuid, List<ControllerInfo> controllers) {
 
     }