ONOS-688 (ONOS-1835,1836,1837) :

 - Implements features to create and remove tunnels and tunnel flow policies.
 - Implements REST API to create/show/delete tunnels and policies.
 - Supports only single instance for now.
 - Fix "apply" actions to "write" actions of all flow rules
Change-Id: I3740ed82fed8eab4ab8b03839192da72d3e223f1

@@ -32,6 +32,96 @@
 
     <properties>
         <onos.app.name>org.onosproject.segmentrouting</onos.app.name>
+        <web.context>/onos/segmentrouting</web.context>
     </properties>
 
+    <dependencies>
+        <dependency>
+            <groupId>org.onosproject</groupId>
+            <artifactId>onos-cli</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.karaf.shell</groupId>
+            <artifactId>org.apache.karaf.shell.console</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.onosproject</groupId>
+            <artifactId>onos-rest</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.onosproject</groupId>
+            <artifactId>onlab-rest</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.ws.rs</groupId>
+            <artifactId>jsr311-api</artifactId>
+            <version>1.1.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.sun.jersey</groupId>
+            <artifactId>jersey-servlet</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>org.osgi.compendium</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>org.osgi.core</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+                <extensions>true</extensions>
+                <configuration>
+                    <instructions>
+                        <_wab>src/main/webapp/</_wab>
+                        <Bundle-SymbolicName>
+                            ${project.groupId}.${project.artifactId}
+                        </Bundle-SymbolicName>
+                        <Import-Package>
+                            org.slf4j,
+                            org.osgi.framework,
+                            javax.ws.rs,
+                            javax.ws.rs.core,
+                            com.sun.jersey.api.core,
+                            com.sun.jersey.spi.container.servlet,
+                            com.sun.jersey.server.impl.container.servlet,
+                            com.fasterxml.jackson.databind,
+                            com.fasterxml.jackson.databind.node,
+                            com.fasterxml.jackson.core,
+                            org.apache.karaf.shell.commands,
+                            org.apache.commons.lang.math.*,
+                            com.google.common.*,
+                            org.onlab.packet.*,
+                            org.onlab.rest.*,
+                            org.onosproject.*,
+                            org.onlab.util.*,
+                            org.jboss.netty.util.*
+                        </Import-Package>
+                        <Web-ContextPath>${web.context}</Web-ContextPath>
+                    </instructions>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
 </project>

+/*
+ * 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.segmentrouting;
+
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Link;
+import org.onosproject.segmentrouting.grouphandler.NeighborSet;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Tunnel class.
+ */
+public class DefaultTunnel implements Tunnel {
+
+    private static final Logger log = LoggerFactory
+            .getLogger(DefaultTunnel.class);
+
+    private final String tunnelId;
+    private final List<Integer> labelIds;
+    private final SegmentRoutingManager srManager;
+    private final DeviceConfiguration config;
+
+    private int groupId;
+
+    /**
+     * Creates a Tunnel reference.
+     *
+     * @param srm SegmentRoutingManager object
+     * @param tid  Tunnel ID
+     * @param labelIds Label stack of the tunnel
+     */
+    public DefaultTunnel(SegmentRoutingManager srm, String tid,
+                         List<Integer> labelIds) {
+        this.srManager = checkNotNull(srm);
+        this.tunnelId = checkNotNull(tid);
+        this.labelIds = Collections.unmodifiableList(labelIds);
+        this.config = srManager.deviceConfiguration;
+        this.groupId = -1;
+    }
+
+    /**
+     * Creates a Tunnel reference.
+     *
+     * @param tid  Tunnel ID
+     * @param labelIds Label stack of the tunnel
+     */
+    public DefaultTunnel(String tid, List<Integer> labelIds) {
+        this.srManager = null;
+        this.tunnelId = checkNotNull(tid);
+        this.labelIds = Collections.unmodifiableList(labelIds);
+        this.config = null;
+        this.groupId = -1;
+    }
+
+    /**
+     * Creates a new DefaultTunnel reference using the tunnel reference.
+     *
+     * @param tunnel DefaultTunnel reference
+     */
+    public DefaultTunnel(DefaultTunnel tunnel) {
+        this.srManager = tunnel.srManager;
+        this.tunnelId = tunnel.tunnelId;
+        this.labelIds = tunnel.labelIds;
+        this.config = tunnel.config;
+        this.groupId = tunnel.groupId;
+    }
+
+    @Override
+    public String id() {
+        return this.tunnelId;
+    }
+
+    @Override
+    public List<Integer> labelIds() {
+        return this.labelIds;
+    }
+
+    @Override
+    public boolean create() {
+
+        if (labelIds.isEmpty() || labelIds.size() < 3) {
+            log.error("More than one router needs to specified to created a tunnel");
+            return false;
+        }
+
+        groupId = createGroupsForTunnel();
+        if (groupId < 0) {
+            log.error("Failed to create groups for the tunnel");
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean remove() {
+
+        DeviceId deviceId = config.getDeviceId(labelIds.get(0));
+        srManager.removeNextObjective(deviceId, groupId);
+
+        return true;
+    }
+
+    @Override
+    public int groupId() {
+        return this.groupId;
+    }
+
+    @Override
+    public DeviceId source() {
+        return config.getDeviceId(labelIds.get(0));
+    }
+
+    private int createGroupsForTunnel() {
+
+        List<Integer> portNumbers;
+
+        int groupId;
+
+        DeviceId deviceId = config.getDeviceId(labelIds.get(0));
+        if (deviceId == null) {
+            log.warn("No device found for SID {}", labelIds.get(0));
+            return -1;
+        }
+        Set<DeviceId> deviceIds = new HashSet<>();
+        int sid = labelIds.get(1);
+        if (config.isAdjacencySid(deviceId, sid)) {
+            portNumbers = config.getPortsForAdjacencySid(deviceId, sid);
+            for (Link link: srManager.linkService.getDeviceEgressLinks(deviceId)) {
+                for (Integer port: portNumbers) {
+                    if (link.src().port().toLong() == port) {
+                        deviceIds.add(link.dst().deviceId());
+                    }
+                }
+            }
+        } else {
+            deviceIds.add(config.getDeviceId(sid));
+        }
+
+        NeighborSet ns = new NeighborSet(deviceIds, labelIds.get(2));
+        groupId = srManager.getNextObjectiveId(deviceId, ns);
+
+        return groupId;
+    }
+
+}

 package org.onosproject.segmentrouting;
 
+import com.google.common.collect.Lists;
 import org.onlab.packet.Ip4Address;
 import org.onlab.packet.Ip4Prefix;
 import org.onlab.packet.IpPrefix;
@@ -44,6 +45,7 @@ public class DeviceConfiguration implements DeviceProperties {
         boolean isEdge;
         HashMap<PortNumber, Ip4Address> gatewayIps;
         HashMap<PortNumber, Ip4Prefix> subnets;
+        List<SegmentRouterConfig.AdjacencySid> adjacencySids;
     }
 
     /**
@@ -80,8 +82,10 @@ public class DeviceConfiguration implements DeviceProperties {
                 info.gatewayIps.put(PortNumber.portNumber(s.getPortNo()),
                                     Ip4Address.valueOf(gatewayIp));
             }
+            info.adjacencySids = ((SegmentRouterConfig) cfg).getAdjacencySids();
             this.deviceConfigMap.put(info.deviceId, info);
             this.allSegmentIds.add(info.nodeSid);
+
         }
     }
 
@@ -352,4 +356,49 @@ public class DeviceConfiguration implements DeviceProperties {
 
         return false;
     }
+
+    /**
+     * Returns the ports corresponding to the adjacency Sid given.
+     *
+     * @param deviceId device identification of the router
+     * @param sid adjacency Sid
+     * @return list of port numbers
+     */
+    public List<Integer> getPortsForAdjacencySid(DeviceId deviceId, int sid) {
+        if (deviceConfigMap.get(deviceId) != null) {
+            for (SegmentRouterConfig.AdjacencySid asid : deviceConfigMap.get(deviceId).adjacencySids) {
+                if (asid.getAdjSid() == sid) {
+                    return asid.getPorts();
+                }
+            }
+        }
+
+        return Lists.newArrayList();
+    }
+
+    /**
+     * Check if the Sid given is whether adjacency Sid of the router device or not.
+     *
+     * @param deviceId device identification of the router
+     * @param sid Sid to check
+     * @return true if the Sid given is the adjacency Sid of the device,
+     * otherwise false
+     */
+    public boolean isAdjacencySid(DeviceId deviceId, int sid) {
+        if (deviceConfigMap.get(deviceId) != null) {
+            if (deviceConfigMap.get(deviceId).adjacencySids.isEmpty()) {
+                return false;
+            } else {
+                for (SegmentRouterConfig.AdjacencySid asid:
+                        deviceConfigMap.get(deviceId).adjacencySids) {
+                    if (asid.getAdjSid() == sid) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+
+        return false;
+    }
 }

+/*
+ * 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.segmentrouting;
+
+import org.onosproject.net.flow.TrafficSelector;
+
+/**
+ * Interface for Segment Routing Policy.
+ */
+public interface Policy {
+    /**
+     * Enums for policy type.
+     */
+    enum Type {
+        // Tunnel flow policy type
+        TUNNEL_FLOW,
+
+        // Load balancing policy type
+        LOADBALANCE,
+
+        // policy to avoid specific routers or links
+        AVOID,
+
+        // Access Control policy type
+        DENY
+    }
+
+    /**
+     * Returns the policy ID.
+     *
+     * @return policy ID
+     */
+    String id();
+
+    /**
+     * Returns the traffic selector object.
+     *
+     * @return TrafficSelector object
+     */
+    TrafficSelector selector();
+
+    /**
+     * Returns the priority of the policy.
+     *
+     * @return priority
+     */
+    int priority();
+
+    /**
+     * Returns the policy type.
+     *
+     * @return policy type
+     */
+    Type type();
+
+    /**
+     * Creates a policy.
+     *
+     * @return true if succeeds, false otherwise
+     */
+    boolean create();
+
+    /**
+     * Removes the policy.
+     *
+     * @return true if succeeds, false otherwise
+     */
+    boolean remove();
+}

+/*
+ * 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.segmentrouting;
+
+import org.slf4j.Logger;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Segment Routing Policy Handler.
+ */
+public class PolicyHandler {
+
+    protected final Logger log = getLogger(getClass());
+
+    private final HashMap<String, Policy> policyMap;
+
+    /**
+     * Creates a reference.
+     */
+    public PolicyHandler() {
+        policyMap = new HashMap<>();
+    }
+
+    /**
+     * Returns the policies.
+     *
+     * @return policy list
+     */
+    public List<Policy> getPolicies() {
+        List<Policy> policies = new ArrayList<>();
+        policyMap.values().forEach(policy -> policies.add(
+                new TunnelPolicy((TunnelPolicy) policy)));
+
+        return policies;
+    }
+
+    /**
+     * Creates a policy using the policy information given.
+     *
+     * @param policy policy reference to create
+     */
+    public void createPolicy(Policy policy) {
+        policy.create();
+        policyMap.put(policy.id(), policy);
+    }
+
+    /**
+     * Removes the policy given.
+     *
+     * @param policyInfo policy information to remove
+     */
+    public void removePolicy(Policy policyInfo) {
+        if (policyMap.get(policyInfo.id()) != null) {
+            if (policyMap.get(policyInfo.id()).remove()) {
+                policyMap.remove(policyInfo.id());
+            } else {
+                log.error("Failed to remove the policy {}", policyInfo.id());
+            }
+        } else {
+            log.warn("Policy {} was not found", policyInfo.id());
+        }
+    }
+
+}

@@ -98,7 +98,8 @@ public class RoutingRulePopulator {
         sbuilder.matchIPDst(IpPrefix.valueOf(hostIp, 32));
         sbuilder.matchEthType(Ethernet.TYPE_IPV4);
 
-        tbuilder.setEthDst(hostMac)
+        tbuilder.deferred()
+                .setEthDst(hostMac)
                 .setEthSrc(config.getDeviceMac(deviceId))
                 .setOutput(outPort);
 
@@ -163,10 +164,10 @@ public class RoutingRulePopulator {
         // If the next hop is the same as the final destination, then MPLS label
         // is not set.
         if (nextHops.size() == 1 && nextHops.toArray()[0].equals(destSw)) {
-            tbuilder.decNwTtl();
+            tbuilder.deferred().decNwTtl();
             ns = new NeighborSet(nextHops);
         } else {
-            tbuilder.copyTtlOut();
+            tbuilder.deferred().copyTtlOut();
             ns = new NeighborSet(nextHops, config.getSegmentId(destSw));
         }
 
@@ -295,15 +296,15 @@ public class RoutingRulePopulator {
 
         if (phpRequired) {
             log.debug("getMplsForwardingObjective: php required");
-            tbuilder.copyTtlIn();
+            tbuilder.deferred().copyTtlIn();
             if (isBos) {
-                tbuilder.popMpls(Ethernet.TYPE_IPV4).decNwTtl();
+                tbuilder.deferred().popMpls(Ethernet.TYPE_IPV4).decNwTtl();
             } else {
-                tbuilder.popMpls(Ethernet.MPLS_UNICAST).decMplsTtl();
+                tbuilder.deferred().popMpls(Ethernet.MPLS_UNICAST).decMplsTtl();
             }
         } else {
             log.debug("getMplsForwardingObjective: php not required");
-            tbuilder.decMplsTtl();
+            tbuilder.deferred().decMplsTtl();
         }
 
         if (!isECMPSupportedInTransitRouter() && !config.isEdgeDevice(deviceId)) {
@@ -313,7 +314,8 @@ public class RoutingRulePopulator {
                 log.warn("No link from {} to {}", deviceId, nextHops);
                 return null;
             }
-            tbuilder.setEthSrc(config.getDeviceMac(deviceId))
+            tbuilder.deferred()
+                    .setEthSrc(config.getDeviceMac(deviceId))
                     .setEthDst(config.getDeviceMac(nextHop))
                     .setOutput(port);
             fwdBuilder.withTreatment(tbuilder.build());

@@ -20,6 +20,7 @@ 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.Ethernet;
 import org.onlab.packet.IPv4;
 import org.onlab.util.KryoNamespace;
@@ -60,6 +61,7 @@ import org.slf4j.LoggerFactory;
 
 import java.net.URI;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
@@ -69,8 +71,9 @@ import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 
 @SuppressWarnings("ALL")
+@Service
 @Component(immediate = true)
-public class SegmentRoutingManager {
+public class SegmentRoutingManager implements SegmentRoutingService {
 
     private static Logger log = LoggerFactory
             .getLogger(SegmentRoutingManager.class);
@@ -101,6 +104,7 @@ public class SegmentRoutingManager {
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected MastershipService mastershipService;
+
     protected ArpHandler arpHandler = null;
     protected IcmpHandler icmpHandler = null;
     protected IpHandler ipHandler = null;
@@ -108,7 +112,10 @@ public class SegmentRoutingManager {
     protected ApplicationId appId;
     protected DeviceConfiguration deviceConfiguration = null;
 
+
     private DefaultRoutingHandler defaultRoutingHandler = null;
+    private TunnelHandler tunnelHandler = null;
+    private PolicyHandler policyHandler = null;
     private InternalPacketProcessor processor = new InternalPacketProcessor();
     private InternalEventHandler eventHandler = new InternalEventHandler();
 
@@ -165,6 +172,8 @@ public class SegmentRoutingManager {
         ipHandler = new IpHandler(this);
         routingRulePopulator = new RoutingRulePopulator(this);
         defaultRoutingHandler = new DefaultRoutingHandler(this);
+        tunnelHandler = new TunnelHandler();
+        policyHandler = new PolicyHandler();
 
         packetService.addProcessor(processor, PacketProcessor.ADVISOR_MAX + 2);
         linkService.addListener(new InternalLinkListener());
@@ -187,6 +196,7 @@ public class SegmentRoutingManager {
 
         defaultRoutingHandler.startPopulationProcess();
         log.info("Started");
+
     }
 
     @Deactivate
@@ -196,6 +206,51 @@ public class SegmentRoutingManager {
         log.info("Stopped");
     }
 
+
+    @Override
+    public List<Tunnel> getTunnels() {
+        return tunnelHandler.getTunnels();
+    }
+
+    @Override
+    public void createTunnel(Tunnel tunnel) {
+        tunnelHandler.createTunnel(tunnel);
+    }
+
+    @Override
+    public void removeTunnel(Tunnel tunnel) {
+        for (Policy policy: policyHandler.getPolicies()) {
+            if (policy.type() == Policy.Type.TUNNEL_FLOW) {
+                TunnelPolicy tunnelPolicy = (TunnelPolicy) policy;
+                if (tunnelPolicy.tunnelId().equals(tunnel.id())) {
+                    log.warn("Cannot remove the tunnel used by a policy");
+                    return;
+                }
+            }
+        }
+        tunnelHandler.removeTunnel(tunnel);
+    }
+
+    @Override
+    public void removePolicy(Policy policy) {
+        policyHandler.removePolicy(policy);
+
+    }
+
+    @Override
+    public void createPolicy(Policy policy) {
+        policyHandler.createPolicy(policy);
+    }
+
+    @Override
+    public List<Policy> getPolicies() {
+        return policyHandler.getPolicies();
+    }
+
+    public Tunnel getTunnel(String tunnelId) {
+        return tunnelHandler.getTunnel(tunnelId);
+    }
+
     /**
      * Returns the GrouopKey object for the device and the NighborSet given.
      *
@@ -211,6 +266,12 @@ public class SegmentRoutingManager {
         return null;
     }
 
+    /**
+     *
+     * @param deviceId
+     * @param ns
+     * @return
+     */
     public int getNextObjectiveId(DeviceId deviceId, NeighborSet ns) {
 
         if (groupHandlerMap.get(deviceId) != null) {
@@ -223,6 +284,16 @@ public class SegmentRoutingManager {
         }
     }
 
+    /**
+     *
+     * @param deviceId
+     * @param objectiveId
+     * @return
+     */
+    public boolean removeNextObjective(DeviceId deviceId, int objectiveId) {
+        return groupHandlerMap.get(deviceId).removeGroup(objectiveId);
+    }
+
     private class InternalPacketProcessor implements PacketProcessor {
 
         @Override
@@ -295,7 +366,7 @@ public class SegmentRoutingManager {
         }
 
         log.trace("numOfEvents {}, numOfEventHanlderScheduled {}", numOfEvents,
-                  numOfHandlerScheduled);
+                numOfHandlerScheduled);
 
     }
 
@@ -403,4 +474,7 @@ public class SegmentRoutingManager {
             groupHandler.portDown(port.number());
         }
     }
+
+
+
 }

+/*
+ * 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.segmentrouting;
+
+import java.util.List;
+
+/**
+ * Segment Routing Service for REST API.
+ */
+public interface SegmentRoutingService {
+
+    /**
+     * Returns all tunnels.
+     *
+     * @return list of tunnels
+     */
+    List<Tunnel> getTunnels();
+
+    /**
+     * Creates a tunnel.
+     *
+     * @param tunnel tunnel reference to create
+     */
+    void createTunnel(Tunnel tunnel);
+
+    /**
+     * Returns all policies.
+     *
+     * @return list of policy
+     */
+    List<Policy> getPolicies();
+
+    /**
+     * Creates a policy.
+     *
+     * @param policy policy reference to create
+     */
+    void createPolicy(Policy policy);
+
+    /**
+     * Removes a tunnel.
+     *
+     * @param tunnel tunnel reference to remove
+     */
+    void removeTunnel(Tunnel tunnel);
+
+    /**
+     * Removes a policy.
+     *
+     * @param policy policy reference to remove
+     */
+    void removePolicy(Policy policy);
+}

+/*
+ * 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.segmentrouting;
+
+import org.onosproject.net.DeviceId;
+
+import java.util.List;
+
+/**
+ * Tunnel interface.
+ */
+public interface Tunnel {
+
+    /**
+     * Returns the tunnel ID.
+     *
+     * @return tunnel ID
+     */
+    String id();
+
+    /**
+     * Returns Segment IDs for the tunnel including source and destination.
+     *
+     * @return List of Node ID
+     */
+    List<Integer> labelIds();
+
+    /**
+     * Creates a tunnel.
+     *
+     * @return true if succeeds, false otherwise
+     */
+    boolean create();
+
+    /**
+     * Removes the tunnel.
+     *
+     * @return true if succeeds, false otherwise.
+     */
+    boolean remove();
+
+    /**
+     * Returns the group ID for the tunnel.
+     *
+     * @return group ID
+     */
+    int groupId();
+
+    /**
+     * Returns the source device Id of the tunnel.
+     *
+     * @return source device Id
+     */
+    DeviceId source();
+}

+/*
+ * 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.segmentrouting;
+
+import org.slf4j.Logger;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.HashMap;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Tunnel Handler.
+ */
+public class TunnelHandler {
+    protected final Logger log = getLogger(getClass());
+
+    private final HashMap<String, Tunnel> tunnelMap;
+
+    public TunnelHandler() {
+        tunnelMap = new HashMap<>();
+    }
+
+    /**
+     * Creates a tunnel.
+     *
+     * @param tunnel tunnel reference to create a tunnel
+     */
+    public void createTunnel(Tunnel tunnel) {
+        tunnel.create();
+        tunnelMap.put(tunnel.id(), tunnel);
+    }
+
+    /**
+     * Removes the tunnel with the tunnel ID given.
+     *
+     * @param tunnelInfo tunnel information to delete tunnels
+     */
+    public void removeTunnel(Tunnel tunnelInfo) {
+
+        Tunnel tunnel = tunnelMap.get(tunnelInfo.id());
+        if (tunnel != null) {
+            tunnel.remove();
+            tunnelMap.remove(tunnel.id());
+        } else {
+            log.warn("No tunnel found for tunnel ID {}", tunnelInfo.id());
+        }
+    }
+
+    /**
+     * Returns the tunnel with the tunnel ID given.
+     *
+     * @param tid Tunnel ID
+     * @return Tunnel reference
+     */
+    public Tunnel getTunnel(String tid) {
+        return tunnelMap.get(tid);
+    }
+
+    /**
+     * Returns all tunnels.
+     *
+     * @return list of Tunnels
+     */
+    public List<Tunnel> getTunnels() {
+        List<Tunnel> tunnels = new ArrayList<>();
+        tunnelMap.values().forEach(tunnel -> tunnels.add(
+                new DefaultTunnel((DefaultTunnel) tunnel)));
+
+        return tunnels;
+    }
+}

+/*
+ * 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.segmentrouting;
+
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flowobjective.DefaultForwardingObjective;
+import org.onosproject.net.flowobjective.ForwardingObjective;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Tunnel Policy.
+ */
+public final class TunnelPolicy implements Policy {
+
+    private final SegmentRoutingManager srManager;
+    private final Type type;
+    private final String id;
+    private final TrafficSelector selector;
+    private final int priority;
+    private final String tunnelId;
+
+    private TunnelPolicy(SegmentRoutingManager srm, String policyId, Type type,
+                         TrafficSelector selector, int priority, String tunnelId) {
+        this.srManager = srm;
+        this.id = checkNotNull(policyId);
+        this.type = type;
+        this.tunnelId = tunnelId;
+        this.priority = priority;
+        this.selector = selector;
+    }
+
+    /**
+     * Creates a TunnelPolicy reference.
+     *
+     * @param p TunnelPolicy reference
+     */
+    public TunnelPolicy(TunnelPolicy p) {
+        this.srManager = p.srManager;
+        this.id = p.id;
+        this.type = p.type;
+        this.tunnelId = p.tunnelId;
+        this.priority = p.priority;
+        this.selector = p.selector;
+    }
+
+    /**
+     * Creates a TunnelPolicy reference.
+     *
+     * @param p TunnelPolicy reference
+     */
+    public TunnelPolicy(SegmentRoutingManager srm, TunnelPolicy p) {
+        this.srManager = srm;
+        this.id = p.id;
+        this.type = p.type;
+        this.tunnelId = p.tunnelId;
+        this.priority = p.priority;
+        this.selector = p.selector;
+    }
+
+    /**
+     * Returns the TunnelPolicy builder reference.
+     *
+     * @return TunnelPolicy builder
+     */
+    public static TunnelPolicy.Builder builder() {
+        return new Builder();
+    }
+
+    @Override
+    public String id() {
+        return this.id;
+    }
+
+    @Override
+    public TrafficSelector selector() {
+        return selector;
+    }
+
+    @Override
+    public int priority() {
+        return priority;
+    }
+
+    @Override
+    public Type type() {
+        return type;
+    }
+
+    @Override
+    public boolean create() {
+
+        Tunnel tunnel = srManager.getTunnel(tunnelId);
+
+        ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective
+                .builder()
+                .fromApp(srManager.appId)
+                .makePermanent()
+                .nextStep(tunnel.groupId())
+                .withPriority(priority)
+                .withSelector(selector)
+                .withFlag(ForwardingObjective.Flag.VERSATILE);
+
+        srManager.flowObjectiveService.forward(tunnel.source(), fwdBuilder.add());
+
+        return true;
+    }
+
+    @Override
+    public boolean remove() {
+
+        Tunnel tunnel = srManager.getTunnel(tunnelId);
+
+        ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective
+                .builder()
+                .fromApp(srManager.appId)
+                .makePermanent()
+                .withSelector(selector)
+                .withPriority(priority)
+                .nextStep(tunnel.groupId())
+                .withFlag(ForwardingObjective.Flag.VERSATILE);
+
+        srManager.flowObjectiveService.forward(tunnel.source(), fwdBuilder.remove());
+
+        return true;
+    }
+
+    /**
+     * Returns the tunnel ID of the policy.
+     *
+     * @return Tunnel ID
+     */
+    public String tunnelId() {
+        return this.tunnelId;
+    }
+
+    /**
+     * Tunnel Policy Builder.
+     */
+    public static final class Builder {
+
+        private SegmentRoutingManager srManager;
+        private String id;
+        private Type type;
+        private TrafficSelector selector;
+        private int priority;
+        private String tunnelId;
+
+        /**
+         * Sets the policy Id.
+         *
+         * @param id policy Id
+         * @return Builder object
+         */
+        public Builder setPolicyId(String id) {
+            this.id = id;
+
+            return this;
+        }
+
+        /**
+         * Sets the policy type.
+         *
+         * @param type policy type
+         * @return Builder object
+         */
+        public Builder setType(Type type) {
+            this.type = type;
+
+            return this;
+        }
+
+        /**
+         * Sets the TrafficSelector.
+         *
+         * @param selector TrafficSelector
+         * @return Builder object
+         */
+        public Builder setSelector(TrafficSelector selector) {
+            this.selector = selector;
+
+            return this;
+        }
+
+        /**
+         * Sets the priority of the policy.
+         *
+         * @param p priority
+         * @return Builder object
+         */
+        public Builder setPriority(int p) {
+            this.priority = p;
+
+            return this;
+        }
+
+        /**
+         * Sets the tunnel Id.
+         *
+         * @param tunnelId tunnel Id
+         * @return Builder object
+         */
+        public Builder setTunnelId(String tunnelId) {
+            this.tunnelId = tunnelId;
+
+            return this;
+        }
+
+        /**
+         * Sets the Segment Routing Manager reference.
+         *
+         * @param srm Segment Routing Manager reference
+         * @return Builder object
+         */
+        public Builder setManager(SegmentRoutingManager srm) {
+            this.srManager = srm;
+
+            return this;
+        }
+
+        /**
+         * Builds the policy.
+         *
+         * @return Tunnel Policy reference
+         */
+        public Policy build() {
+            return new TunnelPolicy(srManager, id, type, selector, priority, tunnelId);
+        }
+    }
+}

@@ -24,6 +24,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Random;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -418,7 +419,12 @@ public class DefaultGroupHandler {
         return nsSegmentIds;
     }
 
-    protected void createGroupsFromNeighborsets(Set<NeighborSet> nsSet) {
+    /**
+     * Creates Groups from a set of NeighborSet given.
+     *
+     * @param nsSet a set of NeighborSet
+     */
+    public void createGroupsFromNeighborsets(Set<NeighborSet> nsSet) {
         for (NeighborSet ns : nsSet) {
             int nextId = flowObjectiveService.allocateNextId();
             NextObjective.Builder nextObjBuilder = DefaultNextObjective
@@ -451,7 +457,7 @@ public class DefaultGroupHandler {
             NextObjective nextObj = nextObjBuilder.add();
             flowObjectiveService.next(deviceId, nextObj);
             log.debug("createGroupsFromNeighborsets: Submited "
-                    + "next objective {} in device {}",
+                            + "next objective {} in device {}",
                     nextId, deviceId);
             nsNextObjStore.put(new NeighborSetNextObjectiveStoreKey(deviceId, ns),
                                nextId);
@@ -462,4 +468,29 @@ public class DefaultGroupHandler {
         return new DefaultGroupKey(kryo.build().serialize(obj));
     }
 
+    /**
+     * Removes groups for the next objective ID given.
+     *
+     * @param objectiveId next objective ID to remove
+     * @return true if succeeds, false otherwise
+     */
+    public boolean removeGroup(int objectiveId) {
+
+        if (nsNextObjStore.containsValue(objectiveId)) {
+            NextObjective.Builder nextObjBuilder = DefaultNextObjective
+                    .builder().withId(objectiveId)
+                    .withType(NextObjective.Type.HASHED).fromApp(appId);
+            NextObjective nextObjective = nextObjBuilder.remove();
+            flowObjectiveService.next(deviceId, nextObjective);
+
+            for (Map.Entry<NeighborSetNextObjectiveStoreKey, Integer> entry: nsNextObjStore.entrySet()) {
+                if (entry.getValue().equals(objectiveId)) {
+                    nsNextObjStore.remove(entry.getKey());
+                    break;
+                }
+            }
+        }
+
+        return false;
+    }
 }

+/*
+ * 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.segmentrouting.web;
+
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.IpPrefix;
+import org.onosproject.cli.net.IpProtocol;
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.onosproject.net.flow.DefaultTrafficSelector;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.criteria.Criterion;
+import org.onosproject.net.flow.criteria.IPCriterion;
+import org.onosproject.net.flow.criteria.IPProtocolCriterion;
+import org.onosproject.segmentrouting.Policy;
+import org.onosproject.segmentrouting.TunnelPolicy;
+
+public final class PolicyCodec extends JsonCodec<Policy> {
+
+    // JSON field names
+    private static final String POLICY_ID = "policy_id";
+    private static final String PRIORITY = "priority";
+    private static final String TYPE = "policy_type";
+    private static final String TUNNEL_ID = "tunnel_id";
+    private static final String DST_IP = "dst_ip";
+    private static final String SRC_IP = "src_ip";
+    private static final String PROTO_TYPE = "proto_type";
+
+    @Override
+    public ObjectNode encode(Policy policy, CodecContext context) {
+        final ObjectNode result = context.mapper().createObjectNode()
+                .put(POLICY_ID, policy.id());
+
+        result.put(PRIORITY, policy.priority());
+        result.put(TYPE, policy.type().toString());
+
+        if (policy.selector().getCriterion(Criterion.Type.IPV4_DST) != null) {
+            IPCriterion criterion = (IPCriterion) policy.selector().getCriterion(
+                    Criterion.Type.IPV4_DST);
+            result.put(DST_IP, criterion.ip().toString());
+        }
+        if (policy.selector().getCriterion(Criterion.Type.IPV4_SRC) != null) {
+            IPCriterion criterion = (IPCriterion) policy.selector().getCriterion(
+                    Criterion.Type.IPV4_SRC);
+            result.put(SRC_IP, criterion.ip().toString());
+        }
+        if (policy.selector().getCriterion(Criterion.Type.IP_PROTO) != null) {
+            IPProtocolCriterion protocolCriterion =
+                    (IPProtocolCriterion) policy.selector().getCriterion(Criterion.Type.IP_PROTO);
+            result.put(PROTO_TYPE, protocolCriterion.toString());
+        }
+
+        if (policy.type() == Policy.Type.TUNNEL_FLOW) {
+            result.put(TUNNEL_ID, ((TunnelPolicy) policy).tunnelId());
+        }
+
+        return result;
+    }
+
+    @Override
+    public Policy decode(ObjectNode json, CodecContext context) {
+
+        String pid = json.path(POLICY_ID).asText();
+        String type = json.path(TYPE).asText();
+        int priority = json.path(PRIORITY).asInt();
+        String dstIp = json.path(DST_IP).asText();
+        String srcIp = json.path(SRC_IP).asText();
+        String tunnelId = json.path(TUNNEL_ID).asText();
+        String protoType = json.path(PROTO_TYPE).asText();
+
+        if (tunnelId != null) {
+            TrafficSelector.Builder tsb = DefaultTrafficSelector.builder();
+            tsb.matchEthType(Ethernet.TYPE_IPV4);
+            if (dstIp != null && !dstIp.isEmpty()) {
+                tsb.matchIPDst(IpPrefix.valueOf(dstIp));
+            }
+            if (srcIp != null && !srcIp.isEmpty()) {
+                tsb.matchIPSrc(IpPrefix.valueOf(srcIp));
+            }
+            if (protoType != null && !protoType.isEmpty()) {
+                Short ipProto = Short.valueOf(IpProtocol.valueOf(protoType).value());
+                tsb.matchIPProtocol(ipProto.byteValue());
+            }
+
+            TunnelPolicy.Builder tpb = TunnelPolicy.builder().setPolicyId(pid);
+            if (tunnelId != null) {
+                tpb.setTunnelId(tunnelId);
+            }
+            if (!json.path(PRIORITY).isMissingNode()) {
+                tpb.setPriority(priority);
+            }
+            if (!json.path(TYPE).isMissingNode()) {
+                tpb.setType(Policy.Type.valueOf(type));
+            }
+            tpb.setSelector(tsb.build());
+
+            return tpb.build();
+        } else {
+            // TODO: handle more policy types
+            return null;
+        }
+
+
+    }
+
+}

+/*
+ * 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.segmentrouting.web;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+import org.onosproject.rest.AbstractWebResource;
+import org.onosproject.segmentrouting.Policy;
+import org.onosproject.segmentrouting.SegmentRoutingManager;
+import org.onosproject.segmentrouting.SegmentRoutingService;
+import org.onosproject.segmentrouting.TunnelPolicy;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+@Path("policy")
+public class PolicyWebResource extends AbstractWebResource {
+
+    private static final PolicyCodec POLICY_CODEC = new PolicyCodec();
+
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    public Response getPolicy() {
+        SegmentRoutingService srService = get(SegmentRoutingService.class);
+        List<Policy> policies = srService.getPolicies();
+        ObjectNode result = new ObjectMapper().createObjectNode();
+        result.set("policy", new PolicyCodec().encode(policies, this));
+
+        return ok(result.toString()).build();
+    }
+
+    @POST
+    @Consumes(MediaType.APPLICATION_JSON)
+    public Response createPolicy(InputStream input) throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        ObjectNode policyJson = (ObjectNode) mapper.readTree(input);
+        SegmentRoutingService srService = get(SegmentRoutingService.class);
+        Policy policyInfo = POLICY_CODEC.decode(policyJson, this);
+        if (policyInfo.type() == Policy.Type.TUNNEL_FLOW) {
+            TunnelPolicy policy = new TunnelPolicy((SegmentRoutingManager) srService, (TunnelPolicy) policyInfo);
+            srService.createPolicy(policy);
+
+            return Response.ok().build();
+        } else {
+            return Response.serverError().build();
+        }
+    }
+
+    @DELETE
+    @Consumes(MediaType.APPLICATION_JSON)
+    public Response removePolicy(InputStream input) throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        ObjectNode policyJson = (ObjectNode) mapper.readTree(input);
+        SegmentRoutingService srService = get(SegmentRoutingService.class);
+        Policy policyInfo = POLICY_CODEC.decode(policyJson, this);
+        // TODO: Check the result
+        srService.removePolicy(policyInfo);
+        return Response.ok().build();
+
+    }
+
+}

+/*
+ * 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.segmentrouting.web;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.onosproject.segmentrouting.DefaultTunnel;
+import org.onosproject.segmentrouting.Tunnel;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class TunnelCodec extends JsonCodec<Tunnel> {
+
+    // JSON field names
+    private static final String TUNNEL_ID = "tunnel_id";
+    private static final String GROUP_ID = "group_id";
+    private static final String LABEL_PATH = "label_path";
+
+    @Override
+    public ObjectNode encode(Tunnel tunnel, CodecContext context) {
+        final ObjectNode result = context.mapper().createObjectNode()
+                .put(TUNNEL_ID, tunnel.id());
+
+        result.put(GROUP_ID, tunnel.groupId());
+
+        final ArrayNode jsonLabelIds = result.putArray(LABEL_PATH);
+
+        tunnel.labelIds().forEach(label -> jsonLabelIds.add(label.intValue()));
+
+        return result;
+    }
+
+    @Override
+    public DefaultTunnel decode(ObjectNode json, CodecContext context) {
+
+        String tid = json.path(TUNNEL_ID).asText();
+        List<Integer> labels = new ArrayList<>();
+
+        if (!json.path(LABEL_PATH).isMissingNode()) {
+            ArrayNode labelArray = (ArrayNode) json.path(LABEL_PATH);
+            for (JsonNode o : labelArray) {
+                labels.add(o.asInt());
+            }
+        }
+
+        return new DefaultTunnel(tid, labels);
+    }
+
+}

+/*
+ * 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.segmentrouting.web;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+import org.onosproject.rest.AbstractWebResource;
+import org.onosproject.segmentrouting.DefaultTunnel;
+import org.onosproject.segmentrouting.SegmentRoutingManager;
+import org.onosproject.segmentrouting.SegmentRoutingService;
+import org.onosproject.segmentrouting.Tunnel;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+@Path("tunnel")
+public class TunnelWebResource extends AbstractWebResource {
+
+    private static final TunnelCodec TUNNEL_CODEC = new TunnelCodec();
+
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    public Response getTunnel() {
+        SegmentRoutingService srService = get(SegmentRoutingService.class);
+        List<Tunnel> tunnels = srService.getTunnels();
+        ObjectNode result = new ObjectMapper().createObjectNode();
+        result.set("tunnel", new TunnelCodec().encode(tunnels, this));
+
+        return ok(result.toString()).build();
+    }
+
+    @POST
+    @Consumes(MediaType.APPLICATION_JSON)
+    public Response createTunnel(InputStream input) throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        ObjectNode tunnelJson = (ObjectNode) mapper.readTree(input);
+        SegmentRoutingService srService = get(SegmentRoutingService.class);
+        Tunnel tunnelInfo = TUNNEL_CODEC.decode(tunnelJson, this);
+        Tunnel tunnel = new DefaultTunnel((SegmentRoutingManager) srService,
+                tunnelInfo.id(), tunnelInfo.labelIds());
+        srService.createTunnel(tunnel);
+
+        return Response.ok().build();
+    }
+
+    @DELETE
+    @Consumes(MediaType.APPLICATION_JSON)
+    public Response removeTunnel(InputStream input) throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        ObjectNode tunnelJson = (ObjectNode) mapper.readTree(input);
+        SegmentRoutingService srService = get(SegmentRoutingService.class);
+        Tunnel tunnelInfo = TUNNEL_CODEC.decode(tunnelJson, this);
+        srService.removeTunnel(tunnelInfo);
+
+        return Response.ok().build();
+    }
+
+}

+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ 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.
+  -->
+<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
+         xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
+         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
+         id="ONOS" version="2.5">
+    <display-name>Segment Routing REST API v1.0</display-name>
+
+    <servlet>
+        <servlet-name>JAX-RS Service</servlet-name>
+        <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
+        <init-param>
+            <param-name>com.sun.jersey.config.property.resourceConfigClass</param-name>
+            <param-value>com.sun.jersey.api.core.ClassNamesResourceConfig</param-value>
+        </init-param>
+        <init-param>
+            <param-name>com.sun.jersey.config.property.classnames</param-name>
+            <param-value>
+                org.onosproject.segmentrouting.web.TunnelWebResource,
+                org.onosproject.segmentrouting.web.PolicyWebResource
+            </param-value>
+        </init-param>
+        <load-on-startup>1</load-on-startup>
+    </servlet>
+
+    <servlet-mapping>
+        <servlet-name>JAX-RS Service</servlet-name>
+        <url-pattern>/*</url-pattern>
+    </servlet-mapping>
+</web-app>

@@ -195,7 +195,6 @@ public final class DefaultNextObjective implements NextObjective {
             checkNotNull(appId, "Must supply an application id");
             checkNotNull(id, "id cannot be null");
             checkNotNull(type, "The type cannot be null");
-            checkArgument(!treatments.isEmpty(), "Must have at least one treatment");
 
             return new DefaultNextObjective(id, treatments, appId, type, Operation.REMOVE);
         }

@@ -49,6 +49,7 @@ import org.onosproject.net.flow.criteria.Criterion;
 import org.onosproject.net.flow.criteria.EthCriterion;
 import org.onosproject.net.flow.criteria.EthTypeCriterion;
 import org.onosproject.net.flow.criteria.IPCriterion;
+import org.onosproject.net.flow.criteria.IPProtocolCriterion;
 import org.onosproject.net.flow.criteria.MplsCriterion;
 import org.onosproject.net.flow.criteria.PortCriterion;
 import org.onosproject.net.flow.criteria.VlanIdCriterion;
@@ -215,7 +216,7 @@ public class SpringOpenTTP extends AbstractHandlerBehaviour
     public void next(NextObjective nextObjective) {
 
         if (nextObjective.op() == Objective.Operation.REMOVE) {
-            if (nextObjective.next() == null) {
+            if (nextObjective.next().isEmpty()) {
                 removeGroup(nextObjective);
             } else {
                 removeBucketFromGroup(nextObjective);
@@ -369,8 +370,89 @@ public class SpringOpenTTP extends AbstractHandlerBehaviour
     }
 
     private Collection<FlowRule> processVersatile(ForwardingObjective fwd) {
-        fail(fwd, ObjectiveError.UNSUPPORTED);
-        return Collections.emptySet();
+        log.debug("Processing versatile forwarding objective");
+        TrafficSelector selector = fwd.selector();
+
+        EthTypeCriterion ethType =
+                (EthTypeCriterion) selector.getCriterion(Criterion.Type.ETH_TYPE);
+        if (ethType == null) {
+            log.error("Versatile forwarding objective must include ethType");
+            fail(fwd, ObjectiveError.UNKNOWN);
+            return Collections.emptySet();
+        }
+
+        TrafficSelector.Builder filteredSelectorBuilder =
+                DefaultTrafficSelector.builder();
+        if (ethType.ethType() == Ethernet.TYPE_IPV4) {
+            IPCriterion ipSrc = (IPCriterion) selector
+                    .getCriterion(Criterion.Type.IPV4_SRC);
+            IPCriterion ipDst = (IPCriterion) selector
+                    .getCriterion(Criterion.Type.IPV4_DST);
+            IPProtocolCriterion ipProto = (IPProtocolCriterion) selector
+                    .getCriterion(Criterion.Type.IP_PROTO);
+
+            filteredSelectorBuilder
+                    .matchEthType(Ethernet.TYPE_IPV4);
+
+            if (ipSrc != null) {
+                filteredSelectorBuilder.matchIPSrc(ipSrc.ip());
+            }
+            if (ipDst != null) {
+                filteredSelectorBuilder.matchIPDst(ipDst.ip());
+            }
+            if (ipProto != null) {
+                filteredSelectorBuilder.matchIPProtocol(
+                        Short.valueOf(ipProto.protocol()).byteValue());
+            }
+
+            log.debug("processing IPv4 specific forwarding objective");
+        } else {
+            log.warn("VERSATILE forwarding objective does not support {} yet.",
+                    ethType.ethType());
+            return Collections.emptySet();
+        }
+
+        TrafficTreatment.Builder treatmentBuilder = DefaultTrafficTreatment
+                .builder();
+        treatmentBuilder.wipeDeferred();
+
+        if (fwd.nextId() != null) {
+            NextGroup next = flowObjectiveStore.getNextGroup(fwd.nextId());
+
+            if (next != null) {
+                GroupKey key = appKryo.deserialize(next.data());
+
+                Group group = groupService.getGroup(deviceId, key);
+
+                if (group == null) {
+                    log.warn("The group left!");
+                    fail(fwd, ObjectiveError.GROUPMISSING);
+                    return Collections.emptySet();
+                }
+                treatmentBuilder.deferred().group(group.id());
+                log.debug("Adding OUTGROUP action");
+            }
+        } else {
+            log.warn("VERSATILE forwarding objective need next objective ID.");
+            return Collections.emptySet();
+        }
+
+        TrafficSelector filteredSelector = filteredSelectorBuilder.build();
+        TrafficTreatment treatment = treatmentBuilder.build();
+
+        FlowRule.Builder ruleBuilder = DefaultFlowRule.builder()
+                .fromApp(fwd.appId()).withPriority(fwd.priority())
+                .forDevice(deviceId).withSelector(filteredSelector)
+                .withTreatment(treatment);
+
+        if (fwd.permanent()) {
+            ruleBuilder.makePermanent();
+        } else {
+            ruleBuilder.makeTemporary(fwd.timeout());
+        }
+
+        ruleBuilder.forTable(aclTableId);
+        return Collections.singletonList(ruleBuilder.build());
     }
 
     protected Collection<FlowRule> processSpecific(ForwardingObjective fwd) {
@@ -434,7 +516,7 @@ public class SpringOpenTTP extends AbstractHandlerBehaviour
                     fail(fwd, ObjectiveError.GROUPMISSING);
                     return Collections.emptySet();
                 }
-                treatmentBuilder.group(group.id());
+                treatmentBuilder.deferred().group(group.id());
                 log.debug("Adding OUTGROUP action");
             } else {
                 log.warn("processSpecific: No associated next objective object");

@@ -104,12 +104,12 @@ public class FlowModBuilderVer13 extends FlowModBuilder {
         List<OFInstruction> instructions = Lists.newLinkedList();
 
 
-        if (immediateActions.size() > 0) {
-            instructions.add(factory().instructions().applyActions(immediateActions));
-        }
         if (treatment.clearedDeferred()) {
             instructions.add(factory().instructions().clearActions());
         }
+        if (immediateActions.size() > 0) {
+            instructions.add(factory().instructions().applyActions(immediateActions));
+        }
         if (deferredActions.size() > 0) {
             instructions.add(factory().instructions().writeActions(deferredActions));
         }