onos commit hash c2999f30c69e50df905a9d175ef80b3f23a98514

Change-Id: I2bb8562c4942b6d6a6d60b663db2e17540477b81
Signed-off-by: Ashlee Young <ashlee@wildernessvoice.com>

84 files changed, 7247 insertions, 59 deletions

diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/DefaultFloatingIp.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/DefaultFloatingIp.java
new file mode 100644
index 00000000..7a297d90
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/DefaultFloatingIp.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Objects;
+
+import org.onlab.packet.IpAddress;
+
+/**
+ * Default implementation of FloatingIp interface.
+ */
+public final class DefaultFloatingIp implements FloatingIp {
+
+    private final FloatingIpId id;
+    private final TenantId tenantId;
+    private final TenantNetworkId networkId;
+    private final VirtualPortId portId;
+    private final RouterId routerId;
+    private final IpAddress floatingIp;
+    private final IpAddress fixedIp;
+    private final Status status;
+
+    /**
+     *
+     * Creates a floating Ip object.
+     *
+     * @param id  floatingIp identifier
+     * @param tenantId  tenant identifier
+     * @param networkId  the identifier of network associated with the floating Ip
+     * @param portId  port identifier
+     * @param routerId  router identifier
+     * @param floatingIp  floatingIp address
+     * @param fixedIp  the fixed Ip associated with the floating Ip
+     * @param status  the floating Ip status
+     */
+    public DefaultFloatingIp(FloatingIpId id, TenantId tenantId,
+                             TenantNetworkId networkId, VirtualPortId portId,
+                             RouterId routerId, IpAddress floatingIp,
+                             IpAddress fixedIp, Status status) {
+        this.id = checkNotNull(id, "id cannot be null");
+        this.tenantId = checkNotNull(tenantId, "tenantId cannot be null");
+        this.networkId = checkNotNull(networkId, "networkId cannot be null");
+        this.portId = portId;
+        this.routerId = routerId;
+        this.floatingIp = checkNotNull(floatingIp, "floatingIp cannot be null");
+        this.fixedIp = fixedIp;
+        this.status = checkNotNull(status, "status cannot be null");
+    }
+
+    @Override
+    public FloatingIpId id() {
+        return id;
+    }
+
+    @Override
+    public TenantId tenantId() {
+        return tenantId;
+    }
+
+    @Override
+    public TenantNetworkId networkId() {
+        return networkId;
+    }
+
+    @Override
+    public VirtualPortId portId() {
+        return portId;
+    }
+
+    @Override
+    public RouterId routerId() {
+        return routerId;
+    }
+
+    @Override
+    public IpAddress floatingIp() {
+        return floatingIp;
+    }
+
+    @Override
+    public IpAddress fixedIp() {
+        return fixedIp;
+    }
+
+    @Override
+    public Status status() {
+        return status;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, tenantId, networkId, portId, routerId,
+                            floatingIp, fixedIp, status);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof DefaultFloatingIp) {
+            final DefaultFloatingIp that = (DefaultFloatingIp) obj;
+            return Objects.equals(this.id, that.id)
+                    && Objects.equals(this.tenantId, that.tenantId)
+                    && Objects.equals(this.networkId, that.networkId)
+                    && Objects.equals(this.portId, that.portId)
+                    && Objects.equals(this.routerId, that.routerId)
+                    && Objects.equals(this.floatingIp, that.floatingIp)
+                    && Objects.equals(this.fixedIp, that.fixedIp)
+                    && Objects.equals(this.status, that.status);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this).add("id", id).add("tenantId", tenantId)
+                .add("networkId", networkId).add("portId", portId)
+                .add("routerId", routerId).add("floatingIp", floatingIp)
+                .add("fixedIp", fixedIp).add("floatingIpStatus", status)
+                .toString();
+    }
+
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/DefaultRouter.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/DefaultRouter.java
new file mode 100644
index 00000000..a2404f56
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/DefaultRouter.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Default implementation of router interface.
+ */
+public final class DefaultRouter implements Router {
+    private final RouterId id;
+    private final String name;
+    private final boolean adminStateUp;
+    private final Status status;
+    private final boolean distributed;
+    private final RouterGateway externalGatewayInfo;
+    private final VirtualPortId gatewayPortId;
+    private final TenantId tenantId;
+    private final List<String> routes;
+
+    /**
+     * Creates router object.
+     *
+     * @param id  router identifier
+     * @param routerName  the name of router
+     * @param adminStateUp  the status of admin state
+     * @param status  the status of router
+     * @param distributed  the status of router distributed
+     * @param externalGatewayInfo  the gateway info of router
+     * @param gatewayPortId  the port identifier of router gateway
+     * @param tenantId  the tenant identifier
+     * @param routes  the routes configure
+     */
+    public DefaultRouter(RouterId id, String routerName, boolean adminStateUp,
+                         Status status, boolean distributed,
+                         RouterGateway externalGatewayInfo,
+                         VirtualPortId gatewayPortId, TenantId tenantId,
+                         List<String> routes) {
+        this.id = checkNotNull(id, "id cannot be null");
+        this.name = routerName;
+        this.adminStateUp = checkNotNull(adminStateUp, "adminStateUp cannot be null");
+        this.status = checkNotNull(status, "status cannot be null");
+        this.distributed = checkNotNull(distributed, "distributed cannot be null");
+        this.externalGatewayInfo = externalGatewayInfo;
+        this.gatewayPortId = gatewayPortId;
+        this.tenantId = checkNotNull(tenantId, "tenantId cannot be null");
+        this.routes = routes;
+    }
+
+    @Override
+    public RouterId id() {
+        return id;
+    }
+
+    @Override
+    public String name() {
+        return name;
+    }
+
+    @Override
+    public boolean adminStateUp() {
+        return adminStateUp;
+    }
+
+    @Override
+    public Status status() {
+        return status;
+    }
+
+    @Override
+    public boolean distributed() {
+        return distributed;
+    }
+
+    @Override
+    public RouterGateway externalGatewayInfo() {
+        return externalGatewayInfo;
+    }
+
+    @Override
+    public VirtualPortId gatewayPortid() {
+        return gatewayPortId;
+    }
+
+    @Override
+    public TenantId tenantId() {
+        return tenantId;
+    }
+
+    @Override
+    public List<String> routes() {
+        return routes;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name, adminStateUp, status, distributed,
+                            externalGatewayInfo, gatewayPortId, routes);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof DefaultRouter) {
+            final DefaultRouter that = (DefaultRouter) obj;
+            return Objects.equals(this.id, that.id)
+                    && Objects.equals(this.name, that.name)
+                    && Objects.equals(this.adminStateUp, that.adminStateUp)
+                    && Objects.equals(this.status, that.status)
+                    && Objects.equals(this.distributed, that.distributed)
+                    && Objects.equals(this.externalGatewayInfo,
+                                      that.externalGatewayInfo)
+                    && Objects.equals(this.gatewayPortId, that.gatewayPortId)
+                    && Objects.equals(this.routes, that.routes);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this).add("id", id).add("routerName", name)
+                .add("adminStateUp", adminStateUp).add("status", status)
+                .add("distributed", distributed)
+                .add("externalGatewayInfo", externalGatewayInfo)
+                .add("gatewayPortid", gatewayPortId).add("routes", routes).toString();
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/FloatingIp.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/FloatingIp.java
new file mode 100644
index 00000000..0933d9ef
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/FloatingIp.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.onlab.packet.IpAddress;
+
+/**
+ * Representation of a floatingIp.
+ */
+public interface FloatingIp {
+
+    /**
+     * Coarse classification of the type of the FloatingIp.
+     */
+    public enum Status {
+        /**
+         * Signifies that a floating Ip is currently active.
+         */
+        ACTIVE,
+        /**
+         * Signifies that a floating Ip is currently inactive.
+         */
+        INACTIVE
+    }
+
+    /**
+     * Returns the floatingIp identifier.
+     *
+     * @return identifier
+     */
+    FloatingIpId id();
+
+    /**
+     * Returns the tenant identifier.
+     *
+     * @return the tenant identifier
+     */
+    TenantId tenantId();
+
+    /**
+     * Returns the network identifier.
+     *
+     * @return the network identifier
+     */
+    TenantNetworkId networkId();
+
+    /**
+     * Returns the port identifier.
+     *
+     * @return the port identifier
+     */
+    VirtualPortId portId();
+
+    /**
+     * Returns the router identifier.
+     *
+     * @return the router identifier
+     */
+    RouterId routerId();
+
+    /**
+     * Returns the floating ip address.
+     *
+     * @return floatingIp
+     */
+    IpAddress floatingIp();
+
+    /**
+     * Returns the fixed ip address.
+     *
+     * @return fixedIp
+     */
+    IpAddress fixedIp();
+
+    /**
+     * Returns the status of floating ip.
+     *
+     * @return floatingIpStatus
+     */
+    Status status();
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/FloatingIpId.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/FloatingIpId.java
new file mode 100644
index 00000000..1b48c7d6
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/FloatingIpId.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Objects;
+import java.util.UUID;
+
+/**
+ * Immutable representation of a floating IP identifier.
+ */
+public final class FloatingIpId {
+    private final UUID floatingIpId;
+
+    // Public construction is prohibited
+    private FloatingIpId(UUID floatingIpId) {
+        this.floatingIpId = checkNotNull(floatingIpId, "floatingIpId cannot be null");
+    }
+
+    /**
+     * Creates a floating IP identifier.
+     *
+     * @param floatingIpId the UUID id of floating IP identifier
+     * @return object of floating IP identifier
+     */
+    public static FloatingIpId of(UUID floatingIpId) {
+        return new FloatingIpId(floatingIpId);
+    }
+
+    /**
+     * Creates a floating IP identifier.
+     *
+     * @param floatingIpId the floating IP identifier in string
+     * @return object of floating IP identifier
+     */
+    public static FloatingIpId of(String floatingIpId) {
+        return new FloatingIpId(UUID.fromString(floatingIpId));
+    }
+
+    /**
+     * Returns the floating IP identifier.
+     *
+     * @return the floating IP identifier
+     */
+    public UUID floatingIpId() {
+        return floatingIpId;
+    }
+
+    @Override
+    public int hashCode() {
+        return floatingIpId.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof FloatingIpId) {
+            final FloatingIpId that = (FloatingIpId) obj;
+            return Objects.equals(this.floatingIpId, that.floatingIpId);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this).add("floatingIpId", floatingIpId).toString();
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/RouterInterface.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/RouterInterface.java
new file mode 100644
index 00000000..5c37c30b
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/RouterInterface.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Objects;
+
+/**
+ * Representation of a Router interface.
+ */
+public final class RouterInterface {
+    private final SubnetId subnetId;
+    private final VirtualPortId portId;
+    private final RouterId routerId;
+    private final TenantId tenantId;
+
+    // Public construction is prohibited
+    private RouterInterface(SubnetId subnetId, VirtualPortId portId,
+                            RouterId routerId, TenantId tenantId) {
+        this.subnetId = checkNotNull(subnetId, "subnetId cannot be null");
+        this.portId = checkNotNull(portId, "portId cannot be null");
+        this.routerId = checkNotNull(routerId, "routerId cannot be null");
+        this.tenantId = checkNotNull(tenantId, "tenantId cannot be null");
+    }
+
+    /**
+     * Creates router interface object.
+     *
+     * @param subnetId subnet identifier
+     * @param portId port identifier
+     * @param routerId router identifier
+     * @param tenantId tenant identifier
+     * @return RouterInterface
+     */
+    public static RouterInterface routerInterface(SubnetId subnetId,
+                                                  VirtualPortId portId,
+                                                  RouterId routerId,
+                                                  TenantId tenantId) {
+        return new RouterInterface(subnetId, portId, routerId, tenantId);
+    }
+
+    /**
+     * Returns subnet identifier.
+     *
+     * @return subnetId the subnet identifier
+     */
+    public SubnetId subnetId() {
+        return subnetId;
+    }
+
+    /**
+     * Returns port identifier.
+     *
+     * @return portId the port identifier
+     */
+    public VirtualPortId portId() {
+        return portId;
+    }
+
+    /**
+     * Returns router identifier.
+     *
+     * @return routerId the router identifier
+     */
+    public RouterId routerId() {
+        return routerId;
+    }
+
+    /**
+     * Returns tenant identifier.
+     *
+     * @return tenantId the tenant identifier
+     */
+    public TenantId tenantId() {
+        return tenantId;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(subnetId, portId, routerId, tenantId);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof RouterInterface) {
+            final RouterInterface that = (RouterInterface) obj;
+            return Objects.equals(this.subnetId, that.subnetId)
+                    && Objects.equals(this.portId, that.portId)
+                    && Objects.equals(this.routerId, that.routerId)
+                    && Objects.equals(this.tenantId, that.tenantId);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this).add("subnetId", subnetId)
+                .add("portId", portId).add("routerId", routerId)
+                .add("tenantId", tenantId).toString();
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpCreateCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpCreateCommand.java
new file mode 100644
index 00000000..00758dd2
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpCreateCommand.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.floatingip;
+
+import java.util.Set;
+
+import org.apache.karaf.shell.commands.Argument;
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onlab.packet.IpAddress;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.DefaultFloatingIp;
+import org.onosproject.vtnrsc.FloatingIpId;
+import org.onosproject.vtnrsc.FloatingIp;
+import org.onosproject.vtnrsc.FloatingIp.Status;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.TenantNetworkId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.floatingip.FloatingIpService;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Supports for create a floating IP.
+ */
+@Command(scope = "onos", name = "floatingip-create",
+        description = "Supports for creating a floating IP")
+public class FloatingIpCreateCommand extends AbstractShellCommand {
+    @Argument(index = 0, name = "id", description = "The floating IP identifier",
+            required = true, multiValued = false)
+    String id = null;
+
+    @Argument(index = 1, name = "networkId", description = "The network identifier of floating IP",
+            required = true, multiValued = false)
+    String networkId = null;
+
+    @Argument(index = 2, name = "tenantId", description = "The tenant identifier of floating IP",
+            required = true, multiValued = false)
+    String tenantId = null;
+
+    @Argument(index = 3, name = "routerId", description = "The router identifier of floating IP",
+            required = true, multiValued = false)
+    String routerId = null;
+
+    @Argument(index = 4, name = "fixedIp", description = "The fixed IP of floating IP",
+            required = true, multiValued = false)
+    String fixedIp = null;
+
+    @Argument(index = 5, name = "floatingIp", description = "The floating IP of floating IP",
+            required = true, multiValued = false)
+    String floatingIp = null;
+
+    @Option(name = "-p", aliases = "--portId", description = "The port identifier of floating IP",
+            required = false, multiValued = false)
+    String portId = null;
+
+    @Option(name = "-s", aliases = "--status", description = "The status of floating IP",
+            required = false, multiValued = false)
+    String status = null;
+
+    @Override
+    protected void execute() {
+        FloatingIpService service = get(FloatingIpService.class);
+        try {
+            FloatingIp floatingIpObj = new DefaultFloatingIp(
+                                                          FloatingIpId.of(id),
+                                                          TenantId.tenantId(tenantId),
+                                                          TenantNetworkId.networkId(networkId),
+                                                          VirtualPortId.portId(portId),
+                                                          RouterId.valueOf(routerId),
+                                                          floatingIp == null ? null : IpAddress.valueOf(floatingIp),
+                                                          fixedIp == null ? null : IpAddress.valueOf(fixedIp),
+                                                          status == null ? Status.ACTIVE
+                                                                         : Status.valueOf(status));
+            Set<FloatingIp> floatingIpSet = Sets.newHashSet(floatingIpObj);
+            service.createFloatingIps(floatingIpSet);
+        } catch (Exception e) {
+            print(null, e.getMessage());
+        }
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpQueryCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpQueryCommand.java
new file mode 100644
index 00000000..c441d535
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpQueryCommand.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.floatingip;
+
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.FloatingIpId;
+import org.onosproject.vtnrsc.FloatingIp;
+import org.onosproject.vtnrsc.floatingip.FloatingIpService;
+
+/**
+ * Supports for query a floating IP.
+ */
+@Command(scope = "onos", name = "floatingips", description = "Supports for querying a floating IP")
+public class FloatingIpQueryCommand extends AbstractShellCommand {
+    @Option(name = "-I", aliases = "--id", description = "The floating IP identifier",
+            required = false, multiValued = false)
+    String id = null;
+
+    @Option(name = "-i", aliases = "--fixedIp", description = "The fixed IP of floating IP",
+            required = false, multiValued = false)
+    String fixedIp = null;
+
+    @Option(name = "-l", aliases = "--floatingIp", description = "The floating IP of floating IP",
+            required = false, multiValued = false)
+    String floatingIp = null;
+
+    private static final String FMT = "floatingIpId=%s, networkId=%s, tenantId=%s, portId=%s,"
+            + "routerId=%s, fixedIp=%s, floatingIp=%s, status=%s";
+
+    @Override
+    protected void execute() {
+        FloatingIpService service = get(FloatingIpService.class);
+        if (id != null) {
+            FloatingIp floatingIp = service.getFloatingIp(FloatingIpId
+                    .of(id));
+            printFloatingIp(floatingIp);
+        } else if (fixedIp != null || floatingIp != null) {
+            Iterable<FloatingIp> floatingIps = service.getFloatingIps();
+            if (floatingIps == null) {
+                return;
+            }
+            if (fixedIp != null) {
+                for (FloatingIp floatingIp : floatingIps) {
+                    if (floatingIp.fixedIp().toString().equals(fixedIp)) {
+                        printFloatingIp(floatingIp);
+                        return;
+                    }
+                }
+                print(null, "The fixedIp is not existed");
+            }
+            if (floatingIp != null) {
+                for (FloatingIp floatingIpObj : floatingIps) {
+                    if (floatingIpObj.fixedIp().toString().equals(floatingIp)) {
+                        printFloatingIp(floatingIpObj);
+                        return;
+                    }
+                }
+                print(null, "The floatingIp is not existed");
+            }
+        } else {
+            Iterable<FloatingIp> floatingIps = service.getFloatingIps();
+            if (floatingIps == null) {
+                return;
+            }
+            for (FloatingIp floatingIp : floatingIps) {
+                printFloatingIp(floatingIp);
+            }
+        }
+    }
+
+    private void printFloatingIp(FloatingIp floatingIp) {
+        print(FMT, floatingIp.id(), floatingIp.networkId(),
+              floatingIp.tenantId(), floatingIp.portId(),
+              floatingIp.routerId(), floatingIp.fixedIp(),
+              floatingIp.floatingIp(), floatingIp.status());
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpRemoveCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpRemoveCommand.java
new file mode 100644
index 00000000..a413503a
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpRemoveCommand.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.floatingip;
+
+import java.util.Set;
+
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.FloatingIp;
+import org.onosproject.vtnrsc.FloatingIpId;
+import org.onosproject.vtnrsc.floatingip.FloatingIpService;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Supports for remove a floating IP.
+ */
+@Command(scope = "onos", name = "floatingip-remove", description = "Supports for removing a floating IP")
+public class FloatingIpRemoveCommand extends AbstractShellCommand {
+    @Option(name = "-I", aliases = "--id", description = "The floating IP identifier",
+            required = false, multiValued = false)
+    String id = null;
+
+    @Option(name = "-i", aliases = "--fixedIp", description = "The fixed IP of floating IP",
+            required = false, multiValued = false)
+    String fixedIp = null;
+
+    @Option(name = "-l", aliases = "--floatingIp", description = "The floating IP of floating IP",
+            required = false, multiValued = false)
+    String floatingIp = null;
+
+    @Override
+    protected void execute() {
+        FloatingIpService service = get(FloatingIpService.class);
+        if (id == null && fixedIp == null && floatingIp == null) {
+            print(null, "one of id, fixedIp, floatingIp should not be null");
+        }
+        try {
+            Set<FloatingIpId> floatingIpSet = Sets.newHashSet();
+            if (id != null) {
+                floatingIpSet.add(FloatingIpId.of(id));
+                service.removeFloatingIps(floatingIpSet);
+            } else {
+                Iterable<FloatingIp> floatingIps = service.getFloatingIps();
+                if (floatingIps == null) {
+                    return;
+                }
+                if (fixedIp != null) {
+                    for (FloatingIp floatingIp : floatingIps) {
+                        if (floatingIp.fixedIp().toString().equals(fixedIp)) {
+                            floatingIpSet.add(floatingIp.id());
+                            service.removeFloatingIps(floatingIpSet);
+                            return;
+                        }
+                    }
+                    print(null, "The fixedIp is not existed");
+                    return;
+                }
+                if (floatingIp != null) {
+                    for (FloatingIp floatingIpObj : floatingIps) {
+                        if (floatingIpObj.fixedIp().toString()
+                                .equals(floatingIp)) {
+                            floatingIpSet.add(floatingIpObj.id());
+                            service.removeFloatingIps(floatingIpSet);
+                            return;
+                        }
+                    }
+                    print(null, "The floatingIp is not existed");
+                    return;
+                }
+            }
+        } catch (Exception e) {
+            print(null, e.getMessage());
+        }
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpUpdateCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpUpdateCommand.java
new file mode 100644
index 00000000..413b3bdb
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/FloatingIpUpdateCommand.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.floatingip;
+
+import java.util.Set;
+
+import org.apache.karaf.shell.commands.Argument;
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onlab.packet.IpAddress;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.DefaultFloatingIp;
+import org.onosproject.vtnrsc.FloatingIpId;
+import org.onosproject.vtnrsc.FloatingIp;
+import org.onosproject.vtnrsc.FloatingIp.Status;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.TenantNetworkId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.floatingip.FloatingIpService;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Supports for update a floating IP.
+ */
+@Command(scope = "onos", name = "floatingip-update",
+        description = "Supports for updating a floating IP")
+public class FloatingIpUpdateCommand extends AbstractShellCommand {
+    @Argument(index = 0, name = "id", description = "The floating IP identifier",
+            required = true, multiValued = false)
+    String id = null;
+
+    @Option(name = "-n", aliases = "--networkId", description = "The network identifier of floating IP",
+            required = false, multiValued = false)
+    String networkId = null;
+
+    @Option(name = "-t", aliases = "--tenantId", description = "The tenant identifier of floating IP",
+            required = false, multiValued = false)
+    String tenantId = null;
+
+    @Option(name = "-r", aliases = "--routerId", description = "The router identifier of floating IP",
+            required = false, multiValued = false)
+    String routerId = null;
+
+    @Option(name = "-p", aliases = "--portId", description = "The port identifier of floating IP",
+            required = false, multiValued = false)
+    String portId = null;
+
+    @Option(name = "-s", aliases = "--status", description = "The status of floating IP",
+            required = false, multiValued = false)
+    String status = null;
+
+    @Option(name = "-i", aliases = "--fixedIp", description = "The fixed IP of floating IP",
+            required = false, multiValued = false)
+    String fixedIp = null;
+
+    @Option(name = "-l", aliases = "--floatingIp", description = "The floating IP of floating IP",
+            required = false, multiValued = false)
+    String floatingIp = null;
+
+    @Override
+    protected void execute() {
+        FloatingIpService service = get(FloatingIpService.class);
+        FloatingIpId floatingIpId = FloatingIpId.of(id);
+        FloatingIp floatingIpStore = get(FloatingIpService.class).getFloatingIp(floatingIpId);
+        try {
+            FloatingIp floatingIpObj = new DefaultFloatingIp(
+                                                          floatingIpId,
+                                                          tenantId == null ? floatingIpStore.tenantId()
+                                                                           :  TenantId.tenantId(tenantId),
+                                                          networkId == null ? floatingIpStore.networkId()
+                                                                            : TenantNetworkId.networkId(networkId),
+                                                          portId == null ? floatingIpStore.portId()
+                                                                         : VirtualPortId.portId(portId),
+                                                          routerId == null ? floatingIpStore.routerId()
+                                                                           : RouterId.valueOf(routerId),
+                                                          floatingIp == null ? floatingIpStore.floatingIp()
+                                                                             : IpAddress.valueOf(floatingIp),
+                                                          fixedIp == null ? floatingIpStore.fixedIp()
+                                                                          : IpAddress.valueOf(fixedIp),
+                                                          status == null ? floatingIpStore.status()
+                                                                         : Status.valueOf(status));
+            Set<FloatingIp> floatingIpSet = Sets.newHashSet(floatingIpObj);
+            service.updateFloatingIps(floatingIpSet);
+        } catch (Exception e) {
+            print(null, e.getMessage());
+        }
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/package-info.java
new file mode 100644
index 00000000..ac560771
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/floatingip/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Command line interface for floatingIP.
+ */
+package org.onosproject.vtnrsc.cli.floatingip;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterCreateCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterCreateCommand.java
new file mode 100644
index 00000000..3a736deb
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterCreateCommand.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.router;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.karaf.shell.commands.Argument;
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.DefaultRouter;
+import org.onosproject.vtnrsc.Router;
+import org.onosproject.vtnrsc.Router.Status;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.router.RouterService;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Supports for create a router.
+ */
+@Command(scope = "onos", name = "router-create",
+        description = "Supports for creating a router")
+public class RouterCreateCommand extends AbstractShellCommand {
+    @Argument(index = 0, name = "id", description = "The router identifier",
+            required = true, multiValued = false)
+    String id = null;
+
+    @Argument(index = 1, name = "routerName", description = "The name of router",
+            required = true, multiValued = false)
+    String routerName = null;
+
+    @Argument(index = 2, name = "tenantId", description = "The tenant identifier of router",
+            required = true, multiValued = false)
+    String tenantId = null;
+
+    @Option(name = "-g", aliases = "--gatewayPortId", description = "The gatewayPort identifier of router",
+            required = false, multiValued = false)
+    String gatewayPortId = null;
+
+    @Option(name = "-e", aliases = "--externalGatewayInfo", description = "The external gateway info of router",
+            required = false, multiValued = false)
+    String externalGatewayInfo = null;
+
+    @Option(name = "-s", aliases = "--status", description = "The status of router",
+            required = false, multiValued = false)
+    String status = null;
+
+    @Option(name = "-a", aliases = "--adminStateUp", description = "The boolean adminStateUp of router",
+            required = false, multiValued = false)
+    boolean adminStateUp = true;
+
+    @Option(name = "-d", aliases = "--distributed", description = "The boolean distributed of router",
+            required = false, multiValued = false)
+    boolean distributed = false;
+
+    @Override
+    protected void execute() {
+        RouterService service = get(RouterService.class);
+        try {
+            List<String> routes = new ArrayList<String>();
+            Router router = new DefaultRouter(
+                                              RouterId.valueOf(id),
+                                              routerName,
+                                              adminStateUp,
+                                              status == null ? Status.ACTIVE
+                                                            : Status.valueOf(status),
+                                              distributed,
+                                              null,
+                                              VirtualPortId.portId(gatewayPortId),
+                                              TenantId.tenantId(tenantId),
+                                              routes);
+            Set<Router> routerSet = Sets.newHashSet(router);
+            service.createRouters(routerSet);
+        } catch (Exception e) {
+            print(null, e.getMessage());
+        }
+    }
+
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterQueryCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterQueryCommand.java
new file mode 100644
index 00000000..a8a4b585
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterQueryCommand.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.router;
+
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.Router;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.router.RouterService;
+
+/**
+ * Supports for query a list of router.
+ */
+@Command(scope = "onos", name = "routers", description = "Supports for creating a router")
+public class RouterQueryCommand extends AbstractShellCommand {
+    @Option(name = "-i", aliases = "--id", description = "The router identifier",
+            required = false, multiValued = false)
+    String id = null;
+
+    @Option(name = "-n", aliases = "--routerName", description = "The name of router",
+            required = false, multiValued = false)
+    String routerName = null;
+
+    private static final String FMT = "routerId=%s, routerName=%s, tenantId=%s, gatewayPortId=%s,"
+            + "externalGatewayInfo=%s, status=%s, adminStateUp=%s, distributed=%s, routers=%s";
+
+    @Override
+    protected void execute() {
+        RouterService service = get(RouterService.class);
+        if (id != null) {
+            Router router = service.getRouter(RouterId.valueOf(id));
+            printFloatingIp(router);
+        } else if (routerName != null) {
+            Iterable<Router> routers = service.getRouters();
+            if (routers == null) {
+                return;
+            }
+            for (Router router : routers) {
+                if (router.name().equals(routerName)) {
+                    printFloatingIp(router);
+                    return;
+                }
+            }
+            print(null, "The routerName is not existed");
+        } else {
+            Iterable<Router> routers = service.getRouters();
+            if (routers == null) {
+                return;
+            }
+            for (Router router : routers) {
+                printFloatingIp(router);
+            }
+        }
+    }
+
+    private void printFloatingIp(Router router) {
+        print(FMT, router.id(), router.name(), router.tenantId(),
+              router.gatewayPortid(), router.externalGatewayInfo(),
+              router.status(), router.adminStateUp(), router.distributed(),
+              router.routes());
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterRemoveCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterRemoveCommand.java
new file mode 100644
index 00000000..b48434a1
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterRemoveCommand.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.router;
+
+import java.util.Set;
+
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.Router;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.router.RouterService;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Supports for remove a router.
+ */
+@Command(scope = "onos", name = "router-remove", description = "Supports for removing a router")
+public class RouterRemoveCommand extends AbstractShellCommand {
+    @Option(name = "-i", aliases = "--id", description = "The router identifier",
+            required = false, multiValued = false)
+    String id = null;
+
+    @Option(name = "-n", aliases = "--routerName", description = "The name of router",
+            required = false, multiValued = false)
+    String routerName = null;
+
+    @Override
+    protected void execute() {
+        RouterService service = get(RouterService.class);
+        if (id == null && routerName == null) {
+            print(null, "one of id, routerName should not be null");
+        }
+        try {
+            Set<RouterId> routerSet = Sets.newHashSet();
+            if (id != null) {
+                routerSet.add(RouterId.valueOf(id));
+                service.removeRouters(routerSet);
+            } else {
+                Iterable<Router> routers = service.getRouters();
+                if (routers == null) {
+                    return;
+                }
+                for (Router router : routers) {
+                    if (router.name().equals(routerName)) {
+                        routerSet.add(router.id());
+                        service.removeRouters(routerSet);
+                        return;
+                    }
+                }
+            }
+        } catch (Exception e) {
+            print(null, e.getMessage());
+        }
+    }
+
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterUpdateCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterUpdateCommand.java
new file mode 100644
index 00000000..699874b3
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/RouterUpdateCommand.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.router;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.karaf.shell.commands.Argument;
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.DefaultRouter;
+import org.onosproject.vtnrsc.Router;
+import org.onosproject.vtnrsc.Router.Status;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.router.RouterService;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Supports for update a router.
+ */
+@Command(scope = "onos", name = "router-update", description = "Supports for updating a router")
+public class RouterUpdateCommand extends AbstractShellCommand {
+    @Argument(index = 0, name = "id", description = "The router identifier",
+            required = true, multiValued = false)
+    String id = null;
+
+    @Option(name = "-r", aliases = "--routerName", description = "The name of router",
+            required = false, multiValued = false)
+    String routerName = null;
+
+    @Option(name = "-t", aliases = "--tenantId", description = "The tenant identifier of router",
+            required = false, multiValued = false)
+    String tenantId = null;
+
+    @Option(name = "-g", aliases = "--gatewayPortId", description = "The gatewayPort identifier of router",
+            required = false, multiValued = false)
+    String gatewayPortId = null;
+
+    @Option(name = "-e", aliases = "--externalGatewayInfo", description = "The externalGatewayInfo of router",
+            required = false, multiValued = false)
+    String externalGatewayInfo = null;
+
+    @Option(name = "-s", aliases = "--status", description = "The status of router",
+            required = false, multiValued = false)
+    String status = null;
+
+    @Option(name = "-a", aliases = "--adminStateUp", description = "The boolean adminStateUp of router",
+            required = false, multiValued = false)
+    boolean adminStateUp = true;
+
+    @Option(name = "-d", aliases = "--distributed", description = "The boolean distributed of router",
+            required = false, multiValued = false)
+    boolean distributed = false;
+
+    @Override
+    protected void execute() {
+        RouterService service = get(RouterService.class);
+        RouterId routerId = RouterId.valueOf(id);
+        Router router = get(RouterService.class).getRouter(routerId);
+        try {
+            List<String> routes = new ArrayList<String>();
+            Router routerObj = new DefaultRouter(
+                                                 RouterId.valueOf(id),
+                                                 routerName == null ? router.name() : routerName,
+                                                 adminStateUp,
+                                                 status == null ? Status.ACTIVE
+                                                               : Status.valueOf(status),
+                                                 distributed,
+                                                 null,
+                                                 gatewayPortId == null ? router.gatewayPortid()
+                                                                      : VirtualPortId.portId(gatewayPortId),
+                                                 tenantId == null ? router.tenantId()
+                                                                  : TenantId.tenantId(tenantId),
+                                                 routes);
+            Set<Router> routerSet = Sets.newHashSet(routerObj);
+            service.createRouters(routerSet);
+        } catch (Exception e) {
+            print(null, e.getMessage());
+        }
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/package-info.java
new file mode 100644
index 00000000..4f1768ac
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/router/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Command line interface for router.
+ */
+package org.onosproject.vtnrsc.cli.router;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/RouterInterfaceCreateCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/RouterInterfaceCreateCommand.java
new file mode 100644
index 00000000..a3a174c9
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/RouterInterfaceCreateCommand.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.routerinterface;
+
+import org.apache.karaf.shell.commands.Argument;
+import org.apache.karaf.shell.commands.Command;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.RouterInterface;
+import org.onosproject.vtnrsc.SubnetId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.routerinterface.RouterInterfaceService;
+
+/**
+ * Supports for create a router interface.
+ */
+@Command(scope = "onos", name = "routerinterface-create", description = "Supports for creating a router interface")
+public class RouterInterfaceCreateCommand extends AbstractShellCommand {
+    @Argument(index = 0, name = "routerId", description = "The router identifier of router interface",
+            required = true, multiValued = false)
+    String routerId = null;
+
+    @Argument(index = 1, name = "tenantId", description = "The tenant identifier of router interface",
+            required = true, multiValued = false)
+    String tenantId = null;
+
+    @Argument(index = 2, name = "portId", description = "The port identifier of router interface",
+            required = true, multiValued = false)
+    String portId = null;
+
+    @Argument(index = 3, name = "subnetId", description = "The subnet identifier of router interface",
+            required = true, multiValued = false)
+    String subnetId = null;
+
+    @Override
+    protected void execute() {
+        RouterInterfaceService service = get(RouterInterfaceService.class);
+        try {
+            RouterInterface routerInterface = RouterInterface.routerInterface(
+                                                                  SubnetId.subnetId(subnetId),
+                                                                  VirtualPortId.portId(portId),
+                                                                  RouterId.valueOf(routerId),
+                                                                  TenantId.tenantId(tenantId));
+            service.addRouterInterface(routerInterface);
+        } catch (Exception e) {
+            print(null, e.getMessage());
+        }
+    }
+
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/RouterInterfaceQueryCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/RouterInterfaceQueryCommand.java
new file mode 100644
index 00000000..5de35aee
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/RouterInterfaceQueryCommand.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.routerinterface;
+
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.RouterInterface;
+import org.onosproject.vtnrsc.SubnetId;
+import org.onosproject.vtnrsc.routerinterface.RouterInterfaceService;
+
+/**
+ * Supports for query a router interface.
+ */
+@Command(scope = "onos", name = "routerinterfaces", description = "Supports for querying a router interface")
+public class RouterInterfaceQueryCommand extends AbstractShellCommand {
+    @Option(name = "-s", aliases = "--subnetId", description = "The subnet identifier of router interface",
+            required = false, multiValued = false)
+    String subnetId = null;
+
+    private static final String FMT = "subnetId=%s, tenantId=%s, portId=%s, routerId=%s";
+
+    @Override
+    protected void execute() {
+        RouterInterfaceService service = get(RouterInterfaceService.class);
+        if (subnetId != null) {
+            RouterInterface routerInterface = service
+                    .getRouterInterface(SubnetId.subnetId(subnetId));
+            printRouterInterface(routerInterface);
+        } else {
+            Iterable<RouterInterface> routerInterfaces = service
+                    .getRouterInterfaces();
+            for (RouterInterface routerInterface : routerInterfaces) {
+                printRouterInterface(routerInterface);
+            }
+        }
+    }
+
+    private void printRouterInterface(RouterInterface routerInterface) {
+        print(FMT, routerInterface.subnetId(), routerInterface.tenantId(),
+              routerInterface.portId(), routerInterface.routerId());
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/RouterInterfaceRemoveCommand.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/RouterInterfaceRemoveCommand.java
new file mode 100644
index 00000000..4e838e26
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/RouterInterfaceRemoveCommand.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2015 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.vtnrsc.cli.routerinterface;
+
+import org.apache.karaf.shell.commands.Command;
+import org.apache.karaf.shell.commands.Option;
+import org.onosproject.cli.AbstractShellCommand;
+import org.onosproject.vtnrsc.RouterInterface;
+import org.onosproject.vtnrsc.SubnetId;
+import org.onosproject.vtnrsc.routerinterface.RouterInterfaceService;
+
+/**
+ * Supports for remove a router interface.
+ */
+@Command(scope = "onos", name = "routerinterface-remove", description = "Supports for removing a router interface")
+public class RouterInterfaceRemoveCommand extends AbstractShellCommand {
+    @Option(name = "-s", aliases = "--subnetId", description = "The subnet identifier of router interface",
+            required = true, multiValued = false)
+    String subnetId = null;
+
+    @Override
+    protected void execute() {
+        RouterInterfaceService service = get(RouterInterfaceService.class);
+        try {
+            RouterInterface routerInterface = service
+                    .getRouterInterface(SubnetId.subnetId(subnetId));
+            if (routerInterface == null) {
+                print(null, "subnet ID of interface doesn't exist");
+                return;
+            }
+            service.removeRouterInterface(routerInterface);
+        } catch (Exception e) {
+            print(null, e.getMessage());
+        }
+
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/package-info.java
new file mode 100644
index 00000000..7b82004e
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/cli/routerinterface/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Command line interface for router interface.
+ */
+package org.onosproject.vtnrsc.cli.routerinterface;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/VtnRscEvent.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/VtnRscEvent.java
new file mode 100644
index 00000000..3bac158b
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/VtnRscEvent.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2015 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.vtnrsc.event;
+
+import org.onosproject.event.AbstractEvent;
+
+
+/**
+ * Describes network vtnrsc event.
+ */
+public class VtnRscEvent
+        extends AbstractEvent<VtnRscEvent.Type, VtnRscEventFeedback> {
+
+    /**
+     * Type of vtnrsc events.
+     */
+    public enum Type {
+        /**
+         * Signifies that floating IP has create.
+         */
+        FLOATINGIP_PUT,
+        /**
+         * Signifies that floating IP has delete.
+         */
+        FLOATINGIP_DELETE,
+        /**
+         * Signifies that router has create.
+         */
+        ROUTER_PUT,
+        /**
+         * Signifies that router has delete.
+         */
+        ROUTER_DELETE,
+        /**
+         * Signifies that router interface has add.
+         */
+        ROUTER_INTERFACE_PUT,
+        /**
+         * Signifies that router interface has remove.
+         */
+        ROUTER_INTERFACE_DELETE
+    }
+
+    /**
+     * Creates an event of a given type and for the specified vtn event feedback.
+     *
+     * @param type Vtnrsc event type
+     * @param vtnFeedback event VtnrscEventFeedback subject
+     */
+    public VtnRscEvent(Type type, VtnRscEventFeedback vtnFeedback) {
+        super(type, vtnFeedback);
+    }
+
+    /**
+     * Creates an event of a given type and for the specified vtn event feedback.
+     *
+     * @param type Vtnrsc event type
+     * @param vtnFeedback event VtnrscEventFeedback subject
+     * @param time occurrence time
+     */
+    public VtnRscEvent(Type type, VtnRscEventFeedback vtnFeedback, long time) {
+        super(type, vtnFeedback, time);
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/VtnRscEventFeedback.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/VtnRscEventFeedback.java
new file mode 100644
index 00000000..63dcaeee
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/VtnRscEventFeedback.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2015 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.vtnrsc.event;
+
+import java.util.Objects;
+
+import org.onosproject.vtnrsc.FloatingIp;
+import org.onosproject.vtnrsc.Router;
+import org.onosproject.vtnrsc.RouterInterface;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Representation of a VtnRsc event feedback.
+ */
+public class VtnRscEventFeedback {
+    private final FloatingIp floaingtIp;
+    private final Router router;
+    private final RouterInterface routerInterface;
+
+    /**
+     * Creates VtnRscEventFeedback object.
+     *
+     * @param floatingIp the floating Ip
+     */
+    public VtnRscEventFeedback(FloatingIp floatingIp) {
+        this.floaingtIp = checkNotNull(floatingIp, "floaintIp cannot be null");
+        this.router = null;
+        this.routerInterface = null;
+    }
+
+    /**
+     * Creates VtnRscEventFeedback object.
+     *
+     * @param router the router
+     */
+    public VtnRscEventFeedback(Router router) {
+        this.floaingtIp = null;
+        this.router = checkNotNull(router, "router cannot be null");
+        this.routerInterface = null;
+    }
+
+    /**
+     * Creates VtnRscEventFeedback object.
+     *
+     * @param routerInterface the router interface
+     */
+    public VtnRscEventFeedback(RouterInterface routerInterface) {
+        this.floaingtIp = null;
+        this.router = null;
+        this.routerInterface = checkNotNull(routerInterface,
+                                            "routerInterface cannot be null");
+    }
+
+    /**
+     * Returns floating IP.
+     *
+     * @return floaingtIp the floating IP
+     */
+    public FloatingIp floatingIp() {
+        return floaingtIp;
+    }
+
+    /**
+     * Returns router.
+     *
+     * @return router the router
+     */
+    public Router router() {
+        return router;
+    }
+
+    /**
+     * Returns router interface.
+     *
+     * @return routerInterface the router interface
+     */
+    public RouterInterface routerInterface() {
+        return routerInterface;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(floaingtIp, router, routerInterface);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof VtnRscEventFeedback) {
+            final VtnRscEventFeedback that = (VtnRscEventFeedback) obj;
+            return Objects.equals(this.floaingtIp, that.floaingtIp)
+                    && Objects.equals(this.router, that.router)
+                    && Objects.equals(this.routerInterface, that.routerInterface);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this)
+                .add("router", router)
+                .add("floaingtIp", floaingtIp)
+                .add("routerInterface", routerInterface)
+                .toString();
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/VtnRscListener.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/VtnRscListener.java
new file mode 100644
index 00000000..fdd67552
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/VtnRscListener.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2015 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.vtnrsc.event;
+
+import org.onosproject.event.EventListener;
+
+/**
+ * Entity capable of VtnRsc related events.
+ */
+public interface VtnRscListener extends EventListener<VtnRscEvent> {
+
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/package-info.java
new file mode 100644
index 00000000..c1575ad3
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/event/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Event of VtnRsc for VtnRsc service.
+ */
+package org.onosproject.vtnrsc.event;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/FloatingIpEvent.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/FloatingIpEvent.java
new file mode 100644
index 00000000..f76007f7
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/FloatingIpEvent.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2015 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.vtnrsc.floatingip;
+
+import org.onosproject.event.AbstractEvent;
+import org.onosproject.vtnrsc.FloatingIp;
+
+/**
+ * Describes network Floating IP event.
+ */
+public class FloatingIpEvent
+        extends AbstractEvent<FloatingIpEvent.Type, FloatingIp> {
+    /**
+     * Type of Floating IP events.
+     */
+    public enum Type {
+        /**
+         * Signifies that Floating IP has been created.
+         */
+        FLOATINGIP_PUT,
+        /**
+         * Signifies that Floating IP has been deleted.
+         */
+        FLOATINGIP_DELETE
+    }
+
+    /**
+     * Creates an event of a given type and for the specified Floating IP.
+     *
+     * @param type Floating IP event type
+     * @param floagingIp Floating IP subject
+     */
+    public FloatingIpEvent(Type type, FloatingIp floagingIp) {
+        super(type, floagingIp);
+    }
+
+    /**
+     * Creates an event of a given type and for the specified Floating IP.
+     *
+     * @param type Floating IP event type
+     * @param floagingIp Floating IP subject
+     * @param time occurrence time
+     */
+    public FloatingIpEvent(Type type, FloatingIp floagingIp, long time) {
+        super(type, floagingIp, time);
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/FloatingIpListener.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/FloatingIpListener.java
new file mode 100644
index 00000000..a42af136
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/FloatingIpListener.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2015 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.vtnrsc.floatingip;
+
+import org.onosproject.event.EventListener;
+
+/**
+ * Entity capable of Floating IP related events.
+ */
+public interface FloatingIpListener extends EventListener<FloatingIpEvent> {
+
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/FloatingIpService.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/FloatingIpService.java
new file mode 100644
index 00000000..3f6f2515
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/FloatingIpService.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2015 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.vtnrsc.floatingip;
+
+import java.util.Collection;
+
+import org.onlab.packet.IpAddress;
+import org.onosproject.vtnrsc.FloatingIp;
+import org.onosproject.vtnrsc.FloatingIpId;
+import org.onosproject.vtnrsc.TenantId;
+
+/**
+ * Service for interacting with the inventory of floating IP.
+ */
+public interface FloatingIpService {
+    /**
+     * Returns exists or not of specific floatingIp identifier.
+     *
+     * @param floatingIpId floatingIp identifier
+     * @return true or false
+     */
+    boolean exists(FloatingIpId floatingIpId);
+
+    /**
+     * Returns is used or not of specific floating IP address.
+     *
+     * @param floatingIpAddr floatingIp address
+     * @param floatingIpId floatingIp identifier
+     * @return true or false
+     */
+    boolean floatingIpIsUsed(IpAddress floatingIpAddr, FloatingIpId floatingIpId);
+
+    /**
+     * Returns is used or not of specific fixed IP address.
+     *
+     * @param fixedIpAddr fixedIp address
+     * @param tenantId the tenant identifier of floating IP
+     * @param floatingIpId floatingIp identifier
+     * @return true or false
+     */
+    boolean fixedIpIsUsed(IpAddress fixedIpAddr, TenantId tenantId, FloatingIpId floatingIpId);
+
+    /**
+     * Returns a collection of the currently known floating IP.
+     *
+     * @return collection of floating IP
+     */
+    Collection<FloatingIp> getFloatingIps();
+
+    /**
+     * Returns the floatingIp with the specified identifier.
+     *
+     * @param floatingIpId floatingIp identifier
+     * @return floatingIp or null if one with the given identifier is not known
+     */
+    FloatingIp getFloatingIp(FloatingIpId floatingIpId);
+
+    /**
+     * Creates new floatingIps.
+     *
+     * @param floatingIps the collection of floatingIp
+     * @return true if the identifier floatingIp has been created right
+     */
+    boolean createFloatingIps(Collection<FloatingIp> floatingIps);
+
+    /**
+     * Updates existing floatingIps.
+     *
+     * @param floatingIps the collection of floatingIp
+     * @return true if all floatingIp were updated successfully
+     */
+    boolean updateFloatingIps(Collection<FloatingIp> floatingIps);
+
+    /**
+     * Removes the specified floatingIp from the store.
+     *
+     * @param floatingIpIds the collection of floatingIp identifier
+     * @return true if remove identifier floatingIp successfully
+     */
+    boolean removeFloatingIps(Collection<FloatingIpId> floatingIpIds);
+
+    /**
+     * Adds the specified listener to floating Ip manager.
+     *
+     * @param listener floating Ip listener
+     */
+    void addListener(FloatingIpListener listener);
+
+    /**
+     * Removes the specified listener to floating Ip manager.
+     *
+     * @param listener floating Ip listener
+     */
+    void removeListener(FloatingIpListener listener);
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/impl/FloatingIpManager.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/impl/FloatingIpManager.java
new file mode 100644
index 00000000..9f944da1
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/impl/FloatingIpManager.java
@@ -0,0 +1,348 @@
+/*
+ * Copyright 2015 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.vtnrsc.floatingip.impl;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onlab.packet.IpAddress;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.EventuallyConsistentMapEvent;
+import org.onosproject.store.service.EventuallyConsistentMapListener;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.onosproject.vtnrsc.DefaultFloatingIp;
+import org.onosproject.vtnrsc.FloatingIp;
+import org.onosproject.vtnrsc.FloatingIpId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.TenantNetworkId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.floatingip.FloatingIpEvent;
+import org.onosproject.vtnrsc.floatingip.FloatingIpListener;
+import org.onosproject.vtnrsc.floatingip.FloatingIpService;
+import org.onosproject.vtnrsc.router.RouterService;
+import org.onosproject.vtnrsc.tenantnetwork.TenantNetworkService;
+import org.onosproject.vtnrsc.virtualport.VirtualPortService;
+import org.slf4j.Logger;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Provides implementation of the FloatingIp service.
+ */
+@Component(immediate = true)
+@Service
+public class FloatingIpManager implements FloatingIpService {
+    private static final String FLOATINGIP_ID_NOT_NULL = "Floatingip ID cannot be null";
+    private static final String FLOATINGIP_NOT_NULL = "Floatingip cannot be null";
+    private static final String FLOATINGIP = "vtn-floatingip-store";
+    private static final String VTNRSC_APP = "org.onosproject.vtnrsc";
+    private static final String LISTENER_NOT_NULL = "Listener cannot be null";
+    private static final String EVENT_NOT_NULL = "event cannot be null";
+
+    private final Logger log = getLogger(getClass());
+    private final Set<FloatingIpListener> listeners = Sets
+            .newCopyOnWriteArraySet();
+    private EventuallyConsistentMapListener<FloatingIpId, FloatingIp> floatingIpListener =
+            new InnerFloatingIpStoreListener();
+    protected EventuallyConsistentMap<FloatingIpId, FloatingIp> floatingIpStore;
+    protected ApplicationId appId;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected StorageService storageService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected CoreService coreService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected TenantNetworkService tenantNetworkService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected VirtualPortService virtualPortService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected RouterService routerService;
+
+    @Activate
+    public void activate() {
+        appId = coreService.registerApplication(VTNRSC_APP);
+        KryoNamespace.Builder serializer = KryoNamespace
+                .newBuilder()
+                .register(KryoNamespaces.API)
+                .register(FloatingIp.class, FloatingIpId.class,
+                          TenantNetworkId.class, TenantId.class,
+                          FloatingIp.Status.class, RouterId.class,
+                          VirtualPortId.class, DefaultFloatingIp.class);
+        floatingIpStore = storageService
+                .<FloatingIpId, FloatingIp>eventuallyConsistentMapBuilder()
+                .withName(FLOATINGIP).withSerializer(serializer)
+                .withTimestampProvider((k, v) -> new WallClockTimestamp())
+                .build();
+        floatingIpStore.addListener(floatingIpListener);
+        log.info("Started");
+    }
+
+    @Deactivate
+    public void deactivate() {
+        floatingIpStore.removeListener(floatingIpListener);
+        floatingIpStore.destroy();
+        listeners.clear();
+        log.info("Stopped");
+    }
+
+    @Override
+    public Collection<FloatingIp> getFloatingIps() {
+        return Collections.unmodifiableCollection(floatingIpStore.values());
+    }
+
+    @Override
+    public FloatingIp getFloatingIp(FloatingIpId floatingIpId) {
+        checkNotNull(floatingIpId, FLOATINGIP_ID_NOT_NULL);
+        return floatingIpStore.get(floatingIpId);
+    }
+
+    @Override
+    public boolean exists(FloatingIpId floatingIpId) {
+        checkNotNull(floatingIpId, FLOATINGIP_ID_NOT_NULL);
+        return floatingIpStore.containsKey(floatingIpId);
+    }
+
+    @Override
+    public boolean floatingIpIsUsed(IpAddress floatingIpAddr,
+                                    FloatingIpId floatingIpId) {
+        checkNotNull(floatingIpAddr, "Floating IP address cannot be null");
+        checkNotNull(floatingIpId, "Floating IP Id cannot be null");
+        Collection<FloatingIp> floatingIps = getFloatingIps();
+        for (FloatingIp floatingIp : floatingIps) {
+            if (floatingIp.floatingIp().equals(floatingIpAddr)
+                    && !floatingIp.id().equals(floatingIpId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean fixedIpIsUsed(IpAddress fixedIpAddr, TenantId tenantId,
+                                 FloatingIpId floatingIpId) {
+        checkNotNull(fixedIpAddr, "Fixed IP address cannot be null");
+        checkNotNull(tenantId, "Tenant Id cannot be null");
+        checkNotNull(floatingIpId, "Floating IP Id cannot be null");
+        Collection<FloatingIp> floatingIps = getFloatingIps();
+        for (FloatingIp floatingIp : floatingIps) {
+            IpAddress fixedIp = floatingIp.fixedIp();
+            if (fixedIp != null) {
+                if (fixedIp.equals(fixedIpAddr)
+                        && floatingIp.tenantId().equals(tenantId)
+                        && !floatingIp.id().equals(floatingIpId)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean createFloatingIps(Collection<FloatingIp> floatingIps) {
+        checkNotNull(floatingIps, FLOATINGIP_NOT_NULL);
+        boolean result = true;
+        for (FloatingIp floatingIp : floatingIps) {
+            verifyFloatingIpData(floatingIp);
+            if (floatingIp.portId() != null) {
+                floatingIpStore.put(floatingIp.id(), floatingIp);
+                if (!floatingIpStore.containsKey(floatingIp.id())) {
+                    log.debug("The floating Ip is created failed whose identifier is {}",
+                              floatingIp.id().toString());
+                    result = false;
+                }
+            } else {
+                FloatingIp oldFloatingIp = floatingIpStore.get(floatingIp.id());
+                if (oldFloatingIp != null) {
+                    floatingIpStore.remove(floatingIp.id(), oldFloatingIp);
+                    if (floatingIpStore.containsKey(floatingIp.id())) {
+                        log.debug("The floating Ip is created failed whose identifier is {}",
+                                  floatingIp.id().toString());
+                        result = false;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public boolean updateFloatingIps(Collection<FloatingIp> floatingIps) {
+        checkNotNull(floatingIps, FLOATINGIP_NOT_NULL);
+        boolean result = true;
+        if (floatingIps != null) {
+            for (FloatingIp floatingIp : floatingIps) {
+                verifyFloatingIpData(floatingIp);
+                if (floatingIp.portId() != null) {
+                    floatingIpStore.put(floatingIp.id(), floatingIp);
+                    if (!floatingIpStore.containsKey(floatingIp.id())) {
+                        log.debug("The floating Ip is updated failed whose identifier is {}",
+                                  floatingIp.id().toString());
+                        result = false;
+                    }
+                } else {
+                    FloatingIp oldFloatingIp = floatingIpStore.get(floatingIp
+                            .id());
+                    if (oldFloatingIp != null) {
+                        floatingIpStore.remove(floatingIp.id(), oldFloatingIp);
+                        if (floatingIpStore.containsKey(floatingIp.id())) {
+                            log.debug("The floating Ip is updated failed whose identifier is {}",
+                                      floatingIp.id().toString());
+                            result = false;
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public boolean removeFloatingIps(Collection<FloatingIpId> floatingIpIds) {
+        checkNotNull(floatingIpIds, FLOATINGIP_ID_NOT_NULL);
+        boolean result = true;
+        if (floatingIpIds != null) {
+            for (FloatingIpId floatingIpId : floatingIpIds) {
+                if (!floatingIpStore.containsKey(floatingIpId)) {
+                    log.debug("The floatingIp is not exist whose identifier is {}",
+                              floatingIpId.toString());
+                    throw new IllegalArgumentException(
+                                                       "FloatingIP ID doesn't exist");
+                }
+                FloatingIp floatingIp = floatingIpStore.get(floatingIpId);
+                floatingIpStore.remove(floatingIpId, floatingIp);
+                if (floatingIpStore.containsKey(floatingIpId)) {
+                    log.debug("The floating Ip is deleted failed whose identifier is {}",
+                              floatingIpId.toString());
+                    result = false;
+                }
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public void addListener(FloatingIpListener listener) {
+        checkNotNull(listener, LISTENER_NOT_NULL);
+        listeners.add(listener);
+    }
+
+    @Override
+    public void removeListener(FloatingIpListener listener) {
+        checkNotNull(listener, LISTENER_NOT_NULL);
+        listeners.add(listener);
+    }
+
+    /**
+     * Verifies validity of FloatingIp data.
+     *
+     * @param floatingIps floatingIp instance
+     */
+    private void verifyFloatingIpData(FloatingIp floatingIps) {
+        checkNotNull(floatingIps, FLOATINGIP_NOT_NULL);
+        if (!tenantNetworkService.exists(floatingIps.networkId())) {
+            log.debug("The network identifier {} that the floating Ip {} create for is not exist",
+                      floatingIps.networkId().toString(), floatingIps.id()
+                              .toString());
+            throw new IllegalArgumentException(
+                                               "Floating network ID doesn't exist");
+        }
+
+        VirtualPortId portId = floatingIps.portId();
+        if (portId != null && !virtualPortService.exists(portId)) {
+            log.debug("The port identifier {} that the floating Ip {} create for is not exist",
+                      floatingIps.portId().toString(), floatingIps.id()
+                              .toString());
+            throw new IllegalArgumentException("Port ID doesn't exist");
+        }
+
+        RouterId routerId = floatingIps.routerId();
+        if (routerId != null && !routerService.exists(routerId)) {
+            log.debug("The router identifier {} that the floating Ip {} create for is not exist",
+                      floatingIps.routerId().toString(), floatingIps.id()
+                              .toString());
+            throw new IllegalArgumentException("Router ID doesn't exist");
+        }
+
+        if (floatingIpIsUsed(floatingIps.floatingIp(), floatingIps.id())) {
+            log.debug("The floaing Ip {} that the floating Ip {} create for is used",
+                      floatingIps.floatingIp().toString(), floatingIps.id()
+                              .toString());
+            throw new IllegalArgumentException(
+                                               "The floating IP address is used");
+        }
+
+        IpAddress fixedIp = floatingIps.fixedIp();
+        if (fixedIp != null
+                && fixedIpIsUsed(fixedIp, floatingIps.tenantId(),
+                                 floatingIps.id())) {
+            log.debug("The fixed Ip {} that the floating Ip {} create for is used",
+                      floatingIps.fixedIp().toString(), floatingIps.id()
+                              .toString());
+            throw new IllegalArgumentException("The fixed IP address is used");
+        }
+    }
+
+    private class InnerFloatingIpStoreListener
+            implements
+            EventuallyConsistentMapListener<FloatingIpId, FloatingIp> {
+
+        @Override
+        public void event(EventuallyConsistentMapEvent<FloatingIpId, FloatingIp> event) {
+            checkNotNull(event, EVENT_NOT_NULL);
+            FloatingIp floatingIp = event.value();
+            if (EventuallyConsistentMapEvent.Type.PUT == event.type()) {
+                notifyListeners(new FloatingIpEvent(
+                                                    FloatingIpEvent.Type.FLOATINGIP_PUT,
+                                                    floatingIp));
+            }
+            if (EventuallyConsistentMapEvent.Type.REMOVE == event.type()) {
+                notifyListeners(new FloatingIpEvent(
+                                                    FloatingIpEvent.Type.FLOATINGIP_DELETE,
+                                                    floatingIp));
+            }
+        }
+    }
+
+    /**
+     * Notifies specify event to all listeners.
+     *
+     * @param event Floating IP event
+     */
+    private void notifyListeners(FloatingIpEvent event) {
+        checkNotNull(event, EVENT_NOT_NULL);
+        listeners.forEach(listener -> listener.event(event));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/impl/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/impl/package-info.java
new file mode 100644
index 00000000..c638eba0
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/impl/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Provides implementation of the FloatingIp service.
+ */
+package org.onosproject.vtnrsc.floatingip.impl;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/package-info.java
new file mode 100644
index 00000000..274cbdd0
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/floatingip/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Service for interacting with the inventory of FloatingIp.
+ */
+package org.onosproject.vtnrsc.floatingip;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/flowclassifier/FlowClassifierService.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/flowclassifier/FlowClassifierService.java
index c160d221..c5911ff2 100644
--- a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/flowclassifier/FlowClassifierService.java
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/flowclassifier/FlowClassifierService.java
@@ -24,49 +24,59 @@ import org.onosproject.vtnrsc.FlowClassifierId;
 public interface FlowClassifierService {
 
     /**
-     * Store Flow Classifier.
+     * Check whether Flow Classifier is present based on given Flow Classifier
+     * Id.
      *
-     * @param flowClassifier Flow Classifier
-     * @return true if adding Flow Classifier into store is success otherwise return false.
+     * @param id flow classifier identifier
+     * @return true if flow classifier is present otherwise return false
      */
-    boolean createFlowClassifier(FlowClassifier flowClassifier);
+    boolean exists(FlowClassifierId id);
 
     /**
-     * Return the existing collection of Flow Classifier.
+     * Returns the number of flow classifiers known to the system.
      *
-     * @return Flow Classifier collections.
+     * @return number of flow classifiers
      */
-    Iterable<FlowClassifier> getFlowClassifiers();
+    int getFlowClassifierCount();
+
+    /**
+     * Store Flow Classifier.
+     *
+     * @param flowClassifier flow classifier
+     * @return true if adding flow classifier into store is success otherwise
+     *         return false
+     */
+    boolean createFlowClassifier(FlowClassifier flowClassifier);
 
     /**
-     * Check whether Flow Classifier is present based on given Flow Classifier Id.
+     * Return the existing collection of Flow Classifier.
      *
-     * @param id Flow Classifier.
-     * @return true if Flow Classifier is present otherwise return false.
+     * @return flow classifier collections
      */
-    boolean hasFlowClassifier(FlowClassifierId id);
+    Iterable<FlowClassifier> getFlowClassifiers();
 
     /**
      * Retrieve the Flow Classifier based on given Flow Classifier id.
      *
-     * @param id Flow Classifier Id.
-     * @return Flow Classifier if present otherwise returns null.
+     * @param id flow classifier identifier
+     * @return flow classifier if present otherwise returns null
      */
     FlowClassifier getFlowClassifier(FlowClassifierId id);
 
     /**
      * Update Flow Classifier based on given Flow Classifier Id.
      *
-     * @param flowClassifier Flow Classifier.
-     * @return true if update is success otherwise return false.
+     * @param flowClassifier flow classifier
+     * @return true if flow classifier update is success otherwise return false
      */
     boolean updateFlowClassifier(FlowClassifier flowClassifier);
 
     /**
      * Remove Flow Classifier from store based on given Flow Classifier Id.
      *
-     * @param id Flow Classifier Id.
-     * @return true if Flow Classifier removal is success otherwise return false.
+     * @param id flow classifier identifier
+     * @return true if flow classifier removal is success otherwise return
+     *         false
      */
     boolean removeFlowClassifier(FlowClassifierId id);
 }
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/flowclassifier/impl/FlowClassifierManager.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/flowclassifier/impl/FlowClassifierManager.java
index ee5873d6..4a60cd34 100644
--- a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/flowclassifier/impl/FlowClassifierManager.java
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/flowclassifier/impl/FlowClassifierManager.java
@@ -54,7 +54,7 @@ public class FlowClassifierManager implements FlowClassifierService {
     protected StorageService storageService;
 
     @Activate
-    private void activate() {
+    protected void activate() {
         KryoNamespace.Builder serializer = KryoNamespace.newBuilder()
                 .register(KryoNamespaces.API)
                 .register(MultiValuedTimestamp.class)
@@ -67,34 +67,25 @@ public class FlowClassifierManager implements FlowClassifierService {
     }
 
     @Deactivate
-    private void deactivate() {
+    protected void deactivate() {
         flowClassifierStore.destroy();
         log.info("Flow Classifier service deactivated");
     }
 
     @Override
-    public boolean createFlowClassifier(FlowClassifier flowClassifier) {
-        log.debug("createFlowClassifier");
-        checkNotNull(flowClassifier, FLOW_CLASSIFIER_NOT_NULL);
-        FlowClassifierId id = flowClassifier.flowClassifierId();
-
-        flowClassifierStore.put(id, flowClassifier);
-        if (!flowClassifierStore.containsKey(id)) {
-            log.debug("Flow Classifier creation is failed whose identifier is {}.", id.toString());
-            return false;
-        }
-        return true;
+    public boolean exists(FlowClassifierId id) {
+        checkNotNull(id, FLOW_CLASSIFIER_ID_NOT_NULL);
+        return flowClassifierStore.containsKey(id);
     }
 
     @Override
-    public Iterable<FlowClassifier> getFlowClassifiers() {
-        return ImmutableList.copyOf(flowClassifierStore.values());
+    public int getFlowClassifierCount() {
+        return flowClassifierStore.size();
     }
 
     @Override
-    public boolean hasFlowClassifier(FlowClassifierId id) {
-        checkNotNull(id, FLOW_CLASSIFIER_ID_NOT_NULL);
-        return flowClassifierStore.containsKey(id);
+    public Iterable<FlowClassifier> getFlowClassifiers() {
+        return ImmutableList.copyOf(flowClassifierStore.values());
     }
 
     @Override
@@ -104,10 +95,36 @@ public class FlowClassifierManager implements FlowClassifierService {
     }
 
     @Override
-    public boolean updateFlowClassifier(FlowClassifier flowClassifier) {
+    public boolean createFlowClassifier(FlowClassifier flowClassifier) {
+        log.debug("createFlowClassifier");
         checkNotNull(flowClassifier, FLOW_CLASSIFIER_NOT_NULL);
         FlowClassifierId id = flowClassifier.flowClassifierId();
+
         flowClassifierStore.put(id, flowClassifier);
+        if (!flowClassifierStore.containsKey(id)) {
+            log.debug("Flow Classifier creation is failed whose identifier is {}.", id.toString());
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean updateFlowClassifier(FlowClassifier flowClassifier) {
+        checkNotNull(flowClassifier, FLOW_CLASSIFIER_NOT_NULL);
+
+        if (!flowClassifierStore.containsKey(flowClassifier.flowClassifierId())) {
+            log.debug("The flowClassifier is not exist whose identifier was {} ", flowClassifier.flowClassifierId()
+                    .toString());
+            return false;
+        }
+
+        flowClassifierStore.put(flowClassifier.flowClassifierId(), flowClassifier);
+
+        if (!flowClassifier.equals(flowClassifierStore.get(flowClassifier.flowClassifierId()))) {
+            log.debug("Updation of flowClassifier is failed whose identifier was {} ", flowClassifier
+                    .flowClassifierId().toString());
+            return false;
+        }
         return true;
     }
 
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/RouterEvent.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/RouterEvent.java
new file mode 100644
index 00000000..25bd7b31
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/RouterEvent.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2015 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.vtnrsc.router;
+
+import org.onosproject.event.AbstractEvent;
+import org.onosproject.vtnrsc.Router;
+
+/**
+ * Describes network Router event.
+ */
+public class RouterEvent extends AbstractEvent<RouterEvent.Type, Router> {
+    /**
+     * Type of Router events.
+     */
+    public enum Type {
+        /**
+         * Signifies that router has been created.
+         */
+        ROUTER_PUT,
+        /**
+         * Signifies that router has been deleted.
+         */
+        ROUTER_DELETE
+    }
+
+    /**
+     * Creates an event of a given type and for the specified Router.
+     *
+     * @param type Router event type
+     * @param router Router subject
+     */
+    public RouterEvent(Type type, Router router) {
+        super(type, router);
+    }
+
+    /**
+     * Creates an event of a given type and for the specified Router.
+     *
+     * @param type Router event type
+     * @param router Router subject
+     * @param time occurrence time
+     */
+    public RouterEvent(Type type, Router router, long time) {
+        super(type, router, time);
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/RouterListener.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/RouterListener.java
new file mode 100644
index 00000000..dc772981
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/RouterListener.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2015 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.vtnrsc.router;
+
+import org.onosproject.event.EventListener;
+
+/**
+ * Entity capable of Router related events.
+ */
+public interface RouterListener extends EventListener<RouterEvent> {
+
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/RouterService.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/RouterService.java
new file mode 100644
index 00000000..362fa02b
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/RouterService.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2015 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.vtnrsc.router;
+
+import java.util.Collection;
+
+import org.onosproject.vtnrsc.Router;
+import org.onosproject.vtnrsc.RouterId;
+
+/**
+ * Service for interacting with the inventory of Routers.
+ */
+public interface RouterService {
+    /**
+     * Returns exists or not of specific router identifier.
+     *
+     * @param routerId router identifier
+     * @return true or false
+     */
+    boolean exists(RouterId routerId);
+
+    /**
+     * Returns a collection of the currently known Routers.
+     *
+     * @return collection of Routers
+     */
+    Collection<Router> getRouters();
+
+    /**
+     * Returns the Router with the specified identifier.
+     *
+     * @param routerId Router identifier
+     * @return Router or null if one with the given identifier is not known
+     */
+    Router getRouter(RouterId routerId);
+
+    /**
+     * Creates new Routers.
+     *
+     * @param routers the collection of Routers
+     * @return true if the identifier Router has been created right.
+     *         false if the identifier Router is failed to store
+     */
+    boolean createRouters(Collection<Router> routers);
+
+    /**
+     * Updates existing Routers.
+     *
+     * @param routers the collection of Routers
+     * @return true if Routers were updated successfully.
+     *         false if Routers were updated failed
+     */
+    boolean updateRouters(Collection<Router> routers);
+
+    /**
+     * Removes the specified Routers from the store.
+     *
+     * @param routerIds the collection of Routers identifier
+     * @return true if remove identifier Routers successfully. false if remove
+     *         identifier Routers failed
+     */
+    boolean removeRouters(Collection<RouterId> routerIds);
+
+    /**
+     * Adds the specified listener to Router manager.
+     *
+     * @param listener Router listener
+     */
+    void addListener(RouterListener listener);
+
+    /**
+     * Removes the specified listener to Router manager.
+     *
+     * @param listener Router listener
+     */
+    void removeListener(RouterListener listener);
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/impl/RouterManager.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/impl/RouterManager.java
new file mode 100644
index 00000000..b796fd7b
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/impl/RouterManager.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2015 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.vtnrsc.router.impl;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.EventuallyConsistentMapEvent;
+import org.onosproject.store.service.EventuallyConsistentMapListener;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.onosproject.vtnrsc.DefaultRouter;
+import org.onosproject.vtnrsc.FixedIp;
+import org.onosproject.vtnrsc.Router;
+import org.onosproject.vtnrsc.RouterGateway;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.SubnetId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.TenantNetworkId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.router.RouterEvent;
+import org.onosproject.vtnrsc.router.RouterListener;
+import org.onosproject.vtnrsc.router.RouterService;
+import org.onosproject.vtnrsc.subnet.SubnetService;
+import org.onosproject.vtnrsc.tenantnetwork.TenantNetworkService;
+import org.onosproject.vtnrsc.virtualport.VirtualPortService;
+import org.slf4j.Logger;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Provides implementation of the Router service.
+ */
+@Component(immediate = true)
+@Service
+public class RouterManager implements RouterService {
+
+    private static final String ROUTER_ID_NULL = "Router ID cannot be null";
+    private static final String ROUTER_NOT_NULL = "Router cannot be null";
+    private static final String ROUTER = "vtn-router-store";
+    private static final String VTNRSC_APP = "org.onosproject.vtnrsc";
+    private static final String LISTENER_NOT_NULL = "Listener cannot be null";
+    private static final String EVENT_NOT_NULL = "event cannot be null";
+
+    private final Logger log = getLogger(getClass());
+    private final Set<RouterListener> listeners = Sets.newCopyOnWriteArraySet();
+    private EventuallyConsistentMapListener<RouterId, Router> routerListener = new InnerRouterStoreListener();
+    protected EventuallyConsistentMap<RouterId, Router> routerStore;
+    protected ApplicationId appId;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected StorageService storageService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected CoreService coreService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected TenantNetworkService tenantNetworkService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected VirtualPortService virtualPortService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected SubnetService subnetService;
+
+    @Activate
+    public void activate() {
+        appId = coreService.registerApplication(VTNRSC_APP);
+        KryoNamespace.Builder serializer = KryoNamespace
+                .newBuilder()
+                .register(KryoNamespaces.API)
+                .register(Router.class, RouterId.class, DefaultRouter.class,
+                          TenantNetworkId.class, TenantId.class,
+                          VirtualPortId.class, DefaultRouter.class,
+                          RouterGateway.class, Router.Status.class,
+                          SubnetId.class);
+        routerStore = storageService
+                .<RouterId, Router>eventuallyConsistentMapBuilder()
+                .withName(ROUTER).withSerializer(serializer)
+                .withTimestampProvider((k, v) -> new WallClockTimestamp())
+                .build();
+        routerStore.addListener(routerListener);
+        log.info("Started");
+    }
+
+    @Deactivate
+    public void deactivate() {
+        routerStore.removeListener(routerListener);
+        routerStore.destroy();
+        listeners.clear();
+        log.info("Stopped");
+    }
+
+    @Override
+    public boolean exists(RouterId routerId) {
+        checkNotNull(routerId, ROUTER_ID_NULL);
+        return routerStore.containsKey(routerId);
+    }
+
+    @Override
+    public Collection<Router> getRouters() {
+        return Collections.unmodifiableCollection(routerStore.values());
+    }
+
+    @Override
+    public Router getRouter(RouterId routerId) {
+        checkNotNull(routerId, ROUTER_ID_NULL);
+        return routerStore.get(routerId);
+    }
+
+    @Override
+    public boolean createRouters(Collection<Router> routers) {
+        checkNotNull(routers, ROUTER_NOT_NULL);
+        for (Router router : routers) {
+            verifyRouterData(router);
+            routerStore.put(router.id(), router);
+            if (!routerStore.containsKey(router.id())) {
+                log.debug("The router is created failed whose identifier is {}",
+                          router.id().toString());
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean updateRouters(Collection<Router> routers) {
+        checkNotNull(routers, ROUTER_NOT_NULL);
+        for (Router router : routers) {
+            if (!routerStore.containsKey(router.id())) {
+                log.debug("The routers is not exist whose identifier is {}",
+                          router.id().toString());
+                throw new IllegalArgumentException(
+                                                   "routers ID doesn't exist");
+            }
+            verifyRouterData(router);
+            routerStore.put(router.id(), router);
+            if (!router.equals(routerStore.get(router.id()))) {
+                log.debug("The router is updated failed whose identifier is {}",
+                          router.id().toString());
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean removeRouters(Collection<RouterId> routerIds) {
+        checkNotNull(routerIds, ROUTER_ID_NULL);
+        for (RouterId routerId : routerIds) {
+            if (!routerStore.containsKey(routerId)) {
+                log.debug("The router is not exist whose identifier is {}",
+                          routerId.toString());
+                throw new IllegalArgumentException(
+                                                   "router ID doesn't exist");
+            }
+            Router router = routerStore.get(routerId);
+            routerStore.remove(routerId, router);
+            if (routerStore.containsKey(routerId)) {
+                log.debug("The router deleted is failed whose identifier is {}",
+                          routerId.toString());
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public void addListener(RouterListener listener) {
+        checkNotNull(listener, LISTENER_NOT_NULL);
+        listeners.add(listener);
+    }
+
+    @Override
+    public void removeListener(RouterListener listener) {
+        checkNotNull(listener, LISTENER_NOT_NULL);
+        listeners.remove(listener);
+    }
+
+    /**
+     * Verifies validity of Router data.
+     *
+     * @param routers router instance
+     */
+    private void verifyRouterData(Router routers) {
+        checkNotNull(routers, ROUTER_NOT_NULL);
+        if (routers.gatewayPortid() != null
+                && !virtualPortService.exists(routers.gatewayPortid())) {
+            log.debug("The gateway port ID is not exist whose identifier is {}",
+                      routers.gatewayPortid().toString());
+            throw new IllegalArgumentException("gateway port ID doesn't exist");
+        }
+
+        if (routers.externalGatewayInfo() != null) {
+            RouterGateway routerGateway = routers.externalGatewayInfo();
+            if (!tenantNetworkService.exists(routerGateway.networkId())) {
+                log.debug("The network ID of gateway info is not exist whose identifier is {}",
+                          routers.id().toString());
+                throw new IllegalArgumentException(
+                                                   "network ID of gateway info doesn't exist");
+            }
+            Iterable<FixedIp> fixedIps = routerGateway.externalFixedIps();
+            for (FixedIp fixedIp : fixedIps) {
+                if (!subnetService.exists(fixedIp.subnetId())) {
+                    log.debug("The subnet ID of gateway info is not exist whose identifier is {}",
+                              routers.id().toString());
+                    throw new IllegalArgumentException(
+                                                       "subnet ID of gateway info doesn't exist");
+                }
+            }
+        }
+    }
+
+    private class InnerRouterStoreListener
+            implements EventuallyConsistentMapListener<RouterId, Router> {
+
+        @Override
+        public void event(EventuallyConsistentMapEvent<RouterId, Router> event) {
+            checkNotNull(event, EVENT_NOT_NULL);
+            Router router = event.value();
+            if (EventuallyConsistentMapEvent.Type.PUT == event.type()) {
+                notifyListeners(new RouterEvent(RouterEvent.Type.ROUTER_PUT,
+                                                router));
+            }
+            if (EventuallyConsistentMapEvent.Type.REMOVE == event.type()) {
+                notifyListeners(new RouterEvent(RouterEvent.Type.ROUTER_DELETE,
+                                                router));
+            }
+        }
+    }
+
+    /**
+     * Notifies specify event to all listeners.
+     *
+     * @param event Floating IP event
+     */
+    private void notifyListeners(RouterEvent event) {
+        checkNotNull(event, EVENT_NOT_NULL);
+        listeners.forEach(listener -> listener.event(event));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/impl/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/impl/package-info.java
new file mode 100644
index 00000000..1254f982
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/impl/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Provides implementation of the Router service.
+ */
+package org.onosproject.vtnrsc.router.impl;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/package-info.java
new file mode 100644
index 00000000..fb6834aa
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/router/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Service for interacting with the inventory of Router.
+ */
+package org.onosproject.vtnrsc.router;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/RouterInterfaceEvent.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/RouterInterfaceEvent.java
new file mode 100644
index 00000000..7f5cfa13
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/RouterInterfaceEvent.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2015 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.vtnrsc.routerinterface;
+
+import org.onosproject.event.AbstractEvent;
+import org.onosproject.vtnrsc.RouterInterface;
+
+/**
+ * Describes network Router Interface event.
+ */
+public class RouterInterfaceEvent
+        extends AbstractEvent<RouterInterfaceEvent.Type, RouterInterface> {
+
+    /**
+     * Type of Router Interface events.
+     */
+    public enum Type {
+        /**
+         * Signifies that router interface has been added.
+         */
+        ROUTER_INTERFACE_PUT,
+        /**
+         * Signifies that router interface has been removed.
+         */
+        ROUTER_INTERFACE_DELETE
+    }
+
+    /**
+     * Creates an event of a given type and for the specified Router Interface.
+     *
+     * @param type Router Interface event type
+     * @param routerInterface Router Interface subject
+     */
+    public RouterInterfaceEvent(Type type, RouterInterface routerInterface) {
+        super(type, routerInterface);
+    }
+
+    /**
+     * Creates an event of a given type and for the specified Router Interface.
+     *
+     * @param type Router Interface event type.
+     * @param routerInterface Router Interface subject
+     * @param time occurrence time
+     */
+    public RouterInterfaceEvent(Type type, RouterInterface routerInterface,
+                                long time) {
+        super(type, routerInterface, time);
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/RouterInterfaceListener.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/RouterInterfaceListener.java
new file mode 100644
index 00000000..1d0dab6f
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/RouterInterfaceListener.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2015 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.vtnrsc.routerinterface;
+
+import org.onosproject.event.EventListener;
+
+/**
+ * Entity capable of Router Interface related events.
+ */
+public interface RouterInterfaceListener
+        extends EventListener<RouterInterfaceEvent> {
+
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/RouterInterfaceService.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/RouterInterfaceService.java
new file mode 100644
index 00000000..8cf147a5
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/RouterInterfaceService.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2015 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.vtnrsc.routerinterface;
+
+import java.util.Collection;
+
+import org.onosproject.vtnrsc.RouterInterface;
+import org.onosproject.vtnrsc.SubnetId;
+
+/**
+ * Service for interacting with the inventory of Router interface.
+ */
+public interface RouterInterfaceService {
+    /**
+     * Returns exists or not of specific subnet identifier.
+     *
+     * @param subnetId subnet identifier
+     * @return true or false
+     */
+    boolean exists(SubnetId subnetId);
+
+    /**
+     * Returns a collection of the currently known Router interface.
+     *
+     * @return collection of RouterInterface
+     */
+    Collection<RouterInterface> getRouterInterfaces();
+
+    /**
+     * Returns the Router interface with the specified subnet identifier.
+     *
+     * @param subnetId subnet identifier
+     * @return RouterInterface or null if one with the given identifier is not
+     *         known
+     */
+    RouterInterface getRouterInterface(SubnetId subnetId);
+
+    /**
+     * Adds the specified RouterInterface.
+     *
+     * @param routerInterface the interface add to router
+     * @return true if add router interface successfully
+     */
+    boolean addRouterInterface(RouterInterface routerInterface);
+
+    /**
+     * Removes the specified RouterInterface.
+     *
+     * @param routerInterface the interface remove from router
+     * @return true if remove router interface successfully
+     */
+    boolean removeRouterInterface(RouterInterface routerInterface);
+
+    /**
+     * Adds the specified listener to Router Interface manager.
+     *
+     * @param listener Router Interface listener
+     */
+    void addListener(RouterInterfaceListener listener);
+
+    /**
+     * Removes the specified listener to RouterInterface manager.
+     *
+     * @param listener Router Interface listener
+     */
+    void removeListener(RouterInterfaceListener listener);
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/impl/RouterInterfaceManager.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/impl/RouterInterfaceManager.java
new file mode 100644
index 00000000..244a5c03
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/impl/RouterInterfaceManager.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright 2015 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.vtnrsc.routerinterface.impl;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.EventuallyConsistentMapEvent;
+import org.onosproject.store.service.EventuallyConsistentMapListener;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.RouterInterface;
+import org.onosproject.vtnrsc.SubnetId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.router.RouterService;
+import org.onosproject.vtnrsc.routerinterface.RouterInterfaceEvent;
+import org.onosproject.vtnrsc.routerinterface.RouterInterfaceListener;
+import org.onosproject.vtnrsc.routerinterface.RouterInterfaceService;
+import org.onosproject.vtnrsc.subnet.SubnetService;
+import org.onosproject.vtnrsc.virtualport.VirtualPortService;
+import org.slf4j.Logger;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Provides implementation of the Router interface service.
+ */
+@Component(immediate = true)
+@Service
+public class RouterInterfaceManager implements RouterInterfaceService {
+    private static final String SUBNET_ID_NULL = "Subnet ID cannot be null";
+    private static final String ROUTER_INTERFACE_NULL = "Router Interface cannot be null";
+    private static final String ROUTER_INTERFACE = "vtn-router-interface-store";
+    private static final String VTNRSC_APP = "org.onosproject.vtnrsc";
+    private static final String LISTENER_NOT_NULL = "Listener cannot be null";
+    private static final String EVENT_NOT_NULL = "event cannot be null";
+
+    private final Logger log = getLogger(getClass());
+    private final Set<RouterInterfaceListener> listeners = Sets
+            .newCopyOnWriteArraySet();
+    private EventuallyConsistentMapListener<SubnetId, RouterInterface> routerInterfaceListener =
+            new InnerRouterInterfaceStoreListener();
+    protected EventuallyConsistentMap<SubnetId, RouterInterface> routerInterfaceStore;
+    protected ApplicationId appId;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected StorageService storageService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected CoreService coreService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected VirtualPortService virtualPortService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected SubnetService subnetService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected RouterService routerService;
+
+    @Activate
+    public void activate() {
+        appId = coreService.registerApplication(VTNRSC_APP);
+        KryoNamespace.Builder serializer = KryoNamespace
+                .newBuilder()
+                .register(KryoNamespaces.API)
+                .register(RouterId.class, TenantId.class, VirtualPortId.class,
+                          RouterInterface.class, SubnetId.class);
+        routerInterfaceStore = storageService
+                .<SubnetId, RouterInterface>eventuallyConsistentMapBuilder()
+                .withName(ROUTER_INTERFACE).withSerializer(serializer)
+                .withTimestampProvider((k, v) -> new WallClockTimestamp())
+                .build();
+        routerInterfaceStore.addListener(routerInterfaceListener);
+        log.info("Started");
+    }
+
+    @Deactivate
+    public void deactivate() {
+        routerInterfaceStore.removeListener(routerInterfaceListener);
+        routerInterfaceStore.destroy();
+        listeners.clear();
+        log.info("Stopped");
+    }
+
+    @Override
+    public boolean exists(SubnetId subnetId) {
+        checkNotNull(subnetId, SUBNET_ID_NULL);
+        return routerInterfaceStore.containsKey(subnetId);
+    }
+
+    @Override
+    public Collection<RouterInterface> getRouterInterfaces() {
+        return Collections
+                .unmodifiableCollection(routerInterfaceStore.values());
+    }
+
+    @Override
+    public RouterInterface getRouterInterface(SubnetId subnetId) {
+        checkNotNull(subnetId, SUBNET_ID_NULL);
+        return routerInterfaceStore.get(subnetId);
+    }
+
+    @Override
+    public boolean addRouterInterface(RouterInterface routerInterface) {
+        checkNotNull(routerInterface, ROUTER_INTERFACE_NULL);
+        verifyRouterInterfaceData(routerInterface);
+        routerInterfaceStore.put(routerInterface.subnetId(), routerInterface);
+        if (!routerInterfaceStore.containsKey(routerInterface.subnetId())) {
+            log.debug("The router interface is created failed whose identifier is {}",
+                      routerInterface.subnetId().toString());
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean removeRouterInterface(RouterInterface routerInterface) {
+        checkNotNull(routerInterface, ROUTER_INTERFACE_NULL);
+        if (!routerInterfaceStore.containsKey(routerInterface.subnetId())) {
+            log.debug("The router interface is not exist whose identifier is {}",
+                      routerInterface.subnetId().toString());
+            throw new IllegalArgumentException("subnet ID doesn't exist");
+        }
+        verifyRouterInterfaceData(routerInterface);
+        routerInterfaceStore
+                .remove(routerInterface.subnetId(), routerInterface);
+        if (routerInterfaceStore.containsKey(routerInterface.subnetId())) {
+            log.debug("The router interface deleted is failed whose identifier is {}",
+                      routerInterface.subnetId().toString());
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public void addListener(RouterInterfaceListener listener) {
+        checkNotNull(listener, LISTENER_NOT_NULL);
+        listeners.add(listener);
+    }
+
+    @Override
+    public void removeListener(RouterInterfaceListener listener) {
+        checkNotNull(listener, LISTENER_NOT_NULL);
+        listeners.remove(listener);
+    }
+
+    /**
+     * Verifies validity of Router interface data.
+     *
+     * @param routers router instance
+     */
+    private void verifyRouterInterfaceData(RouterInterface routerInterface) {
+        checkNotNull(routerInterface, ROUTER_INTERFACE_NULL);
+        if (!subnetService.exists(routerInterface.subnetId())) {
+            log.debug("The subnet ID of interface is not exist whose identifier is {}",
+                      routerInterface.subnetId().toString());
+            throw new IllegalArgumentException(
+                                               "subnet ID of interface doesn't exist");
+        }
+        if (!virtualPortService.exists(routerInterface.portId())) {
+            log.debug("The port ID of interface is not exist whose identifier is {}",
+                      routerInterface.portId().toString());
+            throw new IllegalArgumentException(
+                                               "port ID of interface doesn't exist");
+        }
+        if (!routerService.exists(routerInterface.routerId())) {
+            log.debug("The router ID of interface is not exist whose identifier is {}",
+                      routerInterface.routerId().toString());
+            throw new IllegalArgumentException(
+                                               "router ID of interface doesn't exist");
+        }
+    }
+
+    private class InnerRouterInterfaceStoreListener
+            implements
+            EventuallyConsistentMapListener<SubnetId, RouterInterface> {
+
+        @Override
+        public void event(EventuallyConsistentMapEvent<SubnetId, RouterInterface> event) {
+            checkNotNull(event, EVENT_NOT_NULL);
+            RouterInterface routerInterface = event.value();
+            if (EventuallyConsistentMapEvent.Type.PUT == event.type()) {
+                notifyListeners(new RouterInterfaceEvent(
+                                                         RouterInterfaceEvent.Type.ROUTER_INTERFACE_PUT,
+                                                         routerInterface));
+            }
+            if (EventuallyConsistentMapEvent.Type.REMOVE == event.type()) {
+                notifyListeners(new RouterInterfaceEvent(
+                                                         RouterInterfaceEvent.Type.ROUTER_INTERFACE_DELETE,
+                                                         routerInterface));
+            }
+        }
+    }
+
+    /**
+     * Notifies specify event to all listeners.
+     *
+     * @param event Floating IP event
+     */
+    private void notifyListeners(RouterInterfaceEvent event) {
+        checkNotNull(event, EVENT_NOT_NULL);
+        listeners.forEach(listener -> listener.event(event));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/impl/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/impl/package-info.java
new file mode 100644
index 00000000..71db9dc5
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/impl/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Provides implementation of the RouterInterface service.
+ */
+package org.onosproject.vtnrsc.routerinterface.impl;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/package-info.java
new file mode 100644
index 00000000..3804089a
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/routerinterface/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Service for interacting with the inventory of RouterInterface.
+ */
+package org.onosproject.vtnrsc.routerinterface;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/VtnRscService.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/VtnRscService.java
new file mode 100644
index 00000000..21161ba5
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/VtnRscService.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2015 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.vtnrsc.service;
+
+import java.util.Iterator;
+
+import org.onlab.packet.MacAddress;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.HostId;
+import org.onosproject.vtnrsc.SegmentationId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.event.VtnRscListener;
+
+/**
+ * Service for interacting with the inventory of Vtn resource.
+ */
+public interface VtnRscService {
+    /**
+     * Adds the specified listener.
+     *
+     * @param listener VtnRsc listener
+     */
+    void addListener(VtnRscListener listener);
+
+    /**
+     * Removes the specified listener.
+     *
+     * @param listener VtnRsc listener
+     */
+    void removeListener(VtnRscListener listener);
+
+    /**
+     * Returns the SegmentationId of tenant.
+     *
+     * @param tenantId tenant identifier
+     * @return SegmentationId the SegmentationId of tenant
+     */
+    SegmentationId getL3vni(TenantId tenantId);
+
+    /**
+     * Returns Classifier Ovs list of the specific tenant.
+     *
+     * @param tenantId tenant identifier
+     * @return iterable collection of Device
+     */
+    Iterator<Device> getClassifierOfTenant(TenantId tenantId);
+
+    /**
+     * Returns Service function forwarders Ovs list of the specific tenant.
+     *
+     * @param tenantId tenant identifier
+     * @return iterable collection of Device
+     */
+    Iterator<Device> getSFFOfTenant(TenantId tenantId);
+
+    /**
+     * Returns gateway mac address of the specific host.
+     *
+     * @param hostId host identifier
+     * @return MacAddress of host
+     */
+    MacAddress getGatewayMac(HostId hostId);
+
+    /**
+     * Checks if a specific port is a service function.
+     *
+     * @param portId port identifier
+     * @return true or false
+     */
+    boolean isServiceFunction(VirtualPortId portId);
+
+    /**
+     * Returns device identifier mapping to the specific port.
+     *
+     * @param portId port identifier
+     * @return device identifier
+     */
+    DeviceId getSFToSFFMaping(VirtualPortId portId);
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/impl/VtnRscManager.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/impl/VtnRscManager.java
new file mode 100644
index 00000000..ec9ca3ef
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/impl/VtnRscManager.java
@@ -0,0 +1,472 @@
+/*
+ * Copyright 2015 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.vtnrsc.service.impl;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.slf4j.LoggerFactory.getLogger;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.apache.felix.scr.annotations.Service;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.MacAddress;
+import org.onlab.util.KryoNamespace;
+import org.onosproject.core.CoreService;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Host;
+import org.onosproject.net.HostId;
+import org.onosproject.net.host.HostEvent;
+import org.onosproject.net.host.HostListener;
+import org.onosproject.net.host.HostService;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.LogicalClockService;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.vtnrsc.FixedIp;
+import org.onosproject.vtnrsc.FloatingIp;
+import org.onosproject.vtnrsc.Router;
+import org.onosproject.vtnrsc.RouterInterface;
+import org.onosproject.vtnrsc.SegmentationId;
+import org.onosproject.vtnrsc.Subnet;
+import org.onosproject.vtnrsc.SubnetId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.VirtualPort;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.event.VtnRscEvent;
+import org.onosproject.vtnrsc.event.VtnRscEventFeedback;
+import org.onosproject.vtnrsc.event.VtnRscListener;
+import org.onosproject.vtnrsc.floatingip.FloatingIpEvent;
+import org.onosproject.vtnrsc.floatingip.FloatingIpListener;
+import org.onosproject.vtnrsc.floatingip.FloatingIpService;
+import org.onosproject.vtnrsc.router.RouterEvent;
+import org.onosproject.vtnrsc.router.RouterListener;
+import org.onosproject.vtnrsc.router.RouterService;
+import org.onosproject.vtnrsc.routerinterface.RouterInterfaceEvent;
+import org.onosproject.vtnrsc.routerinterface.RouterInterfaceListener;
+import org.onosproject.vtnrsc.routerinterface.RouterInterfaceService;
+import org.onosproject.vtnrsc.service.VtnRscService;
+import org.onosproject.vtnrsc.subnet.SubnetService;
+import org.onosproject.vtnrsc.tenantnetwork.TenantNetworkService;
+import org.onosproject.vtnrsc.virtualport.VirtualPortService;
+import org.slf4j.Logger;
+
+import com.google.common.collect.Sets;
+
+/**
+ * Provides implementation of the VtnRsc service.
+ */
+@Component(immediate = true)
+@Service
+public class VtnRscManager implements VtnRscService {
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected CoreService coreService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected StorageService storageService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected LogicalClockService clockService;
+
+    private final Logger log = getLogger(getClass());
+    private final Set<VtnRscListener> listeners = Sets.newCopyOnWriteArraySet();
+    private HostListener hostListener = new InnerHostListener();
+    private FloatingIpListener floatingIpListener = new InnerFloatingIpListener();
+    private RouterListener routerListener = new InnerRouterListener();
+    private RouterInterfaceListener routerInterfaceListener = new InnerRouterInterfaceListener();
+
+    private EventuallyConsistentMap<TenantId, SegmentationId> l3vniMap;
+    private EventuallyConsistentMap<TenantId, Set<DeviceId>> classifierOvsMap;
+    private EventuallyConsistentMap<TenantId, Set<DeviceId>> sffOvsMap;
+
+    private static final String IFACEID = "ifaceid";
+    private static final String RUNNELOPTOPOIC = "tunnel-ops-ids";
+    private static final String LISTENER_NOT_NULL = "listener cannot be null";
+    private static final String EVENT_NOT_NULL = "event cannot be null";
+    private static final String TENANTID_NOT_NULL = "tenantId cannot be null";
+    private static final String DEVICEID_NOT_NULL = "deviceId cannot be null";
+    private static final String OVSMAP_NOT_NULL = "ovsMap cannot be null";
+    private static final String L3VNIMAP = "l3vniMap";
+    private static final String CLASSIFIEROVSMAP = "classifierOvsMap";
+    private static final String SFFOVSMAP = "sffOvsMap";
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected RouterService routerService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected FloatingIpService floatingIpService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected RouterInterfaceService routerInterfaceService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected VirtualPortService virtualPortService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected HostService hostService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected SubnetService subnetService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected TenantNetworkService tenantNetworkService;
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected DeviceService deviceService;
+
+    @Activate
+    public void activate() {
+        hostService.addListener(hostListener);
+        floatingIpService.addListener(floatingIpListener);
+        routerService.addListener(routerListener);
+        routerInterfaceService.addListener(routerInterfaceListener);
+
+        KryoNamespace.Builder serializer = KryoNamespace.newBuilder()
+                .register(KryoNamespaces.API)
+                .register(TenantId.class, DeviceId.class);
+        l3vniMap = storageService
+                .<TenantId, SegmentationId>eventuallyConsistentMapBuilder()
+                .withName(L3VNIMAP).withSerializer(serializer)
+                .withTimestampProvider((k, v) -> clockService.getTimestamp())
+                .build();
+
+        classifierOvsMap = storageService
+                .<TenantId, Set<DeviceId>>eventuallyConsistentMapBuilder()
+                .withName(CLASSIFIEROVSMAP).withSerializer(serializer)
+                .withTimestampProvider((k, v) -> clockService.getTimestamp())
+                .build();
+
+        sffOvsMap = storageService
+                .<TenantId, Set<DeviceId>>eventuallyConsistentMapBuilder()
+                .withName(SFFOVSMAP).withSerializer(serializer)
+                .withTimestampProvider((k, v) -> clockService.getTimestamp())
+                .build();
+    }
+
+    @Deactivate
+    public void deactivate() {
+        hostService.removeListener(hostListener);
+        floatingIpService.removeListener(floatingIpListener);
+        routerService.removeListener(routerListener);
+        routerInterfaceService.removeListener(routerInterfaceListener);
+        l3vniMap.destroy();
+        classifierOvsMap.destroy();
+        sffOvsMap.destroy();
+        listeners.clear();
+        log.info("Stopped");
+    }
+
+    @Override
+    public void addListener(VtnRscListener listener) {
+        checkNotNull(listener, LISTENER_NOT_NULL);
+        listeners.add(listener);
+    }
+
+    @Override
+    public void removeListener(VtnRscListener listener) {
+        checkNotNull(listener, LISTENER_NOT_NULL);
+        listeners.add(listener);
+    }
+
+    @Override
+    public SegmentationId getL3vni(TenantId tenantId) {
+        checkNotNull(tenantId, "tenantId cannot be null");
+        SegmentationId l3vni = l3vniMap.get(tenantId);
+        if (l3vni == null) {
+            long segmentationId = coreService.getIdGenerator(RUNNELOPTOPOIC)
+                    .getNewId();
+            l3vni = SegmentationId.segmentationId(String
+                    .valueOf(segmentationId));
+            l3vniMap.put(tenantId, l3vni);
+        }
+        return l3vni;
+    }
+
+    private class InnerHostListener implements HostListener {
+
+        @Override
+        public void event(HostEvent event) {
+            checkNotNull(event, EVENT_NOT_NULL);
+            Host host = event.subject();
+            String ifaceId = host.annotations().value(IFACEID);
+            VirtualPortId hPortId = VirtualPortId.portId(ifaceId);
+            TenantId tenantId = virtualPortService.getPort(hPortId).tenantId();
+            DeviceId deviceId = host.location().deviceId();
+            if (HostEvent.Type.HOST_ADDED == event.type()) {
+                if (isServiceFunction(hPortId)) {
+                    addDeviceIdOfOvsMap(tenantId, deviceId, sffOvsMap);
+                } else {
+                    addDeviceIdOfOvsMap(tenantId, deviceId, classifierOvsMap);
+                }
+            } else if (HostEvent.Type.HOST_REMOVED == event.type()) {
+                if (isLastSFHostOfTenant(host, deviceId, tenantId)) {
+                    removeDeviceIdOfOvsMap(tenantId, deviceId, sffOvsMap);
+                }
+                if (isLastClassifierHostOfTenant(host, deviceId, tenantId)) {
+                    removeDeviceIdOfOvsMap(tenantId, deviceId, classifierOvsMap);
+                }
+            }
+        }
+    }
+
+    private class InnerFloatingIpListener implements FloatingIpListener {
+
+        @Override
+        public void event(FloatingIpEvent event) {
+            checkNotNull(event, EVENT_NOT_NULL);
+            FloatingIp floatingIp = event.subject();
+            if (FloatingIpEvent.Type.FLOATINGIP_PUT == event.type()) {
+                notifyListeners(new VtnRscEvent(
+                                                VtnRscEvent.Type.FLOATINGIP_PUT,
+                                                new VtnRscEventFeedback(
+                                                                        floatingIp)));
+            }
+            if (FloatingIpEvent.Type.FLOATINGIP_DELETE == event.type()) {
+                notifyListeners(new VtnRscEvent(
+                                                VtnRscEvent.Type.FLOATINGIP_DELETE,
+                                                new VtnRscEventFeedback(
+                                                                        floatingIp)));
+            }
+        }
+    }
+
+    private class InnerRouterListener implements RouterListener {
+
+        @Override
+        public void event(RouterEvent event) {
+            checkNotNull(event, EVENT_NOT_NULL);
+            Router router = event.subject();
+            if (RouterEvent.Type.ROUTER_PUT == event.type()) {
+                notifyListeners(new VtnRscEvent(VtnRscEvent.Type.ROUTER_PUT,
+                                                new VtnRscEventFeedback(router)));
+            }
+            if (RouterEvent.Type.ROUTER_DELETE == event.type()) {
+                notifyListeners(new VtnRscEvent(VtnRscEvent.Type.ROUTER_DELETE,
+                                                new VtnRscEventFeedback(router)));
+            }
+        }
+    }
+
+    private class InnerRouterInterfaceListener
+            implements RouterInterfaceListener {
+
+        @Override
+        public void event(RouterInterfaceEvent event) {
+            checkNotNull(event, EVENT_NOT_NULL);
+            RouterInterface routerInterface = event.subject();
+            if (RouterInterfaceEvent.Type.ROUTER_INTERFACE_PUT == event.type()) {
+                notifyListeners(new VtnRscEvent(
+                                                VtnRscEvent.Type.ROUTER_INTERFACE_PUT,
+                                                new VtnRscEventFeedback(
+                                                                        routerInterface)));
+            }
+            if (RouterInterfaceEvent.Type.ROUTER_INTERFACE_DELETE == event
+                    .type()) {
+                notifyListeners(new VtnRscEvent(
+                                                VtnRscEvent.Type.ROUTER_INTERFACE_DELETE,
+                                                new VtnRscEventFeedback(
+                                                                        routerInterface)));
+            }
+        }
+    }
+
+    @Override
+    public Iterator<Device> getClassifierOfTenant(TenantId tenantId) {
+        checkNotNull(tenantId, TENANTID_NOT_NULL);
+        Set<DeviceId> deviceIdSet = classifierOvsMap.get(tenantId);
+        Set<Device> deviceSet = new HashSet<>();
+        if (deviceIdSet != null) {
+            for (DeviceId deviceId : deviceIdSet) {
+                deviceSet.add(deviceService.getDevice(deviceId));
+            }
+        }
+        return deviceSet.iterator();
+    }
+
+    @Override
+    public Iterator<Device> getSFFOfTenant(TenantId tenantId) {
+        checkNotNull(tenantId, TENANTID_NOT_NULL);
+        Set<DeviceId> deviceIdSet = sffOvsMap.get(tenantId);
+        Set<Device> deviceSet = new HashSet<>();
+        if (deviceIdSet != null) {
+            for (DeviceId deviceId : deviceIdSet) {
+                deviceSet.add(deviceService.getDevice(deviceId));
+            }
+        }
+        return deviceSet.iterator();
+    }
+
+    @Override
+    public MacAddress getGatewayMac(HostId hostId) {
+        checkNotNull(hostId, "hostId cannot be null");
+        Host host = hostService.getHost(hostId);
+        String ifaceId = host.annotations().value(IFACEID);
+        VirtualPortId hPortId = VirtualPortId.portId(ifaceId);
+        VirtualPort hPort = virtualPortService.getPort(hPortId);
+        SubnetId subnetId = hPort.fixedIps().iterator().next().subnetId();
+        Subnet subnet = subnetService.getSubnet(subnetId);
+        IpAddress gatewayIp = subnet.gatewayIp();
+        Iterable<VirtualPort> virtualPorts = virtualPortService.getPorts();
+        MacAddress macAddress = null;
+        for (VirtualPort port : virtualPorts) {
+            Set<FixedIp> fixedIpSet = port.fixedIps();
+            for (FixedIp fixedIp : fixedIpSet) {
+                if (fixedIp.ip().equals(gatewayIp)) {
+                    macAddress = port.macAddress();
+                }
+            }
+        }
+        return macAddress;
+    }
+
+    @Override
+    public boolean isServiceFunction(VirtualPortId portId) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public DeviceId getSFToSFFMaping(VirtualPortId portId) {
+        checkNotNull(portId, "portId cannot be null");
+        VirtualPort vmPort = virtualPortService.getPort(portId);
+        Set<Host> hostSet = hostService.getHostsByMac(vmPort.macAddress());
+        for (Host host : hostSet) {
+            if (host.annotations().value(IFACEID).equals(vmPort.portId())) {
+                return host.location().deviceId();
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Checks whether the last Service Function host of a specific tenant in
+     * this device.
+     *
+     * @param host the host on device
+     * @param deviceId the device identifier
+     * @param tenantId the tenant identifier
+     * @return true or false
+     */
+    private boolean isLastSFHostOfTenant(Host host, DeviceId deviceId,
+                                         TenantId tenantId) {
+        checkNotNull(host, "host cannot be null");
+        checkNotNull(deviceId, DEVICEID_NOT_NULL);
+        checkNotNull(tenantId, TENANTID_NOT_NULL);
+        Set<Host> hostSet = hostService.getConnectedHosts(deviceId);
+        for (Host h : hostSet) {
+            String ifaceId = h.annotations().value(IFACEID);
+            VirtualPortId hPortId = VirtualPortId.portId(ifaceId);
+            if (virtualPortService.getPort(hPortId).tenantId() != tenantId) {
+                hostSet.remove(h);
+            } else {
+                if (!isServiceFunction(hPortId)) {
+                    hostSet.remove(h);
+                }
+            }
+        }
+        if (hostSet.size() == 1 && hostSet.contains(host)) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Checks whether the last Classifier host of a specific tenant in this
+     * device.
+     *
+     * @param host the host on device
+     * @param deviceId the device identifier
+     * @param tenantId the tenant identifier
+     * @return true or false
+     */
+    private boolean isLastClassifierHostOfTenant(Host host, DeviceId deviceId,
+                                                 TenantId tenantId) {
+        checkNotNull(host, "host cannot be null");
+        checkNotNull(deviceId, DEVICEID_NOT_NULL);
+        checkNotNull(tenantId, TENANTID_NOT_NULL);
+        Set<Host> hostSet = hostService.getConnectedHosts(deviceId);
+        for (Host h : hostSet) {
+            String ifaceId = h.annotations().value(IFACEID);
+            VirtualPortId hPortId = VirtualPortId.portId(ifaceId);
+            if (virtualPortService.getPort(hPortId).tenantId() != tenantId) {
+                hostSet.remove(h);
+            } else {
+                if (isServiceFunction(hPortId)) {
+                    hostSet.remove(h);
+                }
+            }
+        }
+        if (hostSet.size() == 1 && hostSet.contains(host)) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Adds specify Device identifier to OvsMap.
+     *
+     * @param tenantId the tenant identifier
+     * @param deviceId the device identifier
+     * @param ovsMap the instance of map to store device identifier
+     */
+    private void addDeviceIdOfOvsMap(TenantId tenantId,
+                                     DeviceId deviceId,
+                                     EventuallyConsistentMap<TenantId, Set<DeviceId>> ovsMap) {
+        checkNotNull(tenantId, TENANTID_NOT_NULL);
+        checkNotNull(deviceId, DEVICEID_NOT_NULL);
+        checkNotNull(ovsMap, OVSMAP_NOT_NULL);
+        if (ovsMap.containsKey(tenantId)) {
+            Set<DeviceId> deviceIdSet = ovsMap.get(tenantId);
+            deviceIdSet.add(deviceId);
+            ovsMap.put(tenantId, deviceIdSet);
+        } else {
+            Set<DeviceId> deviceIdSet = new HashSet<>();
+            deviceIdSet.add(deviceId);
+            ovsMap.put(tenantId, deviceIdSet);
+        }
+    }
+
+    /**
+     * Removes specify Device identifier from OvsMap.
+     *
+     * @param tenantId the tenant identifier
+     * @param deviceId the device identifier
+     * @param ovsMap the instance of map to store device identifier
+     */
+    private void removeDeviceIdOfOvsMap(TenantId tenantId,
+                                        DeviceId deviceId,
+                                        EventuallyConsistentMap<TenantId, Set<DeviceId>> ovsMap) {
+        checkNotNull(tenantId, TENANTID_NOT_NULL);
+        checkNotNull(deviceId, DEVICEID_NOT_NULL);
+        checkNotNull(ovsMap, OVSMAP_NOT_NULL);
+        Set<DeviceId> deviceIdSet = ovsMap.get(tenantId);
+        if (deviceIdSet.size() > 1) {
+            deviceIdSet.remove(deviceId);
+            ovsMap.put(tenantId, deviceIdSet);
+        } else {
+            ovsMap.remove(tenantId);
+        }
+    }
+
+    /**
+     * Notifies specify event to all listeners.
+     *
+     * @param event VtnRsc event
+     */
+    private void notifyListeners(VtnRscEvent event) {
+        checkNotNull(event, EVENT_NOT_NULL);
+        listeners.forEach(listener -> listener.event(event));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/impl/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/impl/package-info.java
new file mode 100644
index 00000000..aaea08b3
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/impl/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Provides implementation of the VtnRsc service.
+ */
+package org.onosproject.vtnrsc.service.impl;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/package-info.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/package-info.java
new file mode 100644
index 00000000..37af604a
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/service/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * Service for interacting with the inventory of Vtn resource.
+ */
+package org.onosproject.vtnrsc.service;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/subnet/impl/SubnetManager.java b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/subnet/impl/SubnetManager.java
index 890beb29..94430389 100644
--- a/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/subnet/impl/SubnetManager.java
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/java/org/onosproject/vtnrsc/subnet/impl/SubnetManager.java
@@ -144,21 +144,19 @@ public class SubnetManager implements SubnetService {
     @Override
     public boolean updateSubnets(Iterable<Subnet> subnets) {
         checkNotNull(subnets, SUBNET_NOT_NULL);
-        if (subnets != null) {
-            for (Subnet subnet : subnets) {
-                if (!subnetStore.containsKey(subnet.id())) {
-                    log.debug("The subnet is not exist whose identifier is {}",
-                              subnet.id().toString());
-                    return false;
-                }
-
-                subnetStore.put(subnet.id(), subnet);
-
-                if (!subnet.equals(subnetStore.get(subnet.id()))) {
-                    log.debug("The subnet is updated failed whose identifier is {}",
-                              subnet.id().toString());
-                    return false;
-                }
+        for (Subnet subnet : subnets) {
+            if (!subnetStore.containsKey(subnet.id())) {
+                log.debug("The subnet is not exist whose identifier is {}",
+                          subnet.id().toString());
+                return false;
+            }
+
+            subnetStore.put(subnet.id(), subnet);
+
+            if (!subnet.equals(subnetStore.get(subnet.id()))) {
+                log.debug("The subnet is updated failed whose identifier is {}",
+                          subnet.id().toString());
+                return false;
             }
         }
         return true;
@@ -167,14 +165,12 @@ public class SubnetManager implements SubnetService {
     @Override
     public boolean removeSubnets(Iterable<SubnetId> subnetIds) {
         checkNotNull(subnetIds, SUBNET_ID_NULL);
-        if (subnetIds != null) {
-            for (SubnetId subnetId : subnetIds) {
-                subnetStore.remove(subnetId);
-                if (subnetStore.containsKey(subnetId)) {
-                    log.debug("The subnet created is failed whose identifier is {}",
-                              subnetId.toString());
-                    return false;
-                }
+        for (SubnetId subnetId : subnetIds) {
+             subnetStore.remove(subnetId);
+            if (subnetStore.containsKey(subnetId)) {
+                log.debug("The subnet created is failed whose identifier is {}",
+                          subnetId.toString());
+                return false;
             }
         }
         return true;
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/framework/src/onos/apps/vtn/vtnrsc/src/main/resources/OSGI-INF/blueprint/shell-config.xml
index c6a9c81b..f7a1bf44 100644
--- a/framework/src/onos/apps/vtn/vtnrsc/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/main/resources/OSGI-INF/blueprint/shell-config.xml
@@ -52,5 +52,38 @@
      <command>
       <action class="org.onosproject.vtnrsc.cli.virtualport.VirtualPortUpdateCommand"/>
     </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.floatingip.FloatingIpCreateCommand"/>
+    </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.floatingip.FloatingIpQueryCommand"/>
+    </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.floatingip.FloatingIpRemoveCommand"/>
+    </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.floatingip.FloatingIpUpdateCommand"/>
+    </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.router.RouterCreateCommand"/>
+    </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.router.RouterQueryCommand"/>
+    </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.router.RouterRemoveCommand"/>
+    </command>
+    <command>
+      <action class="org.onosproject.vtnrsc.cli.router.RouterUpdateCommand"/>
+    </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.routerinterface.RouterInterfaceCreateCommand"/>
+    </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.routerinterface.RouterInterfaceRemoveCommand"/>
+    </command>
+     <command>
+      <action class="org.onosproject.vtnrsc.cli.routerinterface.RouterInterfaceQueryCommand"/>
+    </command>
   </command-bundle>
 </blueprint>
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/AllowedAddressPairTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/AllowedAddressPairTest.java
new file mode 100644
index 00000000..05152359
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/AllowedAddressPairTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.MacAddress;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for AllowedAddressPair class.
+ */
+public class AllowedAddressPairTest {
+
+    final IpAddress ip1 = IpAddress.valueOf("192.168.0.1");
+    final IpAddress ip2 = IpAddress.valueOf("192.168.0.2");
+    final MacAddress mac1 = MacAddress.valueOf("fa:16:3e:76:83:88");
+    final MacAddress mac2 = MacAddress.valueOf("aa:16:3e:76:83:88");
+
+    /**
+     * Checks that the AllowedAddressPair class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(AllowedAddressPair.class);
+    }
+
+    /**
+     * Checks the operation of equals().
+     */
+    @Test
+    public void testEquals() {
+        AllowedAddressPair p1 = AllowedAddressPair
+                .allowedAddressPair(ip1, mac1);
+        AllowedAddressPair p2 = AllowedAddressPair
+                .allowedAddressPair(ip1, mac1);
+        AllowedAddressPair p3 = AllowedAddressPair
+                .allowedAddressPair(ip2, mac2);
+        new EqualsTester().addEqualityGroup(p1, p2).addEqualityGroup(p3)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a AllowedAddressPair object.
+     */
+    @Test
+    public void testConstruction() {
+        AllowedAddressPair allowedAddressPair = AllowedAddressPair
+                .allowedAddressPair(ip1, mac1);
+        assertThat(ip1, is(notNullValue()));
+        assertThat(ip1, is(allowedAddressPair.ip()));
+        assertThat(mac1, is(notNullValue()));
+        assertThat(mac1, is(allowedAddressPair.mac()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultAllocationPoolTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultAllocationPoolTest.java
new file mode 100644
index 00000000..9e7d3c1c
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultAllocationPoolTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for DefaultAllocationPool class.
+ */
+public class DefaultAllocationPoolTest {
+
+    final IpAddress startIP1 = IpAddress.valueOf("192.168.1.1");
+    final IpAddress startIP2 = IpAddress.valueOf("192.168.1.2");
+    final IpAddress endIP1 = IpAddress.valueOf("192.168.1.1");
+    final IpAddress endIP2 = IpAddress.valueOf("192.168.1.2");
+
+    /**
+     * Checks that the DefaultAllocationPool class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(DefaultAllocationPool.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        AllocationPool pool1 = new DefaultAllocationPool(startIP1, endIP1);
+        AllocationPool pool2 = new DefaultAllocationPool(startIP1, endIP1);
+        AllocationPool pool3 = new DefaultAllocationPool(startIP2, endIP2);
+        new EqualsTester().addEqualityGroup(pool1, pool2)
+                .addEqualityGroup(pool3).testEquals();
+    }
+
+    /**
+     * Checks the construction of a DefaultAllocationPool object.
+     */
+    @Test
+    public void testConstruction() {
+        final AllocationPool apool = new DefaultAllocationPool(startIP1, endIP1);
+        assertThat(startIP1, is(apool.startIp()));
+        assertThat(endIP1, is(apool.endIp()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultFlowClassifierTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultFlowClassifierTest.java
new file mode 100644
index 00000000..7032c216
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultFlowClassifierTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+import org.onlab.packet.IpPrefix;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for DefaultFlowClassifier class.
+ */
+public class DefaultFlowClassifierTest {
+    /**
+     * Checks that the DefaultFlowClassifier class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(DefaultFlowClassifier.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        // Create same two flow classifier objects.
+        final String name = "FlowClassifier1";
+        final String description = "FlowClassifier1";
+        final String ethType = "IPv4";
+        final String protocol = "tcp";
+        final int minSrcPortRange = 5;
+        final int maxSrcPortRange = 10;
+        final int minDstPortRange = 5;
+        final int maxDstPortRange = 10;
+        final FlowClassifierId flowClassifierId = FlowClassifierId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId = TenantId.tenantId("1");
+        final IpPrefix srcIpPrefix = IpPrefix.valueOf("0.0.0.0/0");
+        final IpPrefix dstIpPrefix = IpPrefix.valueOf("10.10.10.10/0");
+        final VirtualPortId virtualSrcPort = VirtualPortId.portId("1");
+        final VirtualPortId virtualDstPort = VirtualPortId.portId("2");
+
+        DefaultFlowClassifier.Builder flowClassifierBuilder = new DefaultFlowClassifier.Builder();
+        final FlowClassifier flowClassifier1 = flowClassifierBuilder.setFlowClassifierId(flowClassifierId)
+                .setTenantId(tenantId).setName(name).setDescription(description).setEtherType(ethType)
+                .setProtocol(protocol).setMinSrcPortRange(minSrcPortRange).setMaxSrcPortRange(maxSrcPortRange)
+                .setMinDstPortRange(minDstPortRange).setMaxDstPortRange(maxDstPortRange).setSrcIpPrefix(srcIpPrefix)
+                .setDstIpPrefix(dstIpPrefix).setSrcPort(virtualSrcPort).setDstPort(virtualDstPort).build();
+
+        flowClassifierBuilder = new DefaultFlowClassifier.Builder();
+        final FlowClassifier sameAsFlowClassifier1 = flowClassifierBuilder.setFlowClassifierId(flowClassifierId)
+                .setTenantId(tenantId).setName(name).setDescription(description).setEtherType(ethType)
+                .setProtocol(protocol).setMinSrcPortRange(minSrcPortRange).setMaxSrcPortRange(maxSrcPortRange)
+                .setMinDstPortRange(minDstPortRange).setMaxDstPortRange(maxDstPortRange).setSrcIpPrefix(srcIpPrefix)
+                .setDstIpPrefix(dstIpPrefix).setSrcPort(virtualSrcPort).setDstPort(virtualDstPort).build();
+
+        // Create different classifier object.
+        final String name2 = "FlowClassifier2";
+        final String description2 = "FlowClassifier2";
+        final String ethType2 = "IPv6";
+        final String protocol2 = "udp";
+        final int minSrcPortRange2 = 5;
+        final int maxSrcPortRange2 = 10;
+        final int minDstPortRange2 = 5;
+        final int maxDstPortRange2 = 10;
+        final FlowClassifierId flowClassifierId2 = FlowClassifierId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId2 = TenantId.tenantId("2");
+        final IpPrefix srcIpPrefix2 = IpPrefix.valueOf("0.0.0.0/0");
+        final IpPrefix dstIpPrefix2 = IpPrefix.valueOf("10.10.10.10/0");
+        final VirtualPortId virtualSrcPort2 = VirtualPortId.portId("3");
+        final VirtualPortId virtualDstPort2 = VirtualPortId.portId("4");
+
+        DefaultFlowClassifier.Builder flowClassifierBuilder3 = new DefaultFlowClassifier.Builder();
+        final FlowClassifier flowClassifier2 = flowClassifierBuilder3.setFlowClassifierId(flowClassifierId2)
+                .setTenantId(tenantId2).setName(name2).setDescription(description2).setEtherType(ethType2)
+                .setProtocol(protocol2).setMinSrcPortRange(minSrcPortRange2).setMaxSrcPortRange(maxSrcPortRange2)
+                .setMinDstPortRange(minDstPortRange2).setMaxDstPortRange(maxDstPortRange2).setSrcIpPrefix(srcIpPrefix2)
+                .setDstIpPrefix(dstIpPrefix2).setSrcPort(virtualSrcPort2).setDstPort(virtualDstPort2).build();
+
+        new EqualsTester().addEqualityGroup(flowClassifier1, sameAsFlowClassifier1).addEqualityGroup(flowClassifier2)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a DefaultFlowClassifier object.
+     */
+    @Test
+    public void testConstruction() {
+        final String name = "FlowClassifier";
+        final String description = "FlowClassifier";
+        final String ethType = "IPv4";
+        final String protocol = "tcp";
+        final int minSrcPortRange = 5;
+        final int maxSrcPortRange = 10;
+        final int minDstPortRange = 5;
+        final int maxDstPortRange = 10;
+        final FlowClassifierId flowClassifierId = FlowClassifierId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId = TenantId.tenantId("1");
+        final IpPrefix srcIpPrefix = IpPrefix.valueOf("0.0.0.0/0");
+        final IpPrefix dstIpPrefix = IpPrefix.valueOf("10.10.10.10/0");
+        final VirtualPortId virtualSrcPort = VirtualPortId.portId("1");
+        final VirtualPortId virtualDstPort = VirtualPortId.portId("2");
+
+        DefaultFlowClassifier.Builder flowClassifierBuilder = new DefaultFlowClassifier.Builder();
+        final FlowClassifier flowClassifier = flowClassifierBuilder.setFlowClassifierId(flowClassifierId)
+                .setTenantId(tenantId).setName(name).setDescription(description).setEtherType(ethType)
+                .setProtocol(protocol).setMinSrcPortRange(minSrcPortRange).setMaxSrcPortRange(maxSrcPortRange)
+                .setMinDstPortRange(minDstPortRange).setMaxDstPortRange(maxDstPortRange).setSrcIpPrefix(srcIpPrefix)
+                .setDstIpPrefix(dstIpPrefix).setSrcPort(virtualSrcPort).setDstPort(virtualDstPort).build();
+
+        assertThat(flowClassifierId, is(flowClassifier.flowClassifierId()));
+        assertThat(tenantId, is(flowClassifier.tenantId()));
+        assertThat(name, is(flowClassifier.name()));
+        assertThat(description, is(flowClassifier.description()));
+        assertThat(ethType, is(flowClassifier.etherType()));
+        assertThat(protocol, is(flowClassifier.protocol()));
+        assertThat(minSrcPortRange, is(flowClassifier.minSrcPortRange()));
+        assertThat(maxSrcPortRange, is(flowClassifier.maxSrcPortRange()));
+        assertThat(minDstPortRange, is(flowClassifier.minDstPortRange()));
+        assertThat(maxDstPortRange, is(flowClassifier.maxDstPortRange()));
+        assertThat(srcIpPrefix, is(flowClassifier.srcIpPrefix()));
+        assertThat(dstIpPrefix, is(flowClassifier.dstIpPrefix()));
+        assertThat(virtualSrcPort, is(flowClassifier.srcPort()));
+        assertThat(virtualDstPort, is(flowClassifier.dstPort()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultHostRouteTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultHostRouteTest.java
new file mode 100644
index 00000000..53ead67f
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultHostRouteTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpPrefix;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for DefaultHostRoute class.
+ */
+public class DefaultHostRouteTest {
+    final IpAddress nexthop1 = IpAddress.valueOf("192.168.1.1");
+    final IpAddress nexthop2 = IpAddress.valueOf("192.168.1.2");
+    final IpPrefix destination1 = IpPrefix.valueOf("1.1.1.1/1");
+    final IpPrefix destination2 = IpPrefix.valueOf("1.1.1.1/2");
+
+    /**
+     * Checks that the DefaultHostRoute class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(DefaultHostRoute.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        HostRoute route1 = new DefaultHostRoute(nexthop1, destination1);
+        HostRoute route2 = new DefaultHostRoute(nexthop1, destination1);
+        HostRoute route3 = new DefaultHostRoute(nexthop2, destination2);
+        new EqualsTester().addEqualityGroup(route1, route2)
+                .addEqualityGroup(route3).testEquals();
+    }
+
+    /**
+     * Checks the construction of a DefaultHostRoute object.
+     */
+    @Test
+    public void testConstruction() {
+        final HostRoute host = new DefaultHostRoute(nexthop1, destination1);
+        assertThat(nexthop1, is(host.nexthop()));
+        assertThat(destination1, is(host.destination()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultNeutronNetworkTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultNeutronNetworkTest.java
new file mode 100644
index 00000000..7f186a1d
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultNeutronNetworkTest.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for DefaultNeutronNetwork class.
+ */
+public class DefaultNeutronNetworkTest {
+
+    private String networkIdStr1 = "123";
+    private String networkIdStr2 = "234";
+    private String physicalNetworkStr = "1234";
+    private String tenantIdStr = "345";
+    private String segmentationIdStr = "1";
+    private String name = "456";
+
+    /**
+     * Checks that the DefaultNeutronNetwork class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(DefaultTenantNetwork.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquality() {
+        TenantNetworkId networkid1 = TenantNetworkId.networkId(networkIdStr1);
+        TenantNetworkId networkid2 = TenantNetworkId.networkId(networkIdStr2);
+        PhysicalNetwork physicalNetwork = PhysicalNetwork
+                .physicalNetwork(physicalNetworkStr);
+        TenantId tenantId = TenantId.tenantId(tenantIdStr);
+        SegmentationId segmentationID = SegmentationId
+                .segmentationId(segmentationIdStr);
+        TenantNetwork p1 = new DefaultTenantNetwork(networkid1, name, false,
+                                                    TenantNetwork.State.ACTIVE,
+                                                    false, tenantId, false,
+                                                    TenantNetwork.Type.LOCAL,
+                                                    physicalNetwork,
+                                                    segmentationID);
+        TenantNetwork p2 = new DefaultTenantNetwork(networkid1, name, false,
+                                                    TenantNetwork.State.ACTIVE,
+                                                    false, tenantId, false,
+                                                    TenantNetwork.Type.LOCAL,
+                                                    physicalNetwork,
+                                                    segmentationID);
+        TenantNetwork p3 = new DefaultTenantNetwork(networkid2, name, false,
+                                                    TenantNetwork.State.ACTIVE,
+                                                    false, tenantId, false,
+                                                    TenantNetwork.Type.LOCAL,
+                                                    physicalNetwork,
+                                                    segmentationID);
+        new EqualsTester().addEqualityGroup(p1, p2).addEqualityGroup(p3)
+                .testEquals();
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultPortChainTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultPortChainTest.java
new file mode 100644
index 00000000..27234ac3
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultPortChainTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for DefaultPortChain class.
+ */
+public class DefaultPortChainTest {
+    /**
+     * Checks that the DefaultPortChain class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(DefaultPortChain.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        // Create same two port chain objects.
+        final PortChainId portChainId = PortChainId.of("78888888-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId = TenantId.tenantId("1");
+        final String name = "PortChain1";
+        final String description = "PortChain1";
+        // create list of Port Pair Groups.
+        final List<PortPairGroupId> portPairGroups = new LinkedList<PortPairGroupId>();
+        PortPairGroupId portPairGroupId = PortPairGroupId.of("73333333-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairGroups.add(portPairGroupId);
+        portPairGroupId = PortPairGroupId.of("73333333-fc23-aeb6-f44b-56dc5e2fb3af");
+        portPairGroups.add(portPairGroupId);
+        // create list of Flow classifiers.
+        final List<FlowClassifierId> flowClassifiers = new LinkedList<FlowClassifierId>();
+        FlowClassifierId flowClassifierId = FlowClassifierId.of("74444444-fc23-aeb6-f44b-56dc5e2fb3ae");
+        flowClassifiers.add(flowClassifierId);
+        flowClassifierId = FlowClassifierId.of("74444444-fc23-aeb6-f44b-56dc5e2fb3af");
+        flowClassifiers.add(flowClassifierId);
+
+        DefaultPortChain.Builder portChainBuilder = new DefaultPortChain.Builder();
+        final PortChain portChain1 = portChainBuilder.setId(portChainId).setTenantId(tenantId).setName(name)
+                .setDescription(description).setPortPairGroups(portPairGroups).setFlowClassifiers(flowClassifiers)
+                .build();
+
+        portChainBuilder = new DefaultPortChain.Builder();
+        final PortChain samePortChain1 = portChainBuilder.setId(portChainId).setTenantId(tenantId).setName(name)
+                .setDescription(description).setPortPairGroups(portPairGroups).setFlowClassifiers(flowClassifiers)
+                .build();
+
+        // Create different port chain object.
+        final PortChainId portChainId2 = PortChainId.of("79999999-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId2 = TenantId.tenantId("2");
+        final String name2 = "PortChain2";
+        final String description2 = "PortChain2";
+        // create list of Port Pair Groups.
+        final List<PortPairGroupId> portPairGroups2 = new LinkedList<PortPairGroupId>();
+        portPairGroupId = PortPairGroupId.of("75555555-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairGroups2.add(portPairGroupId);
+        portPairGroupId = PortPairGroupId.of("75555555-fc23-aeb6-f44b-56dc5e2fb3af");
+        portPairGroups2.add(portPairGroupId);
+        // create list of Flow classifiers.
+        final List<FlowClassifierId> flowClassifiers2 = new LinkedList<FlowClassifierId>();
+        flowClassifierId = FlowClassifierId.of("76666666-fc23-aeb6-f44b-56dc5e2fb3ae");
+        flowClassifiers2.add(flowClassifierId);
+        flowClassifierId = FlowClassifierId.of("76666666-fc23-aeb6-f44b-56dc5e2fb3af");
+        flowClassifiers2.add(flowClassifierId);
+
+        portChainBuilder = new DefaultPortChain.Builder();
+        final PortChain portChain2 = portChainBuilder.setId(portChainId2).setTenantId(tenantId2).setName(name2)
+                .setDescription(description2).setPortPairGroups(portPairGroups2).setFlowClassifiers(flowClassifiers2)
+                .build();
+
+        new EqualsTester().addEqualityGroup(portChain1, samePortChain1).addEqualityGroup(portChain2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a DefaultPortChain object.
+     */
+    @Test
+    public void testConstruction() {
+        final PortChainId portChainId = PortChainId.of("78888888-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId = TenantId.tenantId("1");
+        final String name = "PortChain";
+        final String description = "PortChain";
+        // create list of Port Pair Groups.
+        final List<PortPairGroupId> portPairGroups = new LinkedList<PortPairGroupId>();
+        PortPairGroupId portPairGroupId = PortPairGroupId.of("73333333-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairGroups.add(portPairGroupId);
+        portPairGroupId = PortPairGroupId.of("73333333-fc23-aeb6-f44b-56dc5e2fb3af");
+        portPairGroups.add(portPairGroupId);
+        // create list of Flow classifiers.
+        final List<FlowClassifierId> flowClassifiers = new LinkedList<FlowClassifierId>();
+        FlowClassifierId flowClassifierId = FlowClassifierId.of("74444444-fc23-aeb6-f44b-56dc5e2fb3ae");
+        flowClassifiers.add(flowClassifierId);
+        flowClassifierId = FlowClassifierId.of("74444444-fc23-aeb6-f44b-56dc5e2fb3af");
+        flowClassifiers.add(flowClassifierId);
+
+        DefaultPortChain.Builder portChainBuilder = new DefaultPortChain.Builder();
+        final PortChain portChain = portChainBuilder.setId(portChainId).setTenantId(tenantId).setName(name)
+                .setDescription(description).setPortPairGroups(portPairGroups).setFlowClassifiers(flowClassifiers)
+                .build();
+
+        assertThat(portChainId, is(portChain.portChainId()));
+        assertThat(tenantId, is(portChain.tenantId()));
+        assertThat(name, is(portChain.name()));
+        assertThat(description, is(portChain.description()));
+        assertThat(portPairGroups, is(portChain.portPairGroups()));
+        assertThat(flowClassifiers, is(portChain.flowClassifiers()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultPortPairGroupTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultPortPairGroupTest.java
new file mode 100644
index 00000000..1b484e94
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultPortPairGroupTest.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for DefaultPortPairGroup class.
+ */
+public class DefaultPortPairGroupTest {
+    /**
+     * Checks that the DefaultPortPairGroup class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(DefaultPortPairGroup.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        // Create same two port-pair-group objects.
+        final PortPairGroupId portPairGroupId = PortPairGroupId.of("78888888-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId = TenantId.tenantId("1");
+        final String name = "PortPairGroup1";
+        final String description = "PortPairGroup1";
+        // create port-pair-id list
+        final List<PortPairId> portPairList = new LinkedList<PortPairId>();
+        PortPairId portPairId = PortPairId.of("73333333-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairList.add(portPairId);
+        portPairId = PortPairId.of("74444444-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairList.add(portPairId);
+
+        DefaultPortPairGroup.Builder portPairGroupBuilder = new DefaultPortPairGroup.Builder();
+        final PortPairGroup portPairGroup1 = portPairGroupBuilder.setId(portPairGroupId).setTenantId(tenantId)
+                .setName(name).setDescription(description).setPortPairs(portPairList).build();
+
+        portPairGroupBuilder = new DefaultPortPairGroup.Builder();
+        final PortPairGroup samePortPairGroup1 = portPairGroupBuilder.setId(portPairGroupId).setTenantId(tenantId)
+                .setName(name).setDescription(description).setPortPairs(portPairList).build();
+
+        // Create different port-pair-group object.
+        final PortPairGroupId portPairGroupId2 = PortPairGroupId.of("79999999-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId2 = TenantId.tenantId("2");
+        final String name2 = "PortPairGroup2";
+        final String description2 = "PortPairGroup2";
+        // create port-pair-id list
+        final List<PortPairId> portPairList2 = new LinkedList<PortPairId>();
+        portPairId = PortPairId.of("75555555-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairList2.add(portPairId);
+        portPairId = PortPairId.of("75555555-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairList2.add(portPairId);
+
+        portPairGroupBuilder = new DefaultPortPairGroup.Builder();
+        final PortPairGroup portPairGroup2 = portPairGroupBuilder.setId(portPairGroupId2).setTenantId(tenantId2)
+                .setName(name2).setDescription(description2).setPortPairs(portPairList2).build();
+
+        new EqualsTester().addEqualityGroup(portPairGroup1, samePortPairGroup1).addEqualityGroup(portPairGroup2)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a DefaultPortPairGroup object.
+     */
+    @Test
+    public void testConstruction() {
+        final PortPairGroupId portPairGroupId = PortPairGroupId.of("78888888-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId = TenantId.tenantId("1");
+        final String name = "PortPairGroup";
+        final String description = "PortPairGroup";
+        // create port-pair-id list
+        final List<PortPairId> portPairList = new LinkedList<PortPairId>();
+        PortPairId portPairId = PortPairId.of("73333333-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairList.add(portPairId);
+        portPairId = PortPairId.of("74444444-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairList.add(portPairId);
+
+        DefaultPortPairGroup.Builder portPairGroupBuilder = new DefaultPortPairGroup.Builder();
+        final PortPairGroup portPairGroup = portPairGroupBuilder.setId(portPairGroupId).setTenantId(tenantId)
+                .setName(name).setDescription(description).setPortPairs(portPairList).build();
+
+        assertThat(portPairGroupId, is(portPairGroup.portPairGroupId()));
+        assertThat(tenantId, is(portPairGroup.tenantId()));
+        assertThat(name, is(portPairGroup.name()));
+        assertThat(description, is(portPairGroup.description()));
+        assertThat(portPairList, is(portPairGroup.portPairs()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultPortPairTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultPortPairTest.java
new file mode 100644
index 00000000..c8004ce6
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultPortPairTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for DefaultPortPair class.
+ */
+public class DefaultPortPairTest {
+    /**
+     * Checks that the DefaultPortPair class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(DefaultPortPair.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        // Create same two port pair objects.
+        final PortPairId portPairId = PortPairId.of("78888888-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId = TenantId.tenantId("1");
+        final String name = "PortPair1";
+        final String description = "PortPair1";
+        final String ingress = "d3333333-24fc-4fae-af4b-321c5e2eb3d1";
+        final String egress = "a4444444-4a56-2a6e-cd3a-9dee4e2ec345";
+
+        DefaultPortPair.Builder portPairBuilder = new DefaultPortPair.Builder();
+        final PortPair portPair1 = portPairBuilder.setId(portPairId).setTenantId(tenantId).setName(name)
+                .setDescription(description).setIngress(ingress).setEgress(egress).build();
+
+        portPairBuilder = new DefaultPortPair.Builder();
+        final PortPair samePortPair1 = portPairBuilder.setId(portPairId).setTenantId(tenantId).setName(name)
+                .setDescription(description).setIngress(ingress).setEgress(egress).build();
+
+        // Create different port pair object.
+        final PortPairId portPairId2 = PortPairId.of("79999999-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId2 = TenantId.tenantId("2");
+        final String name2 = "PortPair2";
+        final String description2 = "PortPair2";
+        final String ingress2 = "d5555555-24fc-4fae-af4b-321c5e2eb3d1";
+        final String egress2 = "a6666666-4a56-2a6e-cd3a-9dee4e2ec345";
+
+        portPairBuilder = new DefaultPortPair.Builder();
+        final PortPair portPair2 = portPairBuilder.setId(portPairId2).setTenantId(tenantId2).setName(name2)
+                .setDescription(description2).setIngress(ingress2).setEgress(egress2).build();
+
+        new EqualsTester().addEqualityGroup(portPair1, samePortPair1).addEqualityGroup(portPair2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a DefaultPortPair object.
+     */
+    @Test
+    public void testConstruction() {
+        final PortPairId portPairId = PortPairId.of("78888888-fc23-aeb6-f44b-56dc5e2fb3ae");
+        final TenantId tenantId = TenantId.tenantId("1");
+        final String name = "PortPair";
+        final String description = "PortPair";
+        final String ingress = "d3333333-24fc-4fae-af4b-321c5e2eb3d1";
+        final String egress = "a4444444-4a56-2a6e-cd3a-9dee4e2ec345";
+
+        DefaultPortPair.Builder portPairBuilder = new DefaultPortPair.Builder();
+        final PortPair portPair = portPairBuilder.setId(portPairId).setTenantId(tenantId).setName(name)
+                .setDescription(description).setIngress(ingress).setEgress(egress).build();
+
+        assertThat(portPairId, is(portPair.portPairId()));
+        assertThat(tenantId, is(portPair.tenantId()));
+        assertThat(name, is(portPair.name()));
+        assertThat(description, is(portPair.description()));
+        assertThat(ingress, is(portPair.ingress()));
+        assertThat(egress, is(portPair.egress()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultVirtualPortTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultVirtualPortTest.java
new file mode 100644
index 00000000..81d8b14d
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/DefaultVirtualPortTest.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.MacAddress;
+import org.onosproject.net.DeviceId;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.common.testing.EqualsTester;
+
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for DefaultVirtualPort class.
+ */
+public class DefaultVirtualPortTest {
+
+    private Set<FixedIp> fixedIps;
+    private Map<String, String> propertyMap;
+    private Set<AllowedAddressPair> allowedAddressPairs;
+    private Set<SecurityGroup> securityGroups;
+    private VirtualPortId id1;
+    private VirtualPortId id2;
+    private String macAddressStr = "fa:12:3e:56:ee:a2";
+    private String ipAddress = "10.1.1.1";
+    private String deviceStr = "of:000000000000001";
+    private String tenantIdStr = "123";
+    private String portId1 = "1241";
+    private String portId2 = "1242";
+    private String tenantNetworkId = "1234567";
+    private String subnet = "1212";
+    private String hostIdStr = "fa:e2:3e:56:ee:a2";
+
+    private void initVirtualPortId() {
+        id1 = VirtualPortId.portId(portId1);
+        id2 = VirtualPortId.portId(portId2);
+    }
+
+    private void initFixedIpSet() {
+        FixedIp fixedIp = FixedIp.fixedIp(SubnetId.subnetId(subnet),
+                                          IpAddress.valueOf(ipAddress));
+        fixedIps = Sets.newHashSet();
+        fixedIps.add(fixedIp);
+    }
+
+    private void initPropertyMap() {
+        String deviceOwner = "james";
+        propertyMap = Maps.newHashMap();
+        propertyMap.putIfAbsent("deviceOwner", deviceOwner);
+    }
+
+    private void initAddressPairSet() {
+        allowedAddressPairs = Sets.newHashSet();
+        AllowedAddressPair allowedAddressPair = AllowedAddressPair
+                .allowedAddressPair(IpAddress.valueOf(ipAddress),
+                                    MacAddress.valueOf(macAddressStr));
+        allowedAddressPairs.add(allowedAddressPair);
+    }
+
+    private void initSecurityGroupSet() {
+        securityGroups = Sets.newHashSet();
+    }
+
+    /**
+     * Checks that the DefaultVirtualPort class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(SecurityGroup.class);
+    }
+
+    /**
+     * Checks the operation of equals().
+     */
+    @Test
+    public void testEquals() {
+        initVirtualPortId();
+        initFixedIpSet();
+        initPropertyMap();
+        initAddressPairSet();
+        initSecurityGroupSet();
+        TenantNetworkId networkId = TenantNetworkId.networkId(tenantNetworkId);
+        MacAddress macAddress = MacAddress.valueOf(macAddressStr);
+        TenantId tenantId = TenantId.tenantId(tenantIdStr);
+        DeviceId deviceId = DeviceId.deviceId(deviceStr);
+        BindingHostId bindingHostId = BindingHostId.bindingHostId(hostIdStr);
+
+        VirtualPort d1 = new DefaultVirtualPort(id1, networkId, true,
+                                                propertyMap,
+                                                VirtualPort.State.ACTIVE,
+                                                macAddress, tenantId, deviceId,
+                                                fixedIps, bindingHostId,
+                                                allowedAddressPairs,
+                                                securityGroups);
+        VirtualPort d2 = new DefaultVirtualPort(id1, networkId, true,
+                                                propertyMap,
+                                                VirtualPort.State.ACTIVE,
+                                                macAddress, tenantId, deviceId,
+                                                fixedIps, bindingHostId,
+                                                allowedAddressPairs,
+                                                securityGroups);
+        VirtualPort d3 = new DefaultVirtualPort(id2, networkId, true,
+                                                propertyMap,
+                                                VirtualPort.State.ACTIVE,
+                                                macAddress, tenantId, deviceId,
+                                                fixedIps, bindingHostId,
+                                                allowedAddressPairs,
+                                                securityGroups);
+        new EqualsTester().addEqualityGroup(d1, d2).addEqualityGroup(d3)
+                .testEquals();
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/FixedIpTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/FixedIpTest.java
new file mode 100644
index 00000000..d77532a7
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/FixedIpTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for FixedIp class.
+ */
+public class FixedIpTest {
+
+    final SubnetId subnetId1 = SubnetId.subnetId("lef11-95w-4er-9c9c");
+    final SubnetId subnetId2 = SubnetId.subnetId("lefaa-95w-4er-9c9c");
+    final IpAddress ip1 = IpAddress.valueOf("192.168.0.1");
+    final IpAddress ip2 = IpAddress.valueOf("192.168.1.1");
+
+    /**
+     * Checks that the FixedIp class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(FixedIp.class);
+    }
+
+    /**
+     * Checks the operation of equals().
+     */
+    @Test
+    public void testEquals() {
+        FixedIp fixedIp1 = FixedIp.fixedIp(subnetId1, ip1);
+        FixedIp fixedIp2 = FixedIp.fixedIp(subnetId1, ip1);
+        FixedIp fixedIp3 = FixedIp.fixedIp(subnetId2, ip2);
+        new EqualsTester().addEqualityGroup(fixedIp1, fixedIp2)
+                .addEqualityGroup(fixedIp3).testEquals();
+    }
+
+    /**
+     * Checks the construction of a FixedIp object.
+     */
+    @Test
+    public void testConstruction() {
+        FixedIp fixedIp = FixedIp.fixedIp(subnetId1, ip1);
+        assertThat(ip1, is(notNullValue()));
+        assertThat(ip1, is(fixedIp.ip()));
+        assertThat(subnetId1, is(notNullValue()));
+        assertThat(subnetId1, is(fixedIp.subnetId()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/FlowClassifierIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/FlowClassifierIdTest.java
new file mode 100644
index 00000000..0bef00fc
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/FlowClassifierIdTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import java.util.UUID;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for FlowClassifierId class.
+ */
+public class FlowClassifierIdTest {
+
+    final FlowClassifierId flowClassifierId1 = FlowClassifierId
+            .of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final FlowClassifierId sameAsFlowClassifierId1 = FlowClassifierId
+            .of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final FlowClassifierId flowClassifierId2 = FlowClassifierId
+            .of("dace4513-24fc-4fae-af4b-321c5e2eb3d1");
+
+    /**
+     * Checks that the FlowClassifierId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(FlowClassifierId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(flowClassifierId1, sameAsFlowClassifierId1)
+        .addEqualityGroup(flowClassifierId2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a FlowClassifierId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String flowClassifierIdValue = "dace4513-24fc-4fae-af4b-321c5e2eb3d1";
+        final FlowClassifierId flowClassifierId = FlowClassifierId.of(flowClassifierIdValue);
+        assertThat(flowClassifierId, is(notNullValue()));
+        assertThat(flowClassifierId.value(), is(UUID.fromString(flowClassifierIdValue)));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PhysicalNetworkTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PhysicalNetworkTest.java
new file mode 100644
index 00000000..c4f591e7
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PhysicalNetworkTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for PhysicalNetwork class.
+ */
+public class PhysicalNetworkTest {
+
+    final PhysicalNetwork physicalNetwork1 = PhysicalNetwork.physicalNetwork("1");
+    final PhysicalNetwork sameAsPhysicalNetwork1 = PhysicalNetwork.physicalNetwork("1");
+    final PhysicalNetwork physicalNetwork2 = PhysicalNetwork.physicalNetwork("2");
+
+    /**
+     * Checks that the PhysicalNetwork class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(PhysicalNetwork.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(physicalNetwork1, sameAsPhysicalNetwork1)
+                .addEqualityGroup(physicalNetwork2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a PhysicalNetwork object.
+     */
+    @Test
+    public void testConstruction() {
+        final String physicalNetworkValue = "s";
+        final PhysicalNetwork physicalNetwork = PhysicalNetwork
+                .physicalNetwork(physicalNetworkValue);
+        assertThat(physicalNetwork, is(notNullValue()));
+        assertThat(physicalNetwork.physicalNetwork(), is(physicalNetworkValue));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PortChainIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PortChainIdTest.java
new file mode 100644
index 00000000..1e84fc5d
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PortChainIdTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import java.util.UUID;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for PortChainId class.
+ */
+public class PortChainIdTest {
+
+    final PortChainId portChainId1 = PortChainId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final PortChainId sameAsPortChainId1 = PortChainId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final PortChainId portChainId2 = PortChainId.of("dace4513-24fc-4fae-af4b-321c5e2eb3d1");
+
+    /**
+     * Checks that the PortChainId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(PortChainId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(portChainId1, sameAsPortChainId1).addEqualityGroup(portChainId2)
+        .testEquals();
+    }
+
+    /**
+     * Checks the construction of a PortChainId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String portChainIdValue = "dace4513-24fc-4fae-af4b-321c5e2eb3d1";
+        final PortChainId portChainId = PortChainId.of(portChainIdValue);
+        assertThat(portChainId, is(notNullValue()));
+        assertThat(portChainId.value(), is(UUID.fromString(portChainIdValue)));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PortPairGroupIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PortPairGroupIdTest.java
new file mode 100644
index 00000000..20eb24a5
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PortPairGroupIdTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import java.util.UUID;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for PortPairGroupId class.
+ */
+public class PortPairGroupIdTest {
+
+    final PortPairGroupId portPairGroupId1 = PortPairGroupId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final PortPairGroupId sameAsPortPairGroupId1 = PortPairGroupId
+            .of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final PortPairGroupId portPairGroupId2 = PortPairGroupId.of("dace4513-24fc-4fae-af4b-321c5e2eb3d1");
+
+    /**
+     * Checks that the PortPairGroupId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(PortPairGroupId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(portPairGroupId1, sameAsPortPairGroupId1)
+                .addEqualityGroup(portPairGroupId2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a PortPairGroupId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String portPairGroupIdValue = "dace4513-24fc-4fae-af4b-321c5e2eb3d1";
+        final PortPairGroupId portPairGroupId = PortPairGroupId.of(portPairGroupIdValue);
+        assertThat(portPairGroupId, is(notNullValue()));
+        assertThat(portPairGroupId.value(), is(UUID.fromString(portPairGroupIdValue)));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PortPairIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PortPairIdTest.java
new file mode 100644
index 00000000..757d3a69
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/PortPairIdTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import java.util.UUID;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for PortPairId class.
+ */
+public class PortPairIdTest {
+
+    final PortPairId portPairId1 = PortPairId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final PortPairId sameAsPortPairId1 = PortPairId.of("78dcd363-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final PortPairId portPairId2 = PortPairId.of("dace4513-24fc-4fae-af4b-321c5e2eb3d1");
+
+    /**
+     * Checks that the PortPairId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(PortPairId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(portPairId1, sameAsPortPairId1).addEqualityGroup(portPairId2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a PortPairId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String portPairIdValue = "dace4513-24fc-4fae-af4b-321c5e2eb3d1";
+        final PortPairId portPairId = PortPairId.of(portPairIdValue);
+        assertThat(portPairId, is(notNullValue()));
+        assertThat(portPairId.value(), is(UUID.fromString(portPairIdValue)));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/RouterGatewayTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/RouterGatewayTest.java
new file mode 100644
index 00000000..9f60de8f
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/RouterGatewayTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for RouterGateway class.
+ */
+public class RouterGatewayTest {
+    final TenantNetworkId networkId1 = TenantNetworkId.networkId("1");
+    final TenantNetworkId networkId2 = TenantNetworkId.networkId("2");
+    final Set<FixedIp> fixedIpSet1 = new HashSet<>();
+    final Set<FixedIp> fixedIpSet2 = new HashSet<>();
+
+    /**
+     * Checks that the RouterGateway class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(RouterGateway.class);
+    }
+
+    /**
+     * Checks the operation of equals().
+     */
+    @Test
+    public void testEquals() {
+        RouterGateway routerGateway1 = RouterGateway.routerGateway(networkId1,
+                                                                   true,
+                                                                   fixedIpSet1);
+        RouterGateway routerGateway2 = RouterGateway.routerGateway(networkId1,
+                                                                   true,
+                                                                   fixedIpSet1);
+        RouterGateway routerGateway3 = RouterGateway.routerGateway(networkId2,
+                                                                   true,
+                                                                   fixedIpSet2);
+        new EqualsTester().addEqualityGroup(routerGateway1, routerGateway2)
+                .addEqualityGroup(routerGateway3).testEquals();
+    }
+
+    /**
+     * Checks the construction of a RouterGateway object.
+     */
+    @Test
+    public void testConstruction() {
+        RouterGateway routerGateway = RouterGateway.routerGateway(networkId1,
+                                                                  true,
+                                                                  fixedIpSet1);
+        assertThat(fixedIpSet1, is(notNullValue()));
+        assertThat(fixedIpSet1, is(routerGateway.externalFixedIps()));
+        assertThat(networkId1, is(notNullValue()));
+        assertThat(networkId1, is(routerGateway.networkId()));
+        assertThat(routerGateway.enableSnat(), is(true));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/RouterIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/RouterIdTest.java
new file mode 100644
index 00000000..225211b9
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/RouterIdTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for RouterId class.
+ */
+public class RouterIdTest {
+    final RouterId routerId1 = RouterId.valueOf("1");
+    final RouterId sameAsRouterId1 = RouterId.valueOf("1");
+    final RouterId routerId2 = RouterId.valueOf("2");
+
+    /**
+     * Checks that the RouterId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(RouterId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(routerId1, sameAsRouterId1).addEqualityGroup(routerId2)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a RouterId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String routerIdValue = "s";
+        final RouterId routerId = RouterId.valueOf(routerIdValue);
+        assertThat(routerId, is(notNullValue()));
+        assertThat(routerId.routerId(), is(routerIdValue));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/SecurityGroupTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/SecurityGroupTest.java
new file mode 100644
index 00000000..20871c02
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/SecurityGroupTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for SecurityGroup class.
+ */
+public class SecurityGroupTest {
+
+    final SecurityGroup securityGroup1 = SecurityGroup.securityGroup("1");
+    final SecurityGroup sameAssecurityGroup = SecurityGroup.securityGroup("1");
+    final SecurityGroup securityGroup2 = SecurityGroup.securityGroup("2");
+
+    /**
+     * Checks that the SecurityGroup class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(SecurityGroup.class);
+    }
+
+    /**
+     * Checks the operation of equals().
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(securityGroup1, sameAssecurityGroup)
+                .addEqualityGroup(securityGroup2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a SecurityGroup object.
+     */
+    @Test
+    public void testConstruction() {
+        final String securityGroupValue = "1";
+        final SecurityGroup securityGroup = SecurityGroup.securityGroup(securityGroupValue);
+        assertThat(securityGroup, is(notNullValue()));
+        assertThat(securityGroup.securityGroup(), is(securityGroupValue));
+
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/SegmentationIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/SegmentationIdTest.java
new file mode 100644
index 00000000..dfb3dcf8
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/SegmentationIdTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for SegmentationId class.
+ */
+public class SegmentationIdTest {
+
+    final SegmentationId segmentationID1 = SegmentationId.segmentationId("1");
+    final SegmentationId sameAsSegmentationID1 = SegmentationId.segmentationId("1");
+    final SegmentationId segmentationID2 = SegmentationId.segmentationId("2");
+
+    /**
+     * Checks that the SegmentationId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(SegmentationId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(segmentationID1, sameAsSegmentationID1)
+                .addEqualityGroup(segmentationID2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a segmentationId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String segmentationIdValue = "s";
+        final SegmentationId segmentationId = SegmentationId.segmentationId(segmentationIdValue);
+        assertThat(segmentationId, is(notNullValue()));
+        assertThat(segmentationId.segmentationId(), is(segmentationIdValue));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/SubnetIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/SubnetIdTest.java
new file mode 100644
index 00000000..5a1809ce
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/SubnetIdTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for SubnetId class.
+ */
+public class SubnetIdTest {
+
+    final SubnetId subnetId1 = SubnetId.subnetId("1");
+    final SubnetId sameAsSubnetId1 = SubnetId.subnetId("1");
+    final SubnetId subnetId2 = SubnetId.subnetId("2");
+
+    /**
+     * Checks that the SubnetId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(SubnetId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(subnetId1, sameAsSubnetId1).addEqualityGroup(subnetId2)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a SubnetId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String subnetIdValue = "s";
+        final SubnetId subnetId = SubnetId.subnetId(subnetIdValue);
+        assertThat(subnetId, is(notNullValue()));
+        assertThat(subnetId.subnetId(), is(subnetIdValue));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/TenantIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/TenantIdTest.java
new file mode 100644
index 00000000..f601d427
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/TenantIdTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for TenantId class.
+ */
+public class TenantIdTest {
+
+    final TenantId tenantId1 = TenantId.tenantId("1");
+    final TenantId sameAsTenantId1 = TenantId.tenantId("1");
+    final TenantId tenantId2 = TenantId.tenantId("2");
+
+    /**
+     * Checks that the TenantId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(TenantId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(tenantId1, sameAsTenantId1).addEqualityGroup(tenantId2)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a TenantId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String tenantIdValue = "s";
+        final TenantId tenantId = TenantId.tenantId(tenantIdValue);
+        assertThat(tenantId, is(notNullValue()));
+        assertThat(tenantId.tenantId(), is(tenantIdValue));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/TenantNetworkIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/TenantNetworkIdTest.java
new file mode 100644
index 00000000..3bd72026
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/TenantNetworkIdTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for TenantNetworkId class.
+ */
+public class TenantNetworkIdTest {
+
+    final TenantNetworkId networkId1 = TenantNetworkId.networkId("1");
+    final TenantNetworkId sameAsnetworkId1 = TenantNetworkId.networkId("1");
+    final TenantNetworkId networkId2 = TenantNetworkId.networkId("2");
+
+    /**
+     * Checks that the TenantNetworkId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(TenantNetworkId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(networkId1, sameAsnetworkId1)
+                .addEqualityGroup(networkId2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a TenantNetworkId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String networkIdValue = "s";
+        final TenantNetworkId networkId = TenantNetworkId.networkId(networkIdValue);
+        assertThat(networkId, is(notNullValue()));
+        assertThat(networkId.networkId(), is(networkIdValue));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/VirtualPortIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/VirtualPortIdTest.java
new file mode 100644
index 00000000..70966118
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/VirtualPortIdTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2015 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.vtnrsc;
+
+import org.junit.Test;
+
+import com.google.common.testing.EqualsTester;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+/**
+ * Unit tests for VirtualPortId class.
+ */
+public class VirtualPortIdTest {
+
+    final VirtualPortId virtualPortId1 = VirtualPortId.portId("1");
+    final VirtualPortId sameAsVirtualPortId1 = VirtualPortId.portId("1");
+    final VirtualPortId virtualPortId2 = VirtualPortId.portId("2");
+
+    /**
+     * Checks that the VirtualPortId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(VirtualPortId.class);
+    }
+
+    /**
+     * Checks the operation of equals().
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester().addEqualityGroup(virtualPortId1, sameAsVirtualPortId1)
+                .addEqualityGroup(virtualPortId2).testEquals();
+    }
+
+    /**
+     * Checks the construction of a VirtualPortId object.
+     */
+    @Test
+    public void testConstruction() {
+        final String vPortIdValue = "aaa";
+        final VirtualPortId virtualPortId = VirtualPortId.portId(vPortIdValue);
+        assertThat(virtualPortId, is(notNullValue()));
+        assertThat(virtualPortId.portId(), is(vPortIdValue));
+
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/floatingip/DefaultFloatingIpTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/floatingip/DefaultFloatingIpTest.java
new file mode 100644
index 00000000..d6826f5d
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/floatingip/DefaultFloatingIpTest.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2015 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.vtnrsc.floatingip;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+import org.junit.Test;
+import org.onlab.packet.IpAddress;
+import org.onosproject.vtnrsc.DefaultFloatingIp;
+import org.onosproject.vtnrsc.FloatingIp;
+import org.onosproject.vtnrsc.FloatingIpId;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.TenantNetworkId;
+import org.onosproject.vtnrsc.VirtualPortId;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Unit tests for DefaultFloatingIp class.
+ */
+public class DefaultFloatingIpTest {
+
+    private String floatingIpIdStr1 = "5fb63824-4d5c-4b85-9f2f-ebb93c9ce3df";
+    private String floatingIpIdStr2 = "fa44f585-fe02-40d3-afe7-d1d7e5782c99";
+    private String floatingIpStr = "10.1.1.2";
+    private String fixedIpStr = "192.168.1.2";
+    private String tenantIdStr = "123";
+    private String tenantNetworkId = "1234567";
+    private String virtualPortId = "1212";
+    private String routerIdStr = "123";
+
+    /**
+     * Checks that the DefaultFloatingIp class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(DefaultFloatingIp.class);
+    }
+
+    /**
+     * Checks the operation of equals().
+     */
+    @Test
+    public void testEquals() {
+        final TenantId tenantId = TenantId.tenantId(tenantIdStr);
+        final TenantNetworkId networkId = TenantNetworkId
+                .networkId(tenantNetworkId);
+        final VirtualPortId portId = VirtualPortId.portId(virtualPortId);
+        final RouterId routerId = RouterId.valueOf(routerIdStr);
+        final FloatingIpId id1 = FloatingIpId.of(floatingIpIdStr1);
+        final FloatingIpId id2 = FloatingIpId.of(floatingIpIdStr2);
+        final IpAddress floatingIpAddress = IpAddress.valueOf(floatingIpStr);
+        final IpAddress fixedIpAddress = IpAddress.valueOf(fixedIpStr);
+
+        FloatingIp fip1 = new DefaultFloatingIp(id1, tenantId, networkId,
+                                                portId, routerId,
+                                                floatingIpAddress,
+                                                fixedIpAddress,
+                                                FloatingIp.Status.ACTIVE);
+        FloatingIp fip2 = new DefaultFloatingIp(id1, tenantId, networkId,
+                                                portId, routerId,
+                                                floatingIpAddress,
+                                                fixedIpAddress,
+                                                FloatingIp.Status.ACTIVE);
+        FloatingIp fip3 = new DefaultFloatingIp(id2, tenantId, networkId,
+                                                portId, routerId,
+                                                floatingIpAddress,
+                                                fixedIpAddress,
+                                                FloatingIp.Status.ACTIVE);
+
+        new EqualsTester().addEqualityGroup(fip1, fip2).addEqualityGroup(fip3)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a DefaultFloatingIp object.
+     */
+    @Test
+    public void testConstruction() {
+        final TenantId tenantId = TenantId.tenantId(tenantIdStr);
+        final TenantNetworkId networkId = TenantNetworkId
+                .networkId(tenantNetworkId);
+        final VirtualPortId portId = VirtualPortId.portId(virtualPortId);
+        final RouterId routerId = RouterId.valueOf(routerIdStr);
+        final FloatingIpId id = FloatingIpId.of(floatingIpIdStr1);
+        final IpAddress floatingIpAddress = IpAddress.valueOf(floatingIpStr);
+        final IpAddress fixedIpAddress = IpAddress.valueOf(fixedIpStr);
+
+        FloatingIp fip = new DefaultFloatingIp(id, tenantId, networkId, portId,
+                                               routerId, floatingIpAddress,
+                                               fixedIpAddress,
+                                               FloatingIp.Status.ACTIVE);
+        assertThat(id, is(notNullValue()));
+        assertThat(id, is(fip.id()));
+        assertThat(tenantId, is(notNullValue()));
+        assertThat(tenantId, is(fip.tenantId()));
+        assertThat(networkId, is(notNullValue()));
+        assertThat(networkId, is(fip.networkId()));
+        assertThat(portId, is(notNullValue()));
+        assertThat(portId, is(fip.portId()));
+        assertThat(routerId, is(notNullValue()));
+        assertThat(routerId, is(fip.routerId()));
+        assertThat(floatingIpAddress, is(notNullValue()));
+        assertThat(floatingIpAddress, is(fip.floatingIp()));
+        assertThat(fixedIpAddress, is(notNullValue()));
+        assertThat(fixedIpAddress, is(fip.fixedIp()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/floatingip/FloatingIpIdTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/floatingip/FloatingIpIdTest.java
new file mode 100644
index 00000000..6ae27e9e
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/floatingip/FloatingIpIdTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2015 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.vtnrsc.floatingip;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+import org.junit.Test;
+import org.onosproject.vtnrsc.FloatingIpId;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Unit tests for FloatingIpId class.
+ */
+public class FloatingIpIdTest {
+    private String floatingIpIdStr1 = "5fb63824-4d5c-4b85-9f2f-ebb93c9ce3df";
+    private String floatingIpIdStr2 = "fa44f585-fe02-40d3-afe7-d1d7e5782c99";
+
+    /**
+     * Checks that the FloatingIpId class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(FloatingIpId.class);
+    }
+
+    /**
+     * Checks the operation of equals() methods.
+     */
+    @Test
+    public void testEquals() {
+        FloatingIpId id1 = FloatingIpId.of(floatingIpIdStr1);
+        FloatingIpId id2 = FloatingIpId.of(floatingIpIdStr1);
+        FloatingIpId id3 = FloatingIpId.of(floatingIpIdStr2);
+        new EqualsTester().addEqualityGroup(id1, id2).addEqualityGroup(id3)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a FloatingIpId object.
+     */
+    @Test
+    public void testConstruction() {
+        final FloatingIpId id = FloatingIpId.of(floatingIpIdStr1);
+        assertThat(id, is(notNullValue()));
+        assertThat(id.floatingIpId().toString(), is(floatingIpIdStr1));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/flowclassifier/impl/FlowClassifierManagerTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/flowclassifier/impl/FlowClassifierManagerTest.java
new file mode 100644
index 00000000..8283a52b
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/flowclassifier/impl/FlowClassifierManagerTest.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2015 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.vtnrsc.flowclassifier.impl;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+
+import org.junit.Test;
+
+import org.onlab.packet.IpPrefix;
+
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.DefaultFlowClassifier;
+import org.onosproject.vtnrsc.FlowClassifierId;
+import org.onosproject.vtnrsc.VirtualPortId;
+import org.onosproject.vtnrsc.FlowClassifier;
+import org.onosproject.vtnrsc.util.VtnStorageServiceTest;
+
+/**
+ * Unit tests for FlowClassifierManager class.
+ */
+public class FlowClassifierManagerTest {
+
+    final String name = "FlowClassifier";
+    final String description = "FlowClassifier";
+    final String ethType = "IPv4";
+    final String protocol = "udp";
+    final int minSrcPortRange = 1024;
+    final int maxSrcPortRange = 5000;
+    final int minDstPortRange = 1024;
+    final int maxDstPortRange = 5000;
+    final FlowClassifierId flowClassifierId = FlowClassifierId.of("71111111-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final TenantId tenantId = TenantId.tenantId("8");
+    final IpPrefix srcIpPrefix = IpPrefix.valueOf("0.0.0.0/0");
+    final IpPrefix dstIpPrefix = IpPrefix.valueOf("100.100.100.100/0");
+    final VirtualPortId virtualSrcPort = VirtualPortId.portId("100");
+    final VirtualPortId virtualDstPort = VirtualPortId.portId("200");
+    DefaultFlowClassifier.Builder flowClassifierBuilder = new DefaultFlowClassifier.Builder();
+    FlowClassifierManager flowClassifierMgr = new FlowClassifierManager();
+    FlowClassifier flowClassifier = null;
+    private final VtnStorageServiceTest storageService = new VtnStorageServiceTest();
+
+    /**
+     * Checks the operation of createFlowClassifier() method.
+     */
+    @Test
+    public void testCreateFlowClassifier() {
+        // initialize flow classifier manager
+        flowClassifierMgr.storageService = storageService;
+        flowClassifierMgr.activate();
+
+        // create flow classifier
+        flowClassifier = flowClassifierBuilder.setFlowClassifierId(flowClassifierId).setTenantId(tenantId)
+                .setName(name).setDescription(description).setEtherType(ethType).setProtocol(protocol)
+                .setMinSrcPortRange(minSrcPortRange).setMaxSrcPortRange(maxSrcPortRange)
+                .setMinDstPortRange(minDstPortRange).setMaxDstPortRange(maxDstPortRange).setSrcIpPrefix(srcIpPrefix)
+                .setDstIpPrefix(dstIpPrefix).setSrcPort(virtualSrcPort).setDstPort(virtualDstPort).build();
+        assertThat(flowClassifierMgr.createFlowClassifier(flowClassifier), is(true));
+    }
+
+    /**
+     * Checks the operation of exists() method.
+     */
+    @Test
+    public void testExists() {
+        testCreateFlowClassifier();
+        assertThat(flowClassifierMgr.exists(flowClassifierId), is(true));
+    }
+
+    /**
+     * Checks the operation of getFlowClassifierCount() method.
+     */
+    @Test
+    public void testGetFlowClassifierCount() {
+        testCreateFlowClassifier();
+        assertThat(flowClassifierMgr.getFlowClassifierCount(), is(1));
+    }
+
+    /**
+     * Checks the operation of getFlowClassifiers() method.
+     */
+    @Test
+    public void testGetFlowClassifiers() {
+        testCreateFlowClassifier();
+        final Iterable<FlowClassifier> flowClassifierList = flowClassifierMgr.getFlowClassifiers();
+        assertThat(flowClassifierList, is(notNullValue()));
+        assertThat(flowClassifierList.iterator().hasNext(), is(true));
+    }
+
+    /**
+     * Checks the operation of getFlowClassifier() method.
+     */
+    @Test
+    public void testGetFlowClassifier() {
+        testCreateFlowClassifier();
+        assertThat(flowClassifier, is(notNullValue()));
+        assertThat(flowClassifierMgr.getFlowClassifier(flowClassifierId), is(flowClassifier));
+    }
+
+    /**
+     * Checks the operation of updateFlowClassifier() method.
+     */
+    @Test
+    public void testUpdateFlowClassifier() {
+        // create a flow classifier
+        testCreateFlowClassifier();
+
+        // new updates
+        final String name2 = "FlowClassifier2";
+        final String description2 = "FlowClassifier2";
+        final String ethType2 = "IPv6";
+        final String protocol2 = "tcp";
+        final TenantId tenantId2 = TenantId.tenantId("10");
+        final VirtualPortId virtualSrcPort2 = VirtualPortId.portId("300");
+        final VirtualPortId virtualDstPort2 = VirtualPortId.portId("400");
+        flowClassifier = flowClassifierBuilder.setFlowClassifierId(flowClassifierId)
+                .setTenantId(tenantId2).setName(name2).setDescription(description2).setEtherType(ethType2)
+                .setProtocol(protocol2).setMinSrcPortRange(minSrcPortRange).setMaxSrcPortRange(maxSrcPortRange)
+                .setMinDstPortRange(minDstPortRange).setMaxDstPortRange(maxDstPortRange).setSrcIpPrefix(srcIpPrefix)
+                .setDstIpPrefix(dstIpPrefix).setSrcPort(virtualSrcPort2).setDstPort(virtualDstPort2).build();
+        assertThat(flowClassifierMgr.updateFlowClassifier(flowClassifier), is(true));
+    }
+
+    /**
+     * Checks the operation of removeFlowClassifier() method.
+     */
+    @Test
+    public void testRemoveFlowClassifier() {
+        testCreateFlowClassifier();
+        assertThat(flowClassifierMgr.removeFlowClassifier(flowClassifierId), is(true));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/portchain/impl/PortChainManagerTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/portchain/impl/PortChainManagerTest.java
new file mode 100644
index 00000000..0831ec9c
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/portchain/impl/PortChainManagerTest.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2015 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.vtnrsc.portchain.impl;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+
+import org.junit.Test;
+import java.util.List;
+import java.util.LinkedList;
+
+import org.onosproject.vtnrsc.PortChainId;
+import org.onosproject.vtnrsc.PortPairGroupId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.FlowClassifierId;
+import org.onosproject.vtnrsc.PortChain;
+import org.onosproject.vtnrsc.DefaultPortChain;
+import org.onosproject.vtnrsc.DefaultFlowClassifier;
+import org.onosproject.vtnrsc.util.VtnStorageServiceTest;
+
+/**
+ * Unit tests for PortChainManager class.
+ */
+public class PortChainManagerTest {
+    final PortChainId portChainId = PortChainId.of("78888888-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final TenantId tenantId = TenantId.tenantId("1");
+    final String name = "PortChain";
+    final String description = "PortChain";
+    final List<PortPairGroupId> portPairGroupList = new LinkedList<PortPairGroupId>();
+    final List<FlowClassifierId> flowClassifierList = new LinkedList<FlowClassifierId>();
+    DefaultPortChain.Builder portChainBuilder = new DefaultPortChain.Builder();
+    DefaultFlowClassifier.Builder flowClassifierBuilder = new DefaultFlowClassifier.Builder();
+    PortChainManager portChainMgr = new PortChainManager();
+    PortChain portChain = null;
+    private final VtnStorageServiceTest storageService = new VtnStorageServiceTest();
+
+    /**
+     * Checks the operation of createPortChain() method.
+     */
+    @Test
+    public void testCreatePortChain() {
+        // initialize port chain manager
+        portChainMgr.storageService = storageService;
+        portChainMgr.activate();
+
+        // create list of Port Pair Groups.
+        PortPairGroupId portPairGroupId = PortPairGroupId.of("73333333-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairGroupList.add(portPairGroupId);
+        portPairGroupId = PortPairGroupId.of("73333333-fc23-aeb6-f44b-56dc5e2fb3af");
+        portPairGroupList.add(portPairGroupId);
+
+        // create list of Flow classifiers.
+        FlowClassifierId flowClassifierId = FlowClassifierId.of("74444444-fc23-aeb6-f44b-56dc5e2fb3ae");
+        flowClassifierList.add(flowClassifierId);
+        flowClassifierId = FlowClassifierId.of("74444444-fc23-aeb6-f44b-56dc5e2fb3af");
+        flowClassifierList.add(flowClassifierId);
+
+        // create port chain
+        portChain = portChainBuilder.setId(portChainId).setTenantId(tenantId).setName(name).setDescription(description)
+                .setPortPairGroups(portPairGroupList).setFlowClassifiers(flowClassifierList).build();
+        assertThat(portChainMgr.createPortChain(portChain), is(true));
+    }
+
+    /**
+     * Checks the operation of exists() method.
+     */
+    @Test
+    public void testExists() {
+        testCreatePortChain();
+        assertThat(portChainMgr.exists(portChainId), is(true));
+    }
+
+    /**
+     * Checks the operation of getPortChainCount() method.
+     */
+    @Test
+    public void testGetPortChainCount() {
+        testCreatePortChain();
+        assertThat(portChainMgr.getPortChainCount(), is(1));
+    }
+
+    /**
+     * Checks the operation of getPortChains() method.
+     */
+    @Test
+    public void testGetPortChains() {
+        testCreatePortChain();
+        final Iterable<PortChain> portChainList = portChainMgr.getPortChains();
+        assertThat(portChainList, is(notNullValue()));
+        assertThat(portChainList.iterator().hasNext(), is(true));
+    }
+
+    /**
+     * Checks the operation of getPortChain() method.
+     */
+    @Test
+    public void testGetPortChain() {
+        testCreatePortChain();
+        assertThat(portChain, is(notNullValue()));
+        assertThat(portChainMgr.getPortChain(portChainId), is(portChain));
+    }
+
+    /**
+     * Checks the operation of updatePortChain() method.
+     */
+    @Test
+    public void testUpdatePortChain() {
+        // create a port chain
+        testCreatePortChain();
+
+        // new updates
+        final TenantId tenantId2 = TenantId.tenantId("2");
+        final String name2 = "PortChain2";
+        final String description2 = "PortChain2";
+        // create list of Port Pair Groups.
+        final List<PortPairGroupId> portPairGroupList = new LinkedList<PortPairGroupId>();
+        PortPairGroupId portPairGroupId = PortPairGroupId.of("75555555-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairGroupList.add(portPairGroupId);
+        portPairGroupId = PortPairGroupId.of("75555555-fc23-aeb6-f44b-56dc5e2fb3af");
+        portPairGroupList.add(portPairGroupId);
+        // create list of Flow classifiers.
+        final List<FlowClassifierId> flowClassifierList = new LinkedList<FlowClassifierId>();
+        FlowClassifierId flowClassifierId = FlowClassifierId.of("76666666-fc23-aeb6-f44b-56dc5e2fb3ae");
+        flowClassifierList.add(flowClassifierId);
+        flowClassifierId = FlowClassifierId.of("76666666-fc23-aeb6-f44b-56dc5e2fb3af");
+        flowClassifierList.add(flowClassifierId);
+        portChain = portChainBuilder.setId(portChainId).setTenantId(tenantId2).setName(name2)
+                .setDescription(description2).setPortPairGroups(portPairGroupList)
+                .setFlowClassifiers(flowClassifierList).build();
+        assertThat(portChainMgr.updatePortChain(portChain), is(true));
+    }
+
+    /**
+     * Checks the operation of removePortChain() method.
+     */
+    @Test
+    public void testRemovePortChain() {
+        testCreatePortChain();
+        assertThat(portChainMgr.removePortChain(portChainId), is(true));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/portpair/impl/PortPairManagerTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/portpair/impl/PortPairManagerTest.java
new file mode 100644
index 00000000..c936d7cc
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/portpair/impl/PortPairManagerTest.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2015 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.vtnrsc.portpair.impl;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+
+import org.junit.Test;
+
+import org.onosproject.vtnrsc.PortPair;
+import org.onosproject.vtnrsc.PortPairId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.DefaultPortPair;
+import org.onosproject.vtnrsc.util.VtnStorageServiceTest;
+
+/**
+ * Unit tests for PortPairManager class.
+ */
+public class PortPairManagerTest {
+    final PortPairId portPairId = PortPairId.of("78888888-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final TenantId tenantId = TenantId.tenantId("1");
+    final String name = "PortPair";
+    final String description = "PortPair";
+    final String ingress = "d3333333-24fc-4fae-af4b-321c5e2eb3d1";
+    final String egress = "a4444444-4a56-2a6e-cd3a-9dee4e2ec345";
+    DefaultPortPair.Builder portPairBuilder = new DefaultPortPair.Builder();
+    PortPairManager portPairMgr = new PortPairManager();
+    PortPair portPair = null;
+    private final VtnStorageServiceTest storageService = new VtnStorageServiceTest();
+
+    /**
+     * Checks the operation of createPortPair() method.
+     */
+    @Test
+    public void testCreatePortPair() {
+        // initialize port pair manager
+        portPairMgr.storageService = storageService;
+        portPairMgr.activate();
+
+        // create port pair
+        portPair = portPairBuilder.setId(portPairId).setTenantId(tenantId).setName(name)
+                .setDescription(description).setIngress(ingress).setEgress(egress).build();
+        assertThat(portPairMgr.createPortPair(portPair), is(true));
+    }
+
+    /**
+     * Checks the operation of exists() method.
+     */
+    @Test
+    public void testExists() {
+        testCreatePortPair();
+        assertThat(portPairMgr.exists(portPairId), is(true));
+    }
+
+    /**
+     * Checks the operation of getPortPairCount() method.
+     */
+    @Test
+    public void testGetPortPairCount() {
+        testCreatePortPair();
+        assertThat(portPairMgr.getPortPairCount(), is(1));
+    }
+
+    /**
+     * Checks the operation of getPortPairs() method.
+     */
+    @Test
+    public void testGetPortPairs() {
+        testCreatePortPair();
+        final Iterable<PortPair> portPairList = portPairMgr.getPortPairs();
+        assertThat(portPairList, is(notNullValue()));
+        assertThat(portPairList.iterator().hasNext(), is(true));
+    }
+
+    /**
+     * Checks the operation of getPortPair() method.
+     */
+    @Test
+    public void testGetPortPair() {
+        testCreatePortPair();
+        assertThat(portPair, is(notNullValue()));
+        assertThat(portPairMgr.getPortPair(portPairId), is(portPair));
+    }
+
+    /**
+     * Checks the operation of updatePortPair() method.
+     */
+    @Test
+    public void testUpdatePortPair() {
+        // create a port pair
+        testCreatePortPair();
+
+        // new updates
+        final TenantId tenantId2 = TenantId.tenantId("2");
+        final String name2 = "PortPair2";
+        final String description2 = "PortPair2";
+        final String ingress2 = "d5555555-24fc-4fae-af4b-321c5e2eb3d1";
+        final String egress2 = "a6666666-4a56-2a6e-cd3a-9dee4e2ec345";
+        portPair = portPairBuilder.setId(portPairId).setTenantId(tenantId2).setName(name2)
+                .setDescription(description2).setIngress(ingress2).setEgress(egress2).build();
+        assertThat(portPairMgr.updatePortPair(portPair), is(true));
+    }
+
+    /**
+     * Checks the operation of removePortPair() method.
+     */
+    @Test
+    public void testRemovePortPair() {
+        testCreatePortPair();
+        assertThat(portPairMgr.removePortPair(portPairId), is(true));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/portpairgroup/impl/PortPairGroupManagerTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/portpairgroup/impl/PortPairGroupManagerTest.java
new file mode 100644
index 00000000..95bcd09a
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/portpairgroup/impl/PortPairGroupManagerTest.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2015 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.vtnrsc.portpairgroup.impl;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+
+import org.junit.Test;
+import java.util.List;
+import java.util.LinkedList;
+
+import org.onosproject.vtnrsc.PortPairId;
+import org.onosproject.vtnrsc.PortPairGroup;
+import org.onosproject.vtnrsc.PortPairGroupId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.DefaultPortPairGroup;
+import org.onosproject.vtnrsc.util.VtnStorageServiceTest;
+
+/**
+ * Unit tests for PortPairGroupManager class.
+ */
+public class PortPairGroupManagerTest {
+    final PortPairGroupId portPairGroupId = PortPairGroupId.of("78888888-fc23-aeb6-f44b-56dc5e2fb3ae");
+    final TenantId tenantId = TenantId.tenantId("1");
+    final String name = "PortPairGroup";
+    final String description = "PortPairGroup";
+    final List<PortPairId> portPairIdList = new LinkedList<PortPairId>();
+    DefaultPortPairGroup.Builder portPairGroupBuilder = new DefaultPortPairGroup.Builder();
+    PortPairGroupManager portPairGroupMgr = new PortPairGroupManager();
+    PortPairGroup portPairGroup = null;
+    private final VtnStorageServiceTest storageService = new VtnStorageServiceTest();
+
+    /**
+     * Checks the operation of createPortPairGroup() method.
+     */
+    @Test
+    public void testCreatePortPairGroup() {
+        // initialize port pair group manager
+        portPairGroupMgr.storageService = storageService;
+        portPairGroupMgr.activate();
+
+        // create port-pair-id list
+        PortPairId portPairId = PortPairId.of("73333333-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairIdList.add(portPairId);
+        portPairId = PortPairId.of("74444444-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairIdList.add(portPairId);
+
+        // create port pair
+        portPairGroup = portPairGroupBuilder.setId(portPairGroupId).setTenantId(tenantId).setName(name)
+                .setDescription(description).setPortPairs(portPairIdList).build();
+        assertThat(portPairGroupMgr.createPortPairGroup(portPairGroup), is(true));
+    }
+
+    /**
+     * Checks the operation of exists() method.
+     */
+    @Test
+    public void testExists() {
+        testCreatePortPairGroup();
+        assertThat(portPairGroupMgr.exists(portPairGroupId), is(true));
+    }
+
+    /**
+     * Checks the operation of getPortPairGroupCount() method.
+     */
+    @Test
+    public void testGetPortPairGroupCount() {
+        testCreatePortPairGroup();
+        assertThat(portPairGroupMgr.getPortPairGroupCount(), is(1));
+    }
+
+    /**
+     * Checks the operation of getPortPairGroups() method.
+     */
+    @Test
+    public void testGetPortPairGroups() {
+        testCreatePortPairGroup();
+        final Iterable<PortPairGroup> portPairGroupList = portPairGroupMgr.getPortPairGroups();
+        assertThat(portPairGroupList, is(notNullValue()));
+        assertThat(portPairGroupList.iterator().hasNext(), is(true));
+    }
+
+    /**
+     * Checks the operation of getPortPairGroup() method.
+     */
+    @Test
+    public void testGetPortPairGroup() {
+        testCreatePortPairGroup();
+        assertThat(portPairGroup, is(notNullValue()));
+        assertThat(portPairGroupMgr.getPortPairGroup(portPairGroupId), is(portPairGroup));
+    }
+
+    /**
+     * Checks the operation of updatePortPairGroup() method.
+     */
+    @Test
+    public void testUpdatePortPairGroup() {
+        // create a port pair group
+        testCreatePortPairGroup();
+
+        // new updates
+        // create port-pair-id list
+        final TenantId tenantId2 = TenantId.tenantId("2");
+        final String name2 = "PortPairGroup2";
+        final String description2 = "PortPairGroup2";
+        final List<PortPairId> portPairIdList = new LinkedList<PortPairId>();
+        PortPairId portPairId = PortPairId.of("75555555-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairIdList.add(portPairId);
+        portPairId = PortPairId.of("76666666-fc23-aeb6-f44b-56dc5e2fb3ae");
+        portPairIdList.add(portPairId);
+
+        // create port pair
+        portPairGroup = portPairGroupBuilder.setId(portPairGroupId).setTenantId(tenantId2).setName(name2)
+                .setDescription(description2).setPortPairs(portPairIdList).build();
+        assertThat(portPairGroupMgr.updatePortPairGroup(portPairGroup), is(true));
+    }
+
+    /**
+     * Checks the operation of removePortPairGroup() method.
+     */
+    @Test
+    public void testRemovePortPairGroup() {
+        testCreatePortPairGroup();
+        assertThat(portPairGroupMgr.removePortPairGroup(portPairGroupId), is(true));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/router/DefaultRouterTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/router/DefaultRouterTest.java
new file mode 100644
index 00000000..ecc80658
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/router/DefaultRouterTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2015 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.vtnrsc.router;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+import java.util.Collections;
+
+import org.junit.Test;
+import org.onosproject.vtnrsc.DefaultRouter;
+import org.onosproject.vtnrsc.Router;
+import org.onosproject.vtnrsc.RouterGateway;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.TenantNetworkId;
+import org.onosproject.vtnrsc.VirtualPortId;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Unit tests for DefaultRouter class.
+ */
+public class DefaultRouterTest {
+
+    private String tenantIdStr = "123";
+    private String virtualPortId = "1212";
+    private String routeIdStr1 = "1";
+    private String routeIdStr2 = "2";
+    private String routerName = "router";
+    private String tenantNetworkId = "1234567";
+
+    /**
+     * Checks that the DefaultRouter class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(DefaultRouter.class);
+    }
+
+    /**
+     * Checks the operation of equals().
+     */
+    @Test
+    public void testEquals() {
+        final TenantId tenantId = TenantId.tenantId(tenantIdStr);
+        final VirtualPortId portId = VirtualPortId.portId(virtualPortId);
+        final RouterId routerId1 = RouterId.valueOf(routeIdStr1);
+        final RouterId routerId2 = RouterId.valueOf(routeIdStr2);
+        final TenantNetworkId networkId = TenantNetworkId
+                .networkId(tenantNetworkId);
+        final RouterGateway routerGateway = RouterGateway.routerGateway(
+                                                              networkId,
+                                                              true,
+                                                              Collections
+                                                                      .emptySet());
+
+        Router r1 = new DefaultRouter(routerId1, routerName, false,
+                                      Router.Status.ACTIVE, false,
+                                      routerGateway, portId, tenantId, null);
+        Router r2 = new DefaultRouter(routerId1, routerName, false,
+                                      Router.Status.ACTIVE, false,
+                                      routerGateway, portId, tenantId, null);
+        Router r3 = new DefaultRouter(routerId2, routerName, false,
+                                      Router.Status.ACTIVE, false,
+                                      routerGateway, portId, tenantId, null);
+
+        new EqualsTester().addEqualityGroup(r1, r2).addEqualityGroup(r3)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a DefaultRouter object.
+     */
+    @Test
+    public void testConstruction() {
+        final TenantId tenantId = TenantId.tenantId(tenantIdStr);
+        final VirtualPortId portId = VirtualPortId.portId(virtualPortId);
+        final RouterId routerId = RouterId.valueOf(routeIdStr1);
+        final TenantNetworkId networkId = TenantNetworkId
+                .networkId(tenantNetworkId);
+        final RouterGateway routerGateway = RouterGateway.routerGateway(
+                                                              networkId,
+                                                              true,
+                                                              Collections
+                                                                      .emptySet());
+
+        Router r1 = new DefaultRouter(routerId, routerName, false,
+                                      Router.Status.ACTIVE, false,
+                                      routerGateway, portId, tenantId, null);
+        assertThat(routerId, is(notNullValue()));
+        assertThat(routerId, is(r1.id()));
+        assertThat(tenantId, is(notNullValue()));
+        assertThat(tenantId, is(r1.tenantId()));
+        assertThat(routerGateway, is(notNullValue()));
+        assertThat(routerGateway, is(r1.externalGatewayInfo()));
+    }
+
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/router/RouterInterfaceTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/router/RouterInterfaceTest.java
new file mode 100644
index 00000000..53ea037d
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/router/RouterInterfaceTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2015 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.vtnrsc.router;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+
+import org.junit.Test;
+import org.onosproject.vtnrsc.RouterId;
+import org.onosproject.vtnrsc.RouterInterface;
+import org.onosproject.vtnrsc.SubnetId;
+import org.onosproject.vtnrsc.TenantId;
+import org.onosproject.vtnrsc.VirtualPortId;
+
+import com.google.common.testing.EqualsTester;
+
+/**
+ * Unit tests for RouterInterface class.
+ */
+public class RouterInterfaceTest {
+    private String tenantIdStr = "123";
+    private String virtualPortId = "1212";
+    private String routeIdStr1 = "1";
+    private String routeIdStr2 = "2";
+    private String subnetIdStr = "1234567";
+
+    /**
+     * Checks that the RouterInterface class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(RouterInterface.class);
+    }
+
+    /**
+     * Checks the operation of equals().
+     */
+    @Test
+    public void testEquals() {
+        final TenantId tenantId = TenantId.tenantId(tenantIdStr);
+        final VirtualPortId portId = VirtualPortId.portId(virtualPortId);
+        final RouterId routerId1 = RouterId.valueOf(routeIdStr1);
+        final RouterId routerId2 = RouterId.valueOf(routeIdStr2);
+        final SubnetId subnet = SubnetId.subnetId(subnetIdStr);
+
+        RouterInterface ri1 = RouterInterface.routerInterface(subnet, portId,
+                                                              routerId1,
+                                                              tenantId);
+        RouterInterface ri2 = RouterInterface.routerInterface(subnet, portId,
+                                                              routerId1,
+                                                              tenantId);
+        RouterInterface ri3 = RouterInterface.routerInterface(subnet, portId,
+                                                              routerId2,
+                                                              tenantId);
+
+        new EqualsTester().addEqualityGroup(ri1, ri2).addEqualityGroup(ri3)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a RouterInterface object.
+     */
+    @Test
+    public void testConstruction() {
+        final TenantId tenantId = TenantId.tenantId(tenantIdStr);
+        final VirtualPortId portId = VirtualPortId.portId(virtualPortId);
+        final RouterId routerId1 = RouterId.valueOf(routeIdStr1);
+        final SubnetId subnet = SubnetId.subnetId(subnetIdStr);
+
+        RouterInterface ri1 = RouterInterface.routerInterface(subnet, portId,
+                                                              routerId1,
+                                                              tenantId);
+        assertThat(portId, is(notNullValue()));
+        assertThat(portId, is(ri1.portId()));
+        assertThat(tenantId, is(notNullValue()));
+        assertThat(tenantId, is(ri1.tenantId()));
+        assertThat(routerId1, is(notNullValue()));
+        assertThat(routerId1, is(ri1.routerId()));
+        assertThat(subnet, is(notNullValue()));
+        assertThat(subnet, is(ri1.subnetId()));
+    }
+}
diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnEventuallyConsistentMapAdapter.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnEventuallyConsistentMapAdapter.java
new file mode 100644
index 00000000..0631f865
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnEventuallyConsistentMapAdapter.java
@@ -0,0 +1,114 @@
+/*

+ * Copyright 2015 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.vtnrsc.util;

+

+import java.util.Collection;

+import java.util.Map;

+import java.util.Set;

+import java.util.function.BiFunction;

+

+import org.onosproject.store.service.EventuallyConsistentMap;

+import org.onosproject.store.service.EventuallyConsistentMapListener;

+

+/**

+ * Testing adapter for EventuallyConsistentMap.

+ */

+public class VtnEventuallyConsistentMapAdapter<K, V> implements EventuallyConsistentMap<K, V> {

+    @Override

+    public int size() {

+        return 0;

+    }

+

+    @Override

+    public boolean isEmpty() {

+        return false;

+    }

+

+    @Override

+    public boolean containsKey(K key) {

+        return false;

+    }

+

+    @Override

+    public boolean containsValue(V value) {

+        return false;

+    }

+

+    @Override

+    public V get(K key) {

+        return null;

+    }

+

+    @Override

+    public void put(K key, V value) {

+

+    }

+

+    @Override

+    public V remove(K key) {

+        return null;

+    }

+

+    @Override

+    public void remove(K key, V value) {

+

+    }

+

+    @Override

+    public V compute(K key, BiFunction<K, V, V> recomputeFunction) {

+        return null;

+    }

+

+    @Override

+    public void putAll(Map<? extends K, ? extends V> m) {

+

+    }

+

+    @Override

+    public void clear() {

+

+    }

+

+    @Override

+    public Set<K> keySet() {

+        return null;

+    }

+

+    @Override

+    public Collection<V> values() {

+        return null;

+    }

+

+    @Override

+    public Set<Map.Entry<K, V>> entrySet() {

+        return null;

+    }

+

+    @Override

+    public void addListener(EventuallyConsistentMapListener<K, V> listener) {

+

+    }

+

+    @Override

+    public void removeListener(EventuallyConsistentMapListener<K, V> listener) {

+

+    }

+

+    @Override

+    public void destroy() {

+

+    }

+}

diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnEventuallyConsistentMapTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnEventuallyConsistentMapTest.java
new file mode 100644
index 00000000..68b7d689
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnEventuallyConsistentMapTest.java
@@ -0,0 +1,242 @@
+/*

+ * Copyright 2015 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.vtnrsc.util;

+

+import java.util.Collection;

+import java.util.HashMap;

+import java.util.LinkedList;

+import java.util.List;

+import java.util.Map;

+import java.util.Set;

+import java.util.concurrent.ExecutorService;

+import java.util.concurrent.ScheduledExecutorService;

+import java.util.concurrent.TimeUnit;

+import java.util.function.BiFunction;

+

+import org.onlab.util.KryoNamespace;

+import org.onosproject.cluster.NodeId;

+import org.onosproject.store.Timestamp;

+

+import static org.onosproject.store.service.EventuallyConsistentMapEvent.Type.*;

+import org.onosproject.store.service.EventuallyConsistentMapListener;

+import org.onosproject.store.service.EventuallyConsistentMapEvent;

+import org.onosproject.store.service.EventuallyConsistentMapBuilder;

+import org.onosproject.store.service.EventuallyConsistentMap;

+

+/**

+ * Testing version of an Eventually Consistent Map.

+ */

+

+public final class VtnEventuallyConsistentMapTest<K, V> extends VtnEventuallyConsistentMapAdapter<K, V> {

+

+    private final HashMap<K, V> map;

+    private final String mapName;

+    private final List<EventuallyConsistentMapListener<K, V>> listeners;

+    private final BiFunction<K, V, Collection<NodeId>> peerUpdateFunction;

+

+    private VtnEventuallyConsistentMapTest(String mapName,

+            BiFunction<K, V, Collection<NodeId>> peerUpdateFunction) {

+        map = new HashMap<>();

+        listeners = new LinkedList<>();

+        this.mapName = mapName;

+        this.peerUpdateFunction = peerUpdateFunction;

+    }

+

+    /**

+     * Notify all listeners of an event.

+     */

+    private void notifyListeners(EventuallyConsistentMapEvent<K, V> event) {

+        listeners.forEach(

+                listener -> listener.event(event)

+                );

+    }

+

+    @Override

+    public int size() {

+        return map.size();

+    }

+

+    @Override

+    public boolean isEmpty() {

+        return map.isEmpty();

+    }

+

+    @Override

+    public boolean containsKey(K key) {

+        return map.containsKey(key);

+    }

+

+    @Override

+    public boolean containsValue(V value) {

+        return map.containsValue(value);

+    }

+

+    @Override

+    public V get(K key) {

+        return map.get(key);

+    }

+

+    @Override

+    public void put(K key, V value) {

+        map.put(key, value);

+        EventuallyConsistentMapEvent<K, V> addEvent =

+                new EventuallyConsistentMapEvent<>(mapName, PUT, key, value);

+        notifyListeners(addEvent);

+        if (peerUpdateFunction != null) {

+            peerUpdateFunction.apply(key, value);

+        }

+    }

+

+    @Override

+    public V remove(K key) {

+        V result = map.remove(key);

+        if (result != null) {

+            EventuallyConsistentMapEvent<K, V> removeEvent =

+                    new EventuallyConsistentMapEvent<>(mapName, REMOVE,

+                            key, map.get(key));

+            notifyListeners(removeEvent);

+        }

+        return result;

+    }

+

+    @Override

+    public void remove(K key, V value) {

+        boolean removed = map.remove(key, value);

+        if (removed) {

+            EventuallyConsistentMapEvent<K, V> removeEvent =

+                    new EventuallyConsistentMapEvent<>(mapName, REMOVE, key, value);

+            notifyListeners(removeEvent);

+        }

+    }

+

+    @Override

+    public V compute(K key, BiFunction<K, V, V> recomputeFunction) {

+        return map.compute(key, recomputeFunction);

+    }

+

+    @Override

+    public void putAll(Map<? extends K, ? extends V> m) {

+        map.putAll(m);

+    }

+

+    @Override

+    public void clear() {

+        map.clear();

+    }

+

+    @Override

+    public Set<K> keySet() {

+        return map.keySet();

+    }

+

+    @Override

+    public Collection<V> values() {

+        return map.values();

+    }

+

+    @Override

+    public Set<Map.Entry<K, V>> entrySet() {

+        return map.entrySet();

+    }

+

+    public static <K, V> Builder<K, V> builder() {

+        return new Builder<>();

+    }

+

+    @Override

+    public void addListener(EventuallyConsistentMapListener<K, V> listener) {

+        listeners.add(listener);

+    }

+

+    @Override

+    public void removeListener(EventuallyConsistentMapListener<K, V> listener) {

+        listeners.remove(listener);

+    }

+

+    public static class Builder<K, V> implements EventuallyConsistentMapBuilder<K, V> {

+        private String name;

+        private BiFunction<K, V, Collection<NodeId>> peerUpdateFunction;

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V> withName(String name) {

+            this.name = name;

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V> withSerializer(KryoNamespace.Builder serializerBuilder) {

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V>

+        withTimestampProvider(BiFunction<K, V, Timestamp> timestampProvider) {

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V> withEventExecutor(ExecutorService executor) {

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V> withCommunicationExecutor(ExecutorService executor) {

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V> withBackgroundExecutor(ScheduledExecutorService executor) {

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V>

+        withPeerUpdateFunction(BiFunction<K, V, Collection<NodeId>> peerUpdateFunction) {

+            this.peerUpdateFunction = peerUpdateFunction;

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V> withTombstonesDisabled() {

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V> withAntiEntropyPeriod(long period, TimeUnit unit) {

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V> withFasterConvergence() {

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMapBuilder<K, V> withPersistence() {

+            return this;

+        }

+

+        @Override

+        public EventuallyConsistentMap<K, V> build() {

+            if (name == null) {

+                name = "test";

+            }

+            return new VtnEventuallyConsistentMapTest<>(name, peerUpdateFunction);

+        }

+    }

+

+}

+

diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnStorageServiceAdapter.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnStorageServiceAdapter.java
new file mode 100644
index 00000000..efb1a791
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnStorageServiceAdapter.java
@@ -0,0 +1,65 @@
+/*

+ * Copyright 2015 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.vtnrsc.util;

+

+import org.onosproject.store.service.EventuallyConsistentMapBuilder;

+import org.onosproject.store.service.ConsistentMapBuilder;

+import org.onosproject.store.service.DistributedSetBuilder;

+import org.onosproject.store.service.DistributedQueueBuilder;

+import org.onosproject.store.service.AtomicCounterBuilder;

+import org.onosproject.store.service.AtomicValueBuilder;

+import org.onosproject.store.service.TransactionContextBuilder;

+import org.onosproject.store.service.StorageService;

+

+/**

+ * Adapter for the storage service.

+ */

+public class VtnStorageServiceAdapter implements StorageService {

+    @Override

+    public <K, V> EventuallyConsistentMapBuilder<K, V> eventuallyConsistentMapBuilder() {

+        return null;

+    }

+

+    @Override

+    public <K, V> ConsistentMapBuilder<K, V> consistentMapBuilder() {

+        return null;

+    }

+

+    @Override

+    public <E> DistributedSetBuilder<E> setBuilder() {

+        return null;

+    }

+

+    @Override

+    public <E> DistributedQueueBuilder<E> queueBuilder() {

+        return null;

+    }

+

+    @Override

+    public AtomicCounterBuilder atomicCounterBuilder() {

+        return null;

+    }

+

+    @Override

+    public <V> AtomicValueBuilder<V> atomicValueBuilder() {

+        return null;

+    }

+

+    @Override

+    public TransactionContextBuilder transactionContextBuilder() {

+        return null;

+    }

+}

diff --git a/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnStorageServiceTest.java b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnStorageServiceTest.java
new file mode 100644
index 00000000..1f0f1835
--- /dev/null
+++ b/framework/src/onos/apps/vtn/vtnrsc/src/test/java/org/onosproject/vtnrsc/util/VtnStorageServiceTest.java
@@ -0,0 +1,25 @@
+/*

+ * Copyright 2015 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.vtnrsc.util;

+

+import org.onosproject.store.service.EventuallyConsistentMapBuilder;

+

+public class VtnStorageServiceTest extends VtnStorageServiceAdapter {

+    @Override

+    public <K, V> EventuallyConsistentMapBuilder<K, V> eventuallyConsistentMapBuilder() {

+        return VtnEventuallyConsistentMapTest.builder();

+    }

+}