ONOS-685: Network Configuration Manager support for Segment Routing application

Change-Id: Ia15bfd24559dd5542633c8b76d500b2d31362340

-/*
- * 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.grouphandler;
-
-import static org.slf4j.LoggerFactory.getLogger;
-
-import java.net.URI;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-
-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.onlab.packet.MacAddress;
-import org.onlab.util.KryoNamespace;
-import org.onosproject.core.ApplicationId;
-import org.onosproject.core.CoreService;
-import org.onosproject.mastership.MastershipService;
-import org.onosproject.net.Device;
-import org.onosproject.net.DeviceId;
-import org.onosproject.net.MastershipRole;
-import org.onosproject.net.device.DeviceEvent;
-import org.onosproject.net.device.DeviceListener;
-import org.onosproject.net.device.DeviceService;
-import org.onosproject.net.group.GroupService;
-import org.onosproject.net.link.LinkEvent;
-import org.onosproject.net.link.LinkListener;
-import org.onosproject.net.link.LinkService;
-import org.onosproject.net.topology.TopologyService;
-import org.slf4j.Logger;
-
-/**
- * Sample application to verify group subsystem end to end.
- * This application expects a network of maximum of six connected
- * devices for the test to work. For every device in the network,
- * this test application launches a default group handler function
- * that creates ECMP groups for every neighbor the device is
- * connected to.
- */
-@Component(immediate = true)
-public class DefaultGroupHandlerApp {
-
-    private final Logger log = getLogger(getClass());
-
-    private final DeviceProperties config = new DeviceConfiguration();
-    private ApplicationId appId;
-    private HashMap<DeviceId, DefaultGroupHandler> dghMap =
-            new HashMap<DeviceId, DefaultGroupHandler>();
-
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected TopologyService topologyService;
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected DeviceService deviceService;
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected LinkService linkService;
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected GroupService groupService;
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected CoreService coreService;
-    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
-    protected MastershipService mastershipService;
-
-    private DeviceListener deviceListener = new InternalDeviceListener();
-    private LinkListener linkListener = new InternalLinkListener();
-
-    protected KryoNamespace.Builder kryo = new KryoNamespace.Builder()
-                        .register(URI.class)
-                        .register(HashSet.class)
-                        .register(DeviceId.class)
-                        .register(NeighborSet.class);
-
-    @Activate
-    public void activate() {
-        appId = coreService.registerApplication("org.onosproject.defaultgrouphandler");
-        log.info("DefaultGroupHandlerApp Activating");
-
-        deviceService.addListener(deviceListener);
-        linkService.addListener(linkListener);
-        for (Device device: deviceService.getDevices()) {
-            if (mastershipService.
-                    getLocalRole(device.id()) == MastershipRole.MASTER) {
-                log.debug("Initiating default group handling for {}", device.id());
-                DefaultGroupHandler dgh = DefaultGroupHandler.createGroupHandler(device.id(),
-                                                                  appId,
-                                                                  config,
-                                                                  linkService,
-                                                                  groupService);
-                dgh.createGroups();
-                dghMap.put(device.id(), dgh);
-            } else {
-                log.debug("Activate: Local role {} "
-                        + "is not MASTER for device {}",
-                          mastershipService.
-                          getLocalRole(device.id()),
-                          device.id());
-            }
-        }
-
-        log.info("Activated");
-    }
-
-    @Deactivate
-    public void deactivate() {
-        dghMap.clear();
-    }
-
-    public class DeviceConfiguration implements DeviceProperties {
-        private final List<Integer> allSegmentIds =
-                Arrays.asList(101, 102, 103, 104, 105, 106);
-        private HashMap<DeviceId, Integer> deviceSegmentIdMap =
-                new HashMap<DeviceId, Integer>() {
-            {
-                put(DeviceId.deviceId("of:0000000000000001"), 101);
-                put(DeviceId.deviceId("of:0000000000000002"), 102);
-                put(DeviceId.deviceId("of:0000000000000003"), 103);
-                put(DeviceId.deviceId("of:0000000000000004"), 104);
-                put(DeviceId.deviceId("of:0000000000000005"), 105);
-                put(DeviceId.deviceId("of:0000000000000006"), 106);
-            }
-        };
-        private final HashMap<DeviceId, MacAddress> deviceMacMap =
-                new HashMap<DeviceId, MacAddress>() {
-            {
-                put(DeviceId.deviceId("of:0000000000000001"),
-                     MacAddress.valueOf("00:00:00:00:00:01"));
-                put(DeviceId.deviceId("of:0000000000000002"),
-                     MacAddress.valueOf("00:00:00:00:00:02"));
-                put(DeviceId.deviceId("of:0000000000000003"),
-                     MacAddress.valueOf("00:00:00:00:00:03"));
-                put(DeviceId.deviceId("of:0000000000000004"),
-                     MacAddress.valueOf("00:00:00:00:00:04"));
-                put(DeviceId.deviceId("of:0000000000000005"),
-                     MacAddress.valueOf("00:00:00:00:00:05"));
-                put(DeviceId.deviceId("of:0000000000000006"),
-                     MacAddress.valueOf("00:00:00:00:00:06"));
-            }
-        };
-
-        @Override
-        public int getSegmentId(DeviceId deviceId) {
-            if (deviceSegmentIdMap.get(deviceId) != null) {
-                log.debug("getSegmentId for device{} is {}",
-                          deviceId,
-                          deviceSegmentIdMap.get(deviceId));
-                return deviceSegmentIdMap.get(deviceId);
-            } else {
-                throw new IllegalStateException();
-            }
-        }
-        @Override
-        public MacAddress getDeviceMac(DeviceId deviceId) {
-            if (deviceMacMap.get(deviceId) != null) {
-                log.debug("getDeviceMac for device{} is {}",
-                          deviceId,
-                          deviceMacMap.get(deviceId));
-                return deviceMacMap.get(deviceId);
-            } else {
-                throw new IllegalStateException();
-            }
-        }
-        @Override
-        public boolean isEdgeDevice(DeviceId deviceId) {
-            return true;
-        }
-        @Override
-        public List<Integer> getAllDeviceSegmentIds() {
-            return allSegmentIds;
-        }
-    }
-
-    private class InternalDeviceListener implements DeviceListener {
-
-        @Override
-        public void event(DeviceEvent event) {
-           if (mastershipService.
-                    getLocalRole(event.subject().id()) != MastershipRole.MASTER) {
-               log.debug("Local role {} is not MASTER for device {}",
-                         mastershipService.
-                         getLocalRole(event.subject().id()),
-                         event.subject().id());
-               return;
-           }
-           switch (event.type()) {
-            case DEVICE_ADDED:
-                log.debug("Initiating default group handling for {}", event.subject().id());
-                DefaultGroupHandler dgh = DefaultGroupHandler.createGroupHandler(
-                                                                  event.subject().id(),
-                                                                  appId,
-                                                                  config,
-                                                                  linkService,
-                                                                  groupService);
-                dgh.createGroups();
-                dghMap.put(event.subject().id(), dgh);
-                break;
-            case PORT_REMOVED:
-                if (dghMap.get(event.subject().id()) != null) {
-                    dghMap.get(event.subject().id()).portDown(event.port().number());
-                }
-                break;
-            default:
-                break;
-            }
-
-        }
-    }
-
-    private class InternalLinkListener implements LinkListener {
-
-        @Override
-        public void event(LinkEvent event) {
-            if (mastershipService.
-                    getLocalRole(event.subject().src().deviceId()) !=
-                    MastershipRole.MASTER) {
-                log.debug("InternalLinkListener: Local role {} "
-                        + "is not MASTER for device {}",
-                          mastershipService.
-                          getLocalRole(event.subject().src().deviceId()),
-                          event.subject().src().deviceId());
-                return;
-            }
-            switch (event.type()) {
-            case LINK_ADDED:
-                if (dghMap.get(event.subject().src().deviceId()) != null) {
-                    dghMap.get(event.subject().src().deviceId()).linkUp(event.subject());
-                }
-                break;
-            default:
-                break;
-            }
-        }
-
-    }
-}
\ No newline at end of file

@@ -45,7 +45,6 @@
         <module>reactive-routing</module>
         <module>reactive-routing</module>
         <module>bgprouter</module>
         <module>bgprouter</module>
         <module>test</module>
         <module>test</module>
-        <module>grouphandler</module>
         <module>segmentrouting</module>
         <module>segmentrouting</module>
     </modules>
     </modules>
 
 

@@ -19,7 +19,6 @@ import org.onlab.packet.ARP;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.Ip4Address;
 import org.onlab.packet.Ip4Address;
 import org.onlab.packet.IpAddress;
 import org.onlab.packet.IpAddress;
-import org.onlab.packet.IpPrefix;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.MacAddress;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.DeviceId;
@@ -36,7 +35,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
 import java.nio.ByteBuffer;
 import java.nio.ByteBuffer;
-
+import java.util.List;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 public class ArpHandler {
 public class ArpHandler {
@@ -112,11 +111,11 @@ public class ArpHandler {
 
 
 
 
     private boolean isArpReqForRouter(DeviceId deviceId, ARP arpRequest) {
     private boolean isArpReqForRouter(DeviceId deviceId, ARP arpRequest) {
-        Ip4Address gatewayIpAddress = config.getGatewayIpAddress(deviceId);
-        if (gatewayIpAddress != null) {
+        List<Ip4Address> gatewayIpAddresses = config.getGatewayIpAddress(deviceId);
+        if (gatewayIpAddresses != null) {
             Ip4Address targetProtocolAddress = Ip4Address.valueOf(arpRequest
             Ip4Address targetProtocolAddress = Ip4Address.valueOf(arpRequest
                     .getTargetProtocolAddress());
                     .getTargetProtocolAddress());
-            if (gatewayIpAddress.equals(targetProtocolAddress)) {
+            if (gatewayIpAddresses.contains(targetProtocolAddress)) {
                 return true;
                 return true;
             }
             }
         }
         }
@@ -124,15 +123,11 @@ public class ArpHandler {
     }
     }
 
 
     private boolean isArpReqForSubnet(DeviceId deviceId, ARP arpRequest) {
     private boolean isArpReqForSubnet(DeviceId deviceId, ARP arpRequest) {
-        String subnetInfo = config.getSubnetInfo(deviceId);
-        if (subnetInfo != null) {
-            IpPrefix prefix = IpPrefix.valueOf(subnetInfo);
-            if (prefix.contains(Ip4Address.valueOf(arpRequest.getTargetProtocolAddress()))) {
-                return true;
-            }
-        }
-
-        return false;
+        return config.getSubnetInfo(deviceId).stream()
+                     .anyMatch((prefix)->
+                     prefix.contains(Ip4Address.
+                                     valueOf(arpRequest.
+                                             getTargetProtocolAddress())));
     }
     }
 
 
     /**
     /**

@@ -15,6 +15,7 @@
  */
  */
 package org.onosproject.segmentrouting;
 package org.onosproject.segmentrouting;
 
 
+import org.onlab.packet.Ip4Prefix;
 import org.onlab.packet.IpPrefix;
 import org.onlab.packet.IpPrefix;
 import org.onosproject.net.Device;
 import org.onosproject.net.Device;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.DeviceId;
@@ -26,6 +27,7 @@ import org.slf4j.LoggerFactory;
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 import java.util.Set;
 
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkNotNull;
@@ -139,8 +141,11 @@ public class DefaultRoutingHandler {
         // If both target switch and dest switch are edge routers, then set IP rule
         // If both target switch and dest switch are edge routers, then set IP rule
         // for both subnet and router IP.
         // for both subnet and router IP.
         if (config.isEdgeRouter(targetSw) && config.isEdgeRouter(destSw)) {
         if (config.isEdgeRouter(targetSw) && config.isEdgeRouter(destSw)) {
-            String subnets = config.getSubnetInfo(destSw);
-            result = rulePopulator.populateIpRuleForSubnet(targetSw, subnets, destSw, nextHops);
+            List<Ip4Prefix> subnets = config.getSubnetInfo(destSw);
+            result = rulePopulator.populateIpRuleForSubnet(targetSw,
+                                                           subnets,
+                                                           destSw,
+                                                           nextHops);
             if (!result) {
             if (!result) {
                 return false;
                 return false;
             }
             }

 package org.onosproject.segmentrouting;
 package org.onosproject.segmentrouting;
 
 
 import org.onlab.packet.Ip4Address;
 import org.onlab.packet.Ip4Address;
+import org.onlab.packet.Ip4Prefix;
+import org.onlab.packet.IpPrefix;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.MacAddress;
-import org.onosproject.grouphandler.DeviceProperties;
+import org.onosproject.segmentrouting.grouphandler.DeviceProperties;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.DeviceId;
+import org.onosproject.net.PortNumber;
+import org.onosproject.segmentrouting.config.NetworkConfig.SwitchConfig;
+import org.onosproject.segmentrouting.config.NetworkConfigManager;
+import org.onosproject.segmentrouting.config.SegmentRouterConfig;
+import org.onosproject.segmentrouting.config.SegmentRouterConfig.Subnet;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
-import java.util.Arrays;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashMap;
 import java.util.List;
 import java.util.List;
 import java.util.Map;
 import java.util.Map;
 
 
+/**
+ * Segment Routing configuration component that reads the
+ * segment routing related configuration from Network Configuration Manager
+ * component and organizes in more accessible formats.
+ *
+ * TODO: Merge multiple Segment Routing configuration wrapper classes into one.
+ */
 public class DeviceConfiguration implements DeviceProperties {
 public class DeviceConfiguration implements DeviceProperties {
 
 
     private static final Logger log = LoggerFactory
     private static final Logger log = LoggerFactory
             .getLogger(DeviceConfiguration.class);
             .getLogger(DeviceConfiguration.class);
-    private final List<Integer> allSegmentIds =
-            Arrays.asList(101, 102, 103, 104, 105, 106);
-    private HashMap<DeviceId, Integer> deviceSegmentIdMap =
-            new HashMap<DeviceId, Integer>() {
-                {
-                    put(DeviceId.deviceId("of:0000000000000001"), 101);
-                    put(DeviceId.deviceId("of:0000000000000002"), 102);
-                    put(DeviceId.deviceId("of:0000000000000003"), 103);
-                    put(DeviceId.deviceId("of:0000000000000004"), 104);
-                    put(DeviceId.deviceId("of:0000000000000005"), 105);
-                    put(DeviceId.deviceId("of:0000000000000006"), 106);
-                }
-            };
-    private final HashMap<DeviceId, MacAddress> deviceMacMap =
-            new HashMap<DeviceId, MacAddress>() {
-                {
-                    put(DeviceId.deviceId("of:0000000000000001"),
-                            MacAddress.valueOf("00:00:00:00:00:01"));
-                    put(DeviceId.deviceId("of:0000000000000002"),
-                            MacAddress.valueOf("00:00:00:00:00:02"));
-                    put(DeviceId.deviceId("of:0000000000000003"),
-                            MacAddress.valueOf("00:00:00:00:00:03"));
-                    put(DeviceId.deviceId("of:0000000000000004"),
-                            MacAddress.valueOf("00:00:00:00:00:04"));
-                    put(DeviceId.deviceId("of:0000000000000005"),
-                            MacAddress.valueOf("00:00:00:00:00:05"));
-                    put(DeviceId.deviceId("of:0000000000000006"),
-                            MacAddress.valueOf("00:00:00:00:00:06"));
-                }
-            };
-
-    private final HashMap<DeviceId, Ip4Address> deviceIpMap =
-            new HashMap<DeviceId, Ip4Address>() {
-                {
-                    put(DeviceId.deviceId("of:0000000000000001"),
-                            Ip4Address.valueOf("192.168.0.1"));
-                    put(DeviceId.deviceId("of:0000000000000002"),
-                            Ip4Address.valueOf("192.168.0.2"));
-                    put(DeviceId.deviceId("of:0000000000000003"),
-                            Ip4Address.valueOf("192.168.0.3"));
-                    put(DeviceId.deviceId("of:0000000000000004"),
-                            Ip4Address.valueOf("192.168.0.4"));
-                    put(DeviceId.deviceId("of:0000000000000005"),
-                            Ip4Address.valueOf("192.168.0.5"));
-                    put(DeviceId.deviceId("of:0000000000000006"),
-                            Ip4Address.valueOf("192.168.0.6"));
-                }
-            };
+    private final List<Integer> allSegmentIds = new ArrayList<Integer>();
+    private final HashMap<DeviceId, SegmentRouterInfo> deviceConfigMap = new HashMap<>();
+    private final NetworkConfigManager configService;
+
+    private class SegmentRouterInfo {
+        int nodeSid;
+        DeviceId deviceId;
+        Ip4Address ip;
+        MacAddress mac;
+        boolean isEdge;
+        HashMap<PortNumber, Ip4Address> gatewayIps;
+        HashMap<PortNumber, Ip4Prefix> subnets;
+    }
+
+    /**
+     * Constructor. Reads all the configuration for all devices of type
+     * Segment Router and organizes into various maps for easier access.
+     *
+     * @param configService handle to network configuration manager
+     * component from where the relevant configuration is retrieved.
+     */
+    public DeviceConfiguration(NetworkConfigManager configService) {
+        this.configService = checkNotNull(configService);
+        List<SwitchConfig> allSwitchCfg =
+                this.configService.getConfiguredAllowedSwitches();
+        for (SwitchConfig cfg : allSwitchCfg) {
+            if (!(cfg instanceof SegmentRouterConfig)) {
+                continue;
+            }
+            SegmentRouterInfo info = new SegmentRouterInfo();
+            info.nodeSid = ((SegmentRouterConfig) cfg).getNodeSid();
+            info.deviceId = ((SegmentRouterConfig) cfg).getDpid();
+            info.mac = MacAddress.valueOf(((
+                    SegmentRouterConfig) cfg).getRouterMac());
+            String routerIp = ((SegmentRouterConfig) cfg).getRouterIp();
+            Ip4Prefix prefix = checkNotNull(IpPrefix.valueOf(routerIp).getIp4Prefix());
+            info.ip = prefix.address();
+            info.isEdge = ((SegmentRouterConfig) cfg).isEdgeRouter();
+            info.subnets = new HashMap<>();
+            info.gatewayIps = new HashMap<PortNumber, Ip4Address>();
+            for (Subnet s: ((SegmentRouterConfig) cfg).getSubnets()) {
+                info.subnets.put(PortNumber.portNumber(s.getPortNo()),
+                                 Ip4Prefix.valueOf(s.getSubnetIp()));
+                String gatewayIp = s.getSubnetIp().
+                        substring(0, s.getSubnetIp().indexOf('/'));
+                info.gatewayIps.put(PortNumber.portNumber(s.getPortNo()),
+                                    Ip4Address.valueOf(gatewayIp));
+            }
+            this.deviceConfigMap.put(info.deviceId, info);
+            this.allSegmentIds.add(info.nodeSid);
+        }
+    }
 
 
+    /**
+     * Returns the segment id of a segment router.
+     *
+     * @param deviceId device identifier
+     * @return segment id
+     */
     @Override
     @Override
     public int getSegmentId(DeviceId deviceId) {
     public int getSegmentId(DeviceId deviceId) {
-        if (deviceSegmentIdMap.get(deviceId) != null) {
+        if (deviceConfigMap.get(deviceId) != null) {
             log.debug("getSegmentId for device{} is {}",
             log.debug("getSegmentId for device{} is {}",
                     deviceId,
                     deviceId,
-                    deviceSegmentIdMap.get(deviceId));
-            return deviceSegmentIdMap.get(deviceId);
+                    deviceConfigMap.get(deviceId).nodeSid);
+            return deviceConfigMap.get(deviceId).nodeSid;
         } else {
         } else {
             throw new IllegalStateException();
             throw new IllegalStateException();
         }
         }
     }
     }
 
 
+    /**
+     * Returns the segment id of a segment router given its mac address.
+     *
+     * @param routerMac router mac address
+     * @return segment id
+     */
+    public int getSegmentId(MacAddress routerMac) {
+        for (Map.Entry<DeviceId, SegmentRouterInfo> entry:
+                    deviceConfigMap.entrySet()) {
+            if (entry.getValue().mac.equals(routerMac)) {
+                return entry.getValue().nodeSid;
+            }
+        }
+
+        return -1;
+    }
+
+    /**
+     * Returns the segment id of a segment router given its router ip address.
+     *
+     * @param routerAddress router ip address
+     * @return segment id
+     */
+    public int getSegmentId(Ip4Address routerAddress) {
+        for (Map.Entry<DeviceId, SegmentRouterInfo> entry:
+            deviceConfigMap.entrySet()) {
+            if (entry.getValue().ip.equals(routerAddress)) {
+                return entry.getValue().nodeSid;
+            }
+        }
+
+        return -1;
+    }
 
 
+    /**
+     * Returns the router mac of a segment router.
+     *
+     * @param deviceId device identifier
+     * @return router mac address
+     */
     @Override
     @Override
     public MacAddress getDeviceMac(DeviceId deviceId) {
     public MacAddress getDeviceMac(DeviceId deviceId) {
-        if (deviceMacMap.get(deviceId) != null) {
+        if (deviceConfigMap.get(deviceId) != null) {
             log.debug("getDeviceMac for device{} is {}",
             log.debug("getDeviceMac for device{} is {}",
                     deviceId,
                     deviceId,
-                    deviceMacMap.get(deviceId));
-            return deviceMacMap.get(deviceId);
+                    deviceConfigMap.get(deviceId).mac);
+            return deviceConfigMap.get(deviceId).mac;
         } else {
         } else {
             throw new IllegalStateException();
             throw new IllegalStateException();
         }
         }
     }
     }
 
 
+    /**
+     * Returns the router ip address of a segment router.
+     *
+     * @param deviceId device identifier
+     * @return router ip address
+     */
+    public Ip4Address getRouterIp(DeviceId deviceId) {
+        if (deviceConfigMap.get(deviceId) != null) {
+            log.debug("getDeviceIp for device{} is {}",
+                    deviceId,
+                    deviceConfigMap.get(deviceId).ip);
+            return deviceConfigMap.get(deviceId).ip;
+        } else {
+            throw new IllegalStateException();
+        }
+    }
 
 
+    /**
+     * Indicates if the segment router is a edge router or
+     * a transit/back bone router.
+     *
+     * @param deviceId device identifier
+     * @return boolean
+     */
     @Override
     @Override
     public boolean isEdgeDevice(DeviceId deviceId) {
     public boolean isEdgeDevice(DeviceId deviceId) {
-        if (deviceId.equals(DeviceId.deviceId("of:0000000000000001"))
-                || deviceId.equals(DeviceId.deviceId("of:0000000000000006"))) {
-            return true;
+        if (deviceConfigMap.get(deviceId) != null) {
+            log.debug("isEdgeDevice for device{} is {}",
+                    deviceId,
+                    deviceConfigMap.get(deviceId).isEdge);
+            return deviceConfigMap.get(deviceId).isEdge;
+        } else {
+            throw new IllegalStateException();
         }
         }
-
-        return false;
     }
     }
 
 
+    /**
+     * Returns the segment ids of all configured segment routers.
+     *
+     * @return list of segment ids
+     */
     @Override
     @Override
     public List<Integer> getAllDeviceSegmentIds() {
     public List<Integer> getAllDeviceSegmentIds() {
         return allSegmentIds;
         return allSegmentIds;
     }
     }
 
 
-
     /**
     /**
-     * Returns Segment ID for the router with the MAC address given.
+     * Returns the device identifier or data plane identifier (dpid)
+     * of a segment router given its segment id.
      *
      *
-     * @param targetMac Mac address for the router
-     * @return Segment ID for the router with the MAC address
+     * @param sid segment id
+     * @return deviceId device identifier
      */
      */
-    public int getSegmentId(MacAddress targetMac) {
-        for (Map.Entry<DeviceId, MacAddress> entry: deviceMacMap.entrySet()) {
-            if (entry.getValue().equals(targetMac)) {
-                return deviceSegmentIdMap.get(entry.getKey());
+    public DeviceId getDeviceId(int sid) {
+        for (Map.Entry<DeviceId, SegmentRouterInfo> entry:
+            deviceConfigMap.entrySet()) {
+            if (entry.getValue().nodeSid == sid) {
+                return entry.getValue().deviceId;
             }
             }
         }
         }
 
 
-        return -1;
+        return null;
     }
     }
 
 
     /**
     /**
-     * Returns Segment ID for the router withe IP address given.
+     * Returns the device identifier or data plane identifier (dpid)
+     * of a segment router given its router ip address.
      *
      *
-     * @param targetAddress IP address of the router
-     * @return Segment ID for the router with the IP address
+     * @param ipAddress router ip address
+     * @return deviceId device identifier
      */
      */
-    public int getSegmentId(Ip4Address targetAddress) {
-        for (Map.Entry<DeviceId, Ip4Address> entry: deviceIpMap.entrySet()) {
-            if (entry.getValue().equals(targetAddress)) {
-                return deviceSegmentIdMap.get(entry.getKey());
+    public DeviceId getDeviceId(Ip4Address ipAddress) {
+        for (Map.Entry<DeviceId, SegmentRouterInfo> entry:
+            deviceConfigMap.entrySet()) {
+            if (entry.getValue().ip.equals(ipAddress)) {
+                return entry.getValue().deviceId;
             }
             }
         }
         }
 
 
-        return -1;
+        return null;
     }
     }
 
 
     /**
     /**
-     * Returns Router IP address for the router with the device ID given.
+     * Returns the configured subnet gateway ip addresses for a segment router.
      *
      *
-     * @param deviceId device ID of the router
-     * @return IP address of the router
+     * @param deviceId device identifier
+     * @return list of ip addresses
      */
      */
-    public Ip4Address getRouterIp(DeviceId deviceId) {
-        if (deviceIpMap.get(deviceId) != null) {
-            log.debug("getDeviceIp for device{} is {}",
+    public List<Ip4Address> getSubnetGatewayIps(DeviceId deviceId) {
+        if (deviceConfigMap.get(deviceId) != null) {
+            log.debug("getSubnetGatewayIps for device{} is {}",
                     deviceId,
                     deviceId,
-                    deviceIpMap.get(deviceId));
-            return deviceIpMap.get(deviceId);
+                    deviceConfigMap.get(deviceId).gatewayIps.values());
+            return new ArrayList<Ip4Address>(deviceConfigMap.
+                    get(deviceId).gatewayIps.values());
         } else {
         } else {
-            throw new IllegalStateException();
+            return null;
         }
         }
     }
     }
 
 
     /**
     /**
-     * Returns the Device ID of the router with the Segment ID given.
+     * Returns the configured subnet prefixes for a segment router.
      *
      *
-     * @param sid Segment ID of the router
-     * @return Device ID of the router
+     * @param deviceId device identifier
+     * @return list of ip prefixes
      */
      */
-    public DeviceId getDeviceId(int sid) {
-        for (Map.Entry<DeviceId, Integer> entry: deviceSegmentIdMap.entrySet()) {
-            if (entry.getValue() == sid) {
-                return entry.getKey();
+    public List<Ip4Prefix> getSubnets(DeviceId deviceId) {
+        if (deviceConfigMap.get(deviceId) != null) {
+            log.debug("getSubnets for device{} is {}",
+                    deviceId,
+                    deviceConfigMap.get(deviceId).subnets.values());
+            return new ArrayList<Ip4Prefix>(deviceConfigMap.
+                    get(deviceId).subnets.values());
+        } else {
+            return null;
         }
         }
     }
     }
 
 
+    /**
+     * Returns the router ip address of segment router that has the
+     * specified ip address in its subnets.
+     *
+     * @param destIpAddress target ip address
+     * @return router ip address
+     */
+    public Ip4Address getRouterIpAddressForASubnetHost(Ip4Address destIpAddress) {
+        for (Map.Entry<DeviceId, SegmentRouterInfo> entry:
+                    deviceConfigMap.entrySet()) {
+            for (Ip4Prefix prefix:entry.getValue().subnets.values()) {
+                if (prefix.contains(destIpAddress)) {
+                    return entry.getValue().ip;
+                }
+            }
+        }
+
+        log.debug("No router was found for {}", destIpAddress);
         return null;
         return null;
     }
     }
 
 
     /**
     /**
-     * Returns the Device ID of the router with the IP address given.
+     * Returns the router mac address of segment router that has the
+     * specified ip address as one of its subnet gateway ip address.
      *
      *
-     * @param ipAddress IP address of the router
-     * @return Device ID of the router
+     * @param gatewayIpAddress router gateway ip address
+     * @return router mac address
      */
      */
-    public DeviceId getDeviceId(Ip4Address ipAddress) {
-        for (Map.Entry<DeviceId, Ip4Address> entry: deviceIpMap.entrySet()) {
-            if (entry.getValue().equals(ipAddress)) {
-                return entry.getKey();
+    public MacAddress getRouterMacForAGatewayIp(Ip4Address gatewayIpAddress) {
+        for (Map.Entry<DeviceId, SegmentRouterInfo> entry:
+                deviceConfigMap.entrySet()) {
+            if (entry.getValue().gatewayIps.
+                    values().contains(gatewayIpAddress)) {
+                return entry.getValue().mac;
             }
             }
         }
         }
 
 
+        log.debug("Cannot find a router for {}", gatewayIpAddress);
         return null;
         return null;
     }
     }
 }
 }

@@ -16,7 +16,7 @@
 package org.onosproject.segmentrouting;
 package org.onosproject.segmentrouting;
 
 
 import java.nio.ByteBuffer;
 import java.nio.ByteBuffer;
-
+import java.util.List;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.ICMP;
 import org.onlab.packet.ICMP;
 import org.onlab.packet.IPv4;
 import org.onlab.packet.IPv4;
@@ -69,14 +69,14 @@ public class IcmpHandler {
         DeviceId deviceId = connectPoint.deviceId();
         DeviceId deviceId = connectPoint.deviceId();
         Ip4Address destinationAddress =
         Ip4Address destinationAddress =
                 Ip4Address.valueOf(ipv4.getDestinationAddress());
                 Ip4Address.valueOf(ipv4.getDestinationAddress());
-        Ip4Address gatewayIpAddress = config.getGatewayIpAddress(deviceId);
+        List<Ip4Address> gatewayIpAddresses = config.getGatewayIpAddress(deviceId);
         IpPrefix routerIpPrefix = config.getRouterIpAddress(deviceId);
         IpPrefix routerIpPrefix = config.getRouterIpAddress(deviceId);
         Ip4Address routerIpAddress = routerIpPrefix.getIp4Prefix().address();
         Ip4Address routerIpAddress = routerIpPrefix.getIp4Prefix().address();
 
 
         // ICMP to the router IP or gateway IP
         // ICMP to the router IP or gateway IP
         if (((ICMP) ipv4.getPayload()).getIcmpType() == ICMP.TYPE_ECHO_REQUEST &&
         if (((ICMP) ipv4.getPayload()).getIcmpType() == ICMP.TYPE_ECHO_REQUEST &&
                 (destinationAddress.equals(routerIpAddress) ||
                 (destinationAddress.equals(routerIpAddress) ||
-                        gatewayIpAddress.equals(destinationAddress))) {
+                        gatewayIpAddresses.contains(destinationAddress))) {
             sendICMPResponse(ethernet, connectPoint);
             sendICMPResponse(ethernet, connectPoint);
             // TODO: do we need to set the flow rule again ??
             // TODO: do we need to set the flow rule again ??
 
 

@@ -16,6 +16,7 @@
 package org.onosproject.segmentrouting;
 package org.onosproject.segmentrouting;
 
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Lists;
+
 import org.onlab.packet.Ip4Address;
 import org.onlab.packet.Ip4Address;
 import org.onlab.packet.Ip4Prefix;
 import org.onlab.packet.Ip4Prefix;
 import org.onlab.packet.IpPrefix;
 import org.onlab.packet.IpPrefix;
@@ -26,39 +27,33 @@ import org.onosproject.net.PortNumber;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
-import java.net.URI;
 import java.util.List;
 import java.util.List;
 import java.util.Set;
 import java.util.Set;
 
 
 /**
 /**
  * This class is temporary class and used only for test.
  * This class is temporary class and used only for test.
  * It will be replaced with "real" Network Config Manager.
  * It will be replaced with "real" Network Config Manager.
+ *
+ * TODO: Knock off this wrapper and directly use DeviceConfiguration class
  */
  */
 
 
 public class NetworkConfigHandler {
 public class NetworkConfigHandler {
 
 
     private static Logger log = LoggerFactory.getLogger(NetworkConfigHandler.class);
     private static Logger log = LoggerFactory.getLogger(NetworkConfigHandler.class);
     private SegmentRoutingManager srManager;
     private SegmentRoutingManager srManager;
-    private DeviceConfiguration deviceConfig = new DeviceConfiguration();
+    private DeviceConfiguration deviceConfig;
 
 
-    public NetworkConfigHandler(SegmentRoutingManager srManager) {
+    public NetworkConfigHandler(SegmentRoutingManager srManager,
+                                DeviceConfiguration deviceConfig) {
         this.srManager = srManager;
         this.srManager = srManager;
+        this.deviceConfig = deviceConfig;
     }
     }
 
 
-    public Ip4Address getGatewayIpAddress(DeviceId deviceId) {
-
-        if (deviceId.uri().equals(URI.create("of:0000000000000001"))) {
-            return Ip4Address.valueOf("10.0.1.128");
-        } else if (deviceId.uri().equals(URI.create("of:0000000000000006"))) {
-            return Ip4Address.valueOf("7.7.7.128");
-        }
-
-        log.warn("No gateway Ip address was found for {}", deviceId);
-        return Ip4Address.valueOf("0.0.0.0");
+    public List<Ip4Address> getGatewayIpAddress(DeviceId deviceId) {
+        return this.deviceConfig.getSubnetGatewayIps(deviceId);
     }
     }
 
 
     public IpPrefix getRouterIpAddress(DeviceId deviceId) {
     public IpPrefix getRouterIpAddress(DeviceId deviceId) {
-
         return IpPrefix.valueOf(deviceConfig.getRouterIp(deviceId), 32);
         return IpPrefix.valueOf(deviceConfig.getRouterIp(deviceId), 32);
     }
     }
 
 
@@ -68,17 +63,13 @@ public class NetworkConfigHandler {
 
 
     public boolean inSameSubnet(DeviceId deviceId, Ip4Address destIp) {
     public boolean inSameSubnet(DeviceId deviceId, Ip4Address destIp) {
 
 
-        String subnetInfo = getSubnetInfo(deviceId);
-        if (subnetInfo == null) {
+        List<Ip4Prefix> subnets = getSubnetInfo(deviceId);
+        if (subnets == null) {
             return false;
             return false;
         }
         }
 
 
-        IpPrefix prefix = IpPrefix.valueOf(subnetInfo);
-        if (prefix.contains(destIp)) {
-            return true;
-        }
-
-        return false;
+        return subnets.stream()
+               .anyMatch((subnet) -> subnet.contains(destIp));
     }
     }
 
 
     public boolean inSameSubnet(Ip4Address address, int sid) {
     public boolean inSameSubnet(Ip4Address address, int sid) {
@@ -88,43 +79,23 @@ public class NetworkConfigHandler {
             return false;
             return false;
         }
         }
 
 
-        String subnetInfo = getSubnetInfo(deviceId);
-        if (subnetInfo == null) {
-            log.warn("Cannot find the subnet info for {}", deviceId);
-            return false;
+        return inSameSubnet(deviceId, address);
     }
     }
 
 
-        Ip4Prefix subnet = Ip4Prefix.valueOf(subnetInfo);
-        if (subnet.contains(address)) {
-            return true;
-        }
-
-        return false;
-
-    }
-
-    public String getSubnetInfo(DeviceId deviceId) {
-        // TODO : supports multiple subnet
-        if (deviceId.uri().equals(URI.create("of:0000000000000001"))) {
-            return "10.0.1.1/24";
-        } else if (deviceId.uri().equals(URI.create("of:0000000000000006"))) {
-            return "7.7.7.7/24";
-        } else {
-            log.error("Switch {} is not an edge router", deviceId);
-            return null;
-        }
+    public List<Ip4Prefix> getSubnetInfo(DeviceId deviceId) {
+        return deviceConfig.getSubnets(deviceId);
     }
     }
 
 
     public int getMplsId(DeviceId deviceId) {
     public int getMplsId(DeviceId deviceId) {
         return deviceConfig.getSegmentId(deviceId);
         return deviceConfig.getSegmentId(deviceId);
     }
     }
 
 
-    public int getMplsId(MacAddress mac) {
-        return deviceConfig.getSegmentId(mac);
+    public int getMplsId(MacAddress routerMac) {
+        return deviceConfig.getSegmentId(routerMac);
     }
     }
 
 
-    public int getMplsId(Ip4Address address) {
-        return deviceConfig.getSegmentId(address);
+    public int getMplsId(Ip4Address routerIpAddress) {
+        return deviceConfig.getSegmentId(routerIpAddress);
     }
     }
 
 
     public boolean isEcmpNotSupportedInTransit(DeviceId deviceId) {
     public boolean isEcmpNotSupportedInTransit(DeviceId deviceId) {
@@ -132,17 +103,12 @@ public class NetworkConfigHandler {
     }
     }
 
 
     public boolean isTransitRouter(DeviceId deviceId) {
     public boolean isTransitRouter(DeviceId deviceId) {
-        return true;
+        return !(deviceConfig.isEdgeDevice(deviceId));
     }
     }
 
 
 
 
     public boolean isEdgeRouter(DeviceId deviceId) {
     public boolean isEdgeRouter(DeviceId deviceId) {
-        if (deviceId.uri().equals(URI.create("of:0000000000000001"))
-                || deviceId.uri().equals(URI.create("of:0000000000000006"))) {
-            return true;
-        }
-
-        return false;
+        return deviceConfig.isEdgeDevice(deviceId);
     }
     }
 
 
     private List<PortNumber> getPortsToNeighbors(DeviceId deviceId, List<DeviceId> fwdSws) {
     private List<PortNumber> getPortsToNeighbors(DeviceId deviceId, List<DeviceId> fwdSws) {
@@ -177,16 +143,7 @@ public class NetworkConfigHandler {
 
 
 
 
     public Ip4Address getDestinationRouterAddress(Ip4Address destIpAddress) {
     public Ip4Address getDestinationRouterAddress(Ip4Address destIpAddress) {
-        // TODO: need to check the subnet info
-        if (destIpAddress.toString().equals("10.0.1.1")) {
-            return Ip4Address.valueOf("192.168.0.1");
-        } else if (destIpAddress.toString().equals("7.7.7.7")) {
-            return Ip4Address.valueOf("192.168.0.6");
-        } else {
-            log.warn("No router was found for {}", destIpAddress);
-            return null;
-        }
-
+        return deviceConfig.getRouterIpAddressForASubnetHost(destIpAddress);
     }
     }
 
 
     public DeviceId getDeviceId(Ip4Address ip4Address) {
     public DeviceId getDeviceId(Ip4Address ip4Address) {
@@ -194,13 +151,6 @@ public class NetworkConfigHandler {
     }
     }
 
 
     public MacAddress getRouterMac(Ip4Address targetAddress) {
     public MacAddress getRouterMac(Ip4Address targetAddress) {
-        if (targetAddress.toString().equals("10.0.1.128")) {
-            return MacAddress.valueOf("00:00:00:00:00:01");
-        } else if (targetAddress.toString().equals("7.7.7.128")) {
-            return MacAddress.valueOf("00:00:00:00:00:06");
-        } else {
-            log.warn("Cannot find a router for {}", targetAddress);
-            return null;
-        }
+        return deviceConfig.getRouterMacForAGatewayIp(targetAddress);
     }
     }
 }
 }

@@ -17,11 +17,11 @@ package org.onosproject.segmentrouting;
 
 
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.Ip4Address;
 import org.onlab.packet.Ip4Address;
+import org.onlab.packet.Ip4Prefix;
 import org.onlab.packet.IpPrefix;
 import org.onlab.packet.IpPrefix;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.MacAddress;
-
 import org.onlab.packet.MplsLabel;
 import org.onlab.packet.MplsLabel;
-import org.onosproject.grouphandler.NeighborSet;
+import org.onosproject.segmentrouting.grouphandler.NeighborSet;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.Link;
 import org.onosproject.net.Link;
 import org.onosproject.net.PortNumber;
 import org.onosproject.net.PortNumber;
@@ -94,15 +94,15 @@ public class RoutingRulePopulator {
      * Populates IP flow rules for the subnets of the destination router.
      * Populates IP flow rules for the subnets of the destination router.
      *
      *
      * @param deviceId switch ID to set the rules
      * @param deviceId switch ID to set the rules
-     * @param subnetInfo subnet information
+     * @param subnets subnet information
      * @param destSw destination switch ID
      * @param destSw destination switch ID
      * @param nextHops next hop switch ID list
      * @param nextHops next hop switch ID list
      * @return true if all rules are set successfully, false otherwise
      * @return true if all rules are set successfully, false otherwise
      */
      */
-    public boolean populateIpRuleForSubnet(DeviceId deviceId, String subnetInfo,
+    public boolean populateIpRuleForSubnet(DeviceId deviceId, List<Ip4Prefix> subnets,
                                            DeviceId destSw, Set<DeviceId> nextHops) {
                                            DeviceId destSw, Set<DeviceId> nextHops) {
 
 
-        List<IpPrefix> subnets = extractSubnet(subnetInfo);
+        //List<IpPrefix> subnets = extractSubnet(subnetInfo);
         for (IpPrefix subnet: subnets) {
         for (IpPrefix subnet: subnets) {
             if (!populateIpRuleForRouter(deviceId, subnet, destSw, nextHops)) {
             if (!populateIpRuleForRouter(deviceId, subnet, destSw, nextHops)) {
                 return false;
                 return false;
@@ -371,21 +371,6 @@ public class RoutingRulePopulator {
 
 
     }
     }
 
 
-
-    private List<IpPrefix> extractSubnet(String subnetInfo) {
-        List<IpPrefix> subnetIpPrefixes = new ArrayList<>();
-
-        // TODO: refactoring required depending on the format of the subnet info
-        IpPrefix prefix = IpPrefix.valueOf(subnetInfo);
-        if (prefix == null) {
-            log.error("Wrong ip prefix type {}", subnetInfo);
-        } else {
-            subnetIpPrefixes.add(prefix);
-        }
-
-        return subnetIpPrefixes;
-    }
-
     private Link selectOneLink(DeviceId srcId, Set<DeviceId> destIds) {
     private Link selectOneLink(DeviceId srcId, Set<DeviceId> destIds) {
 
 
         Set<Link> links = srManager.linkService.getDeviceEgressLinks(srcId);
         Set<Link> links = srManager.linkService.getDeviceEgressLinks(srcId);

@@ -25,8 +25,8 @@ import org.onlab.packet.IPv4;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.CoreService;
 import org.onosproject.core.CoreService;
 import org.onosproject.event.Event;
 import org.onosproject.event.Event;
-import org.onosproject.grouphandler.DefaultGroupHandler;
-import org.onosproject.grouphandler.NeighborSet;
+import org.onosproject.segmentrouting.grouphandler.DefaultGroupHandler;
+import org.onosproject.segmentrouting.grouphandler.NeighborSet;
 import org.onosproject.mastership.MastershipService;
 import org.onosproject.mastership.MastershipService;
 import org.onosproject.net.Device;
 import org.onosproject.net.Device;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.DeviceId;
@@ -52,6 +52,7 @@ import org.onosproject.net.packet.PacketContext;
 import org.onosproject.net.packet.PacketProcessor;
 import org.onosproject.net.packet.PacketProcessor;
 import org.onosproject.net.packet.PacketService;
 import org.onosproject.net.packet.PacketService;
 import org.onosproject.net.topology.TopologyService;
 import org.onosproject.net.topology.TopologyService;
+import org.onosproject.segmentrouting.config.NetworkConfigManager;
 import org.slf4j.Logger;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.slf4j.LoggerFactory;
 
 
@@ -98,16 +99,15 @@ public class SegmentRoutingManager {
 
 
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected MastershipService mastershipService;
     protected MastershipService mastershipService;
-
-    protected NetworkConfigHandler networkConfigHandler = new NetworkConfigHandler(this);
-    protected ArpHandler arpHandler = new ArpHandler(this);
-    protected IcmpHandler icmpHandler = new IcmpHandler(this);
-    protected IpHandler ipHandler = new IpHandler(this);
-    protected RoutingRulePopulator routingRulePopulator = new RoutingRulePopulator(this);
+    protected NetworkConfigHandler networkConfigHandler = null;
+    protected ArpHandler arpHandler = null;
+    protected IcmpHandler icmpHandler = null;
+    protected IpHandler ipHandler = null;
+    protected RoutingRulePopulator routingRulePopulator = null;
     protected ApplicationId appId;
     protected ApplicationId appId;
 
 
-    private DefaultRoutingHandler defaultRoutingHandler = new DefaultRoutingHandler(this);
-    private DeviceConfiguration deviceConfiguration = new DeviceConfiguration();
+    private DefaultRoutingHandler defaultRoutingHandler = null;
+    private DeviceConfiguration deviceConfiguration = null;
     private InternalPacketProcessor processor = new InternalPacketProcessor();
     private InternalPacketProcessor processor = new InternalPacketProcessor();
     private InternalEventHandler eventHandler = new InternalEventHandler();
     private InternalEventHandler eventHandler = new InternalEventHandler();
 
 
@@ -118,6 +118,8 @@ public class SegmentRoutingManager {
     private Map<DeviceId, DefaultGroupHandler> groupHandlerMap
     private Map<DeviceId, DefaultGroupHandler> groupHandlerMap
             = new ConcurrentHashMap<DeviceId, DefaultGroupHandler>();
             = new ConcurrentHashMap<DeviceId, DefaultGroupHandler>();
 
 
+    private NetworkConfigManager networkConfigService = new NetworkConfigManager();;
+
     private static int numOfEvents = 0;
     private static int numOfEvents = 0;
     private static int numOfHandlerExecution = 0;
     private static int numOfHandlerExecution = 0;
     private static int numOfHandlerScheduled = 0;
     private static int numOfHandlerScheduled = 0;
@@ -125,6 +127,16 @@ public class SegmentRoutingManager {
     @Activate
     @Activate
     protected void activate() {
     protected void activate() {
         appId = coreService.registerApplication("org.onosproject.segmentrouting");
         appId = coreService.registerApplication("org.onosproject.segmentrouting");
+        networkConfigService.init();
+        deviceConfiguration = new DeviceConfiguration(networkConfigService);
+        networkConfigHandler = new NetworkConfigHandler(this,
+                                                        deviceConfiguration);
+        arpHandler = new ArpHandler(this);
+        icmpHandler = new IcmpHandler(this);
+        ipHandler = new IpHandler(this);
+        routingRulePopulator = new RoutingRulePopulator(this);
+        defaultRoutingHandler = new DefaultRoutingHandler(this);
+
         packetService.addProcessor(processor, PacketProcessor.ADVISOR_MAX + 2);
         packetService.addProcessor(processor, PacketProcessor.ADVISOR_MAX + 2);
         linkService.addListener(new InternalLinkListener());
         linkService.addListener(new InternalLinkListener());
         groupService.addListener(new InternalGroupListener());
         groupService.addListener(new InternalGroupListener());
@@ -271,6 +283,7 @@ public class SegmentRoutingManager {
 
 
     private class InternalEventHandler implements Runnable {
     private class InternalEventHandler implements Runnable {
 
 
+        @Override
         public void run() {
         public void run() {
             numOfHandlerExecution++;
             numOfHandlerExecution++;
             while (!eventQueue.isEmpty()) {
             while (!eventQueue.isEmpty()) {
@@ -326,7 +339,11 @@ public class SegmentRoutingManager {
         log.debug("A new device with ID {} was added", device.id());
         log.debug("A new device with ID {} was added", device.id());
         defaultRoutingHandler.populateTtpRules(device.id());
         defaultRoutingHandler.populateTtpRules(device.id());
         DefaultGroupHandler dgh = DefaultGroupHandler.createGroupHandler(
         DefaultGroupHandler dgh = DefaultGroupHandler.createGroupHandler(
-                device.id(), appId, new DeviceConfiguration(), linkService, groupService);
+                device.id(),
+                appId,
+                deviceConfiguration,
+                linkService,
+                groupService);
         dgh.createGroups();
         dgh.createGroups();
         groupHandlerMap.put(device.id(), dgh);
         groupHandlerMap.put(device.id(), dgh);
     }
     }

+package org.onosproject.segmentrouting.config;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.onosproject.net.DeviceId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.JsonNode;
+
+/**
+ * Public class corresponding to JSON described data model. Defines the network
+ * configuration at startup.
+ */
+public class NetworkConfig {
+    protected static final Logger log = LoggerFactory.getLogger(NetworkConfig.class);
+
+    @SuppressWarnings("unused")
+    private String comment;
+
+    private Boolean restrictSwitches;
+    private Boolean restrictLinks;
+    private List<SwitchConfig> switches;
+    private List<LinkConfig> links;
+
+    /**
+     * Default constructor.
+     */
+    public NetworkConfig() {
+        switches = new ArrayList<SwitchConfig>();
+        links = new ArrayList<LinkConfig>();
+    }
+
+    @JsonProperty("comment")
+    public void setComment(String c) {
+        log.trace("NetworkConfig: comment={}", c);
+        comment = c;
+    }
+
+    @JsonProperty("restrictSwitches")
+    public void setRestrictSwitches(boolean rs) {
+        log.trace("NetworkConfig: restrictSwitches={}", rs);
+        restrictSwitches = rs;
+    }
+
+    /**
+     * Returns default restrict configuration for switches.
+     *
+     * @return boolean
+     */
+    public Boolean getRestrictSwitches() {
+        return restrictSwitches;
+    }
+
+    @JsonProperty("restrictLinks")
+    public void setRestrictLinks(boolean rl) {
+        log.trace("NetworkConfig: restrictLinks={}", rl);
+        restrictLinks = rl;
+    }
+
+    /**
+     * Returns default restrict configuration for links.
+     *
+     * @return boolean
+     */
+    public Boolean getRestrictLinks() {
+        return restrictLinks;
+    }
+
+    /**
+     * Returns configuration for switches.
+     *
+     * @return list of switch configuration
+     */
+    public List<SwitchConfig> getSwitchConfig() {
+        return switches;
+    }
+
+    @JsonProperty("switchConfig")
+    public void setSwitchConfig(List<SwitchConfig> switches2) {
+        log.trace("NetworkConfig: switchConfig={}", switches2);
+        this.switches = switches2;
+    }
+
+    /**
+     * Java class corresponding to JSON described switch
+     * configuration data model.
+     */
+    public static class SwitchConfig {
+        protected String nodeDpid;
+        protected String name;
+        protected String type;
+        protected boolean allowed;
+        protected double latitude;
+        protected double longitude;
+        protected Map<String, JsonNode> params;
+        protected Map<String, String> publishAttributes;
+        protected DeviceId dpid;
+
+        /**
+         * Returns the configured "name" of a switch.
+         *
+         * @return string
+         */
+        public String getName() {
+            return name;
+        }
+
+        @JsonProperty("name")
+        public void setName(String name) {
+            log.trace("SwitchConfig: name={}", name);
+            this.name = name;
+        }
+
+        /**
+         * Returns the data plane identifier of a switch.
+         *
+         * @return ONOS device identifier
+         */
+        public DeviceId getDpid() {
+            return dpid;
+        }
+
+        public void setDpid(DeviceId dpid) {
+            this.dpid = dpid;
+            this.nodeDpid = dpid.toString();
+        }
+
+        /**
+         * Returns the data plane identifier of a switch.
+         *
+         * @return string
+         */
+        public String getNodeDpid() {
+            return nodeDpid;
+        }
+
+        // mapper sets both DeviceId and string fields for dpid
+        @JsonProperty("nodeDpid")
+        public void setNodeDpid(String nodeDpid) {
+            log.trace("SwitchConfig: nodeDpid={}", nodeDpid);
+            this.nodeDpid = nodeDpid;
+            this.dpid = DeviceId.deviceId(nodeDpid);
+        }
+
+        /**
+         * Returns the type of a switch.
+         *
+         * @return string
+         */
+        public String getType() {
+            return type;
+        }
+
+        @JsonProperty("type")
+        public void setType(String type) {
+            log.trace("SwitchConfig: type={}", type);
+            this.type = type;
+        }
+
+        /**
+         * Returns the latitude of a switch.
+         *
+         * @return double
+         */
+        public double getLatitude() {
+            return latitude;
+        }
+
+        @JsonProperty("latitude")
+        public void setLatitude(double latitude) {
+            log.trace("SwitchConfig: latitude={}", latitude);
+            this.latitude = latitude;
+        }
+
+        /**
+         * Returns the longitude of a switch.
+         *
+         * @return double
+         */
+        public double getLongitude() {
+            return longitude;
+        }
+
+        @JsonProperty("longitude")
+        public void setLongitude(double longitude) {
+            log.trace("SwitchConfig: longitude={}", longitude);
+            this.longitude = longitude;
+        }
+
+        /**
+         * Returns the allowed flag for a switch.
+         *
+         * @return boolean
+         */
+        public boolean isAllowed() {
+            return allowed;
+        }
+
+        @JsonProperty("allowed")
+        public void setAllowed(boolean allowed) {
+            this.allowed = allowed;
+        }
+
+        /**
+         * Returns the additional configured parameters of a switch.
+         *
+         * @return key value map
+         */
+        public Map<String, JsonNode> getParams() {
+            return params;
+        }
+
+        @JsonProperty("params")
+        public void setParams(Map<String, JsonNode> params) {
+            this.params = params;
+        }
+
+        /**
+         * Reserved for future use.
+         *
+         * @return key value map
+         */
+        public Map<String, String> getPublishAttributes() {
+            return publishAttributes;
+        }
+
+        @JsonProperty("publishAttributes")
+        public void setPublishAttributes(Map<String, String> publishAttributes) {
+            this.publishAttributes = publishAttributes;
+        }
+
+    }
+
+    @JsonProperty("linkConfig")
+    public void setLinkConfig(List<LinkConfig> links2) {
+        this.links = links2;
+    }
+
+    /**
+     * Reserved for future use.
+     *
+     * @return list of configured link configuration
+     */
+    public List<LinkConfig> getLinkConfig() {
+        return links;
+    }
+
+    /**
+     * Reserved for future use.
+     */
+    public static class LinkConfig {
+        protected String type;
+        protected Boolean allowed;
+        protected DeviceId dpid1;
+        protected DeviceId dpid2;
+        protected String nodeDpid1;
+        protected String nodeDpid2;
+        protected Map<String, JsonNode> params;
+        protected Map<String, String> publishAttributes;
+
+        public String getType() {
+            return type;
+        }
+
+        public void setType(String type) {
+            this.type = type;
+        }
+
+        public Boolean isAllowed() {
+            return allowed;
+        }
+
+        public void setAllowed(Boolean allowed) {
+            this.allowed = allowed;
+        }
+
+        public String getNodeDpid1() {
+            return nodeDpid1;
+        }
+
+        // mapper sets both long and string fields for dpid
+        public void setNodeDpid1(String nodeDpid1) {
+            this.nodeDpid1 = nodeDpid1;
+            this.dpid1 = DeviceId.deviceId(nodeDpid1);
+        }
+
+        public String getNodeDpid2() {
+            return nodeDpid2;
+        }
+
+        // mapper sets both long and string fields for dpid
+        public void setNodeDpid2(String nodeDpid2) {
+            this.nodeDpid2 = nodeDpid2;
+            this.dpid2 = DeviceId.deviceId(nodeDpid2);
+        }
+
+        public DeviceId getDpid1() {
+            return dpid1;
+        }
+
+        public void setDpid1(DeviceId dpid1) {
+            this.dpid1 = dpid1;
+            this.nodeDpid1 = dpid1.toString();
+        }
+
+        public DeviceId getDpid2() {
+            return dpid2;
+        }
+
+        public void setDpid2(DeviceId dpid2) {
+            this.dpid2 = dpid2;
+            this.nodeDpid2 = dpid2.toString();
+        }
+
+        public Map<String, JsonNode> getParams() {
+            return params;
+        }
+
+        public void setParams(Map<String, JsonNode> params) {
+            this.params = params;
+        }
+
+        public Map<String, String> getPublishAttributes() {
+            return publishAttributes;
+        }
+
+        public void setPublishAttributes(Map<String, String> publishAttributes) {
+            this.publishAttributes = publishAttributes;
+        }
+    }
+}
+

+package org.onosproject.segmentrouting.config;
+
+import org.onosproject.net.DeviceId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * NetworkConfigExceptions specifies a set of unchecked runtime exceptions that
+ * can be thrown by the {@link NetworkConfigManager}. It indicates errors that
+ * must be fixed in the config file before controller execution can proceed.
+ */
+public class NetworkConfigException extends RuntimeException {
+
+    private static final long serialVersionUID = 4959684709803000652L;
+    protected static final Logger log = LoggerFactory
+            .getLogger(NetworkConfigException.class);
+
+    /**
+     * Exception for duplicate device identifier configuration.
+     */
+    public static class DuplicateDpid extends RuntimeException {
+        private static final long serialVersionUID = 5491113234592145335L;
+
+        public DuplicateDpid(DeviceId dpid) {
+            super();
+            log.error("Duplicate dpid found in switch-config Dpid:{}",
+                    dpid);
+        }
+    }
+
+    /**
+     * Exception for duplicate device name configuration.
+     */
+    public static class DuplicateName extends RuntimeException {
+        private static final long serialVersionUID = -4090171438031376129L;
+
+        public DuplicateName(String name) {
+            super();
+            log.error("Duplicate name found in switch-config name:{}", name);
+        }
+    }
+
+    /**
+     * Exception for unspecified device identifier for a switch.
+     */
+    public static class DpidNotSpecified extends RuntimeException {
+        private static final long serialVersionUID = -8494418855597117254L;
+
+        public DpidNotSpecified(String name) {
+            super();
+            log.error("Dpid not specified for switch-config name:{}", name);
+        }
+    }
+
+    /**
+     * Exception for unspecified device name for a switch.
+     */
+    public static class NameNotSpecified extends RuntimeException {
+        private static final long serialVersionUID = -3518881744110422891L;
+
+        public NameNotSpecified(DeviceId dpid) {
+            super();
+            log.error("Name not specified for switch-config dpid:{}",
+                    dpid);
+        }
+    }
+
+    /**
+     * Exception for unspecified device type for a switch.
+     */
+    public static class SwitchTypeNotSpecified extends RuntimeException {
+        private static final long serialVersionUID = 2527453336226053753L;
+
+        public SwitchTypeNotSpecified(DeviceId dpid) {
+            super();
+            log.error("Switch type not specified for switch-config dpid:{}",
+                    dpid);
+        }
+    }
+
+    /**
+     * Exception for unknown device type configured for a switch.
+     */
+    public static class UnknownSwitchType extends RuntimeException {
+        private static final long serialVersionUID = 7758418165512249170L;
+
+        public UnknownSwitchType(String type, String name) {
+            super();
+            log.error("Unknown switch type {} for switch name:{}", type, name);
+        }
+    }
+
+    /**
+     * Exception for missing required parameter configuration for a switch.
+     */
+    public static class ParamsNotSpecified extends RuntimeException {
+        private static final long serialVersionUID = 6247582323691265513L;
+
+        public ParamsNotSpecified(String name) {
+            super();
+            log.error("Params required - not specified for switch:{}", name);
+        }
+    }
+
+    /**
+     * Reserved for future use.
+     */
+    public static class LinkTypeNotSpecified extends RuntimeException {
+        private static final long serialVersionUID = -2089470389588542215L;
+
+        public LinkTypeNotSpecified(String dpid1, String dpid2) {
+            super();
+            log.error("Link type not specified for link-config between "
+                    + "dpid1:{} and dpid2:{}", dpid1, dpid2);
+        }
+    }
+
+    /**
+     * Reserved for future use.
+     */
+    public static class LinkDpidNotSpecified extends RuntimeException {
+        private static final long serialVersionUID = -5701825916378616004L;
+
+        public LinkDpidNotSpecified(String dpid1, String dpid2) {
+            super();
+            if (dpid1 == null) {
+                log.error("nodeDpid1 not specified for link-config ");
+            }
+            if (dpid2 == null) {
+                log.error("nodeDpid2 not specified for link-config ");
+            }
+        }
+    }
+
+    /**
+     * Reserved for future use.
+     */
+    public static class LinkForUnknownSwitchConfig extends RuntimeException {
+        private static final long serialVersionUID = -2910458439881964094L;
+
+        public LinkForUnknownSwitchConfig(String dpid) {
+            super();
+            log.error("Link configuration was specified for a switch-dpid {} "
+                    + "that has not been configured", dpid);
+        }
+    }
+
+    /**
+     * Reserved for future use.
+     */
+    public static class UnknownLinkType extends RuntimeException {
+        private static final long serialVersionUID = -5505376193106542305L;
+
+        public UnknownLinkType(String linktype, String dpid1, String dpid2) {
+            super();
+            log.error("unknown link type {} for links between dpid1:{} "
+                    + "and dpid2:{}", linktype, dpid1, dpid2);
+        }
+    }
+
+    /**
+     * Exception for generic configuration errors.
+     */
+    public static class ErrorConfig extends RuntimeException {
+        private static final long serialVersionUID = -2827406314700193147L;
+
+        public ErrorConfig(String errorMsg) {
+            super();
+            log.error(errorMsg);
+        }
+
+    }
+
+    /**
+     * Reserved for future use.
+     */
+    public static class SwitchDpidNotConverted extends RuntimeException {
+        private static final long serialVersionUID = 5640347104590170426L;
+
+        public SwitchDpidNotConverted(String name) {
+            super();
+            log.error("Switch dpid specified as a HexString {} does not match "
+                    + "with long value", name);
+        }
+    }
+
+    /**
+     * Reserved for future use.
+     */
+    public static class LinkDpidNotConverted extends RuntimeException {
+        private static final long serialVersionUID = 2397245646094080774L;
+
+        public LinkDpidNotConverted(String dpid1, String dpid2) {
+            log.error("Dpids expressed as HexStrings for links between dpid1:{} "
+                    + "and dpid2:{} do not match with long values", dpid1, dpid2);
+        }
+    }
+
+}
+

+package org.onosproject.segmentrouting.config;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Link;
+import org.onosproject.segmentrouting.config.NetworkConfig.LinkConfig;
+import org.onosproject.segmentrouting.config.NetworkConfig.SwitchConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * NetworkConfigManager manages all network configuration for switches, links
+ * and any other state that needs to be configured for correct network
+ * operation.
+ *
+ */
+public class NetworkConfigManager implements NetworkConfigService {
+    protected static final Logger log = LoggerFactory
+            .getLogger(NetworkConfigManager.class);
+    private static final String CONFIG_DIR = "../config";
+    private static final String DEFAULT_CONFIG_FILE = "segmentrouting.conf";
+    private final String configFileName = DEFAULT_CONFIG_FILE;
+    /**
+     * JSON Config file needs to use one of the following types for defining the
+     * kind of switch or link it wishes to configure.
+     */
+    public static final String SEGMENT_ROUTER = "Router_SR";
+
+    public static final String PKT_LINK = "pktLink";
+
+    NetworkConfig networkConfig;
+    private ConcurrentMap<DeviceId, SwitchConfig> configuredSwitches;
+    private ConcurrentMap<Link, LinkConfig> configuredLinks;
+    private Map<String, DeviceId> nameToDpid;
+
+    @Override
+    public SwitchConfigStatus checkSwitchConfig(DeviceId dpid) {
+        SwitchConfig swc = configuredSwitches.get(dpid);
+        if (networkConfig.getRestrictSwitches()) {
+            // default deny behavior
+            if (swc == null) {
+                // switch is not configured - we deny this switch
+                return new SwitchConfigStatus(NetworkConfigState.DENY, null,
+                        "Switch not configured, in network denying switches by default.");
+            }
+            if (swc.isAllowed()) {
+                // switch is allowed in config, return configured attributes
+                return new SwitchConfigStatus(NetworkConfigState.ACCEPT_ADD, swc);
+            } else {
+                // switch has been configured off (administratively down)
+                return new SwitchConfigStatus(NetworkConfigState.DENY, null,
+                        "Switch configured down (allowed=false).");
+            }
+        } else {
+            // default allow behavior
+            if (swc == null) {
+                // no config to add
+                return new SwitchConfigStatus(NetworkConfigState.ACCEPT, null);
+            }
+            if (swc.isAllowed()) {
+                // switch is allowed in config, return configured attributes
+                return new SwitchConfigStatus(NetworkConfigState.ACCEPT_ADD, swc);
+            } else {
+                // switch has been configured off (administratively down)
+                return new SwitchConfigStatus(NetworkConfigState.DENY, null,
+                        "Switch configured down (allowed=false).");
+            }
+        }
+
+    }
+
+    @Override
+    public LinkConfigStatus checkLinkConfig(Link linkTuple) {
+        LinkConfig lkc = getConfiguredLink(linkTuple);
+        // links are always disallowed if any one of the nodes that make up the
+        // link are disallowed
+        DeviceId linkNode1 = linkTuple.src().deviceId();
+        SwitchConfigStatus scs1 = checkSwitchConfig(linkNode1);
+        if (scs1.getConfigState() == NetworkConfigState.DENY) {
+            return new LinkConfigStatus(NetworkConfigState.DENY, null,
+                    "Link-node: " + linkNode1 + " denied by config: " + scs1.getMsg());
+        }
+        DeviceId linkNode2 = linkTuple.dst().deviceId();
+        SwitchConfigStatus scs2 = checkSwitchConfig(linkNode2);
+        if (scs2.getConfigState() == NetworkConfigState.DENY) {
+            return new LinkConfigStatus(NetworkConfigState.DENY, null,
+                    "Link-node: " + linkNode2 + " denied by config: " + scs2.getMsg());
+        }
+        if (networkConfig.getRestrictLinks()) {
+            // default deny behavior
+            if (lkc == null) {
+                // link is not configured - we deny this link
+                return new LinkConfigStatus(NetworkConfigState.DENY, null,
+                        "Link not configured, in network denying links by default.");
+            }
+            if (lkc.isAllowed()) {
+                // link is allowed in config, return configured attributes
+                return new LinkConfigStatus(NetworkConfigState.ACCEPT_ADD, lkc);
+            } else {
+                // link has been configured off (administratively down)
+                return new LinkConfigStatus(NetworkConfigState.DENY, null,
+                        "Link configured down (allowed=false).");
+            }
+        } else {
+            // default allow behavior
+            if (lkc == null) {
+                // no config to add
+                return new LinkConfigStatus(NetworkConfigState.ACCEPT, null);
+            }
+            if (lkc.isAllowed()) {
+                // link is allowed in config, return configured attributes
+                return new LinkConfigStatus(NetworkConfigState.ACCEPT_ADD, lkc);
+            } else {
+                // link has been configured off (administratively down)
+                return new LinkConfigStatus(NetworkConfigState.DENY, null,
+                        "Link configured down (allowed=false).");
+            }
+        }
+
+    }
+
+    @Override
+    public List<SwitchConfig> getConfiguredAllowedSwitches() {
+        List<SwitchConfig> allowed = new ArrayList<SwitchConfig>();
+        for (SwitchConfig swc : configuredSwitches.values()) {
+            if (swc.isAllowed()) {
+                allowed.add(swc);
+            }
+        }
+        return allowed;
+    }
+
+    @Override
+    public List<LinkConfig> getConfiguredAllowedLinks() {
+        List<LinkConfig> allowed = new ArrayList<LinkConfig>();
+        for (LinkConfig lkc : configuredLinks.values()) {
+            if (lkc.isAllowed()) {
+                allowed.add(lkc);
+            }
+        }
+        return allowed;
+    }
+
+    @Override
+    public DeviceId getDpidForName(String name) {
+        if (nameToDpid.get(name) != null) {
+            return nameToDpid.get(name);
+        }
+        return null;
+    }
+
+    // **************
+    // Private methods
+    // **************
+
+    private void loadNetworkConfig() {
+        File configFile = new File(CONFIG_DIR, configFileName);
+        ObjectMapper mapper = new ObjectMapper();
+        networkConfig = new NetworkConfig();
+
+        try {
+            networkConfig = mapper.readValue(configFile,
+                                             NetworkConfig.class);
+        } catch (JsonParseException e) {
+            String err = String.format("JsonParseException while loading network "
+                    + "config from file: %s: %s", configFileName,
+                    e.getMessage());
+            throw new NetworkConfigException.ErrorConfig(err);
+        } catch (JsonMappingException e) {
+            String err = String.format(
+                    "JsonMappingException while loading network config "
+                            + "from file: %s: %s",
+                            configFileName,
+                            e.getMessage());
+            throw new NetworkConfigException.ErrorConfig(err);
+        } catch (IOException e) {
+            String err = String.format("IOException while loading network config "
+                    + "from file: %s %s", configFileName, e.getMessage());
+            throw new NetworkConfigException.ErrorConfig(err);
+        }
+
+        log.info("Network config specifies: {} switches and {} links",
+                (networkConfig.getRestrictSwitches())
+                        ? networkConfig.getSwitchConfig().size() : "default allow",
+                        (networkConfig.getRestrictLinks())
+                        ? networkConfig.getLinkConfig().size() : "default allow");
+    }
+
+    private void parseNetworkConfig() {
+        List<SwitchConfig> swConfList = networkConfig.getSwitchConfig();
+        List<LinkConfig> lkConfList = networkConfig.getLinkConfig();
+        validateSwitchConfig(swConfList);
+        createTypeSpecificSwitchConfig(swConfList);
+        validateLinkConfig(lkConfList);
+        createTypeSpecificLinkConfig(lkConfList);
+        // TODO validate reachability matrix 'names' for configured dpids
+    }
+
+    private void createTypeSpecificSwitchConfig(List<SwitchConfig> swConfList) {
+        for (SwitchConfig swc : swConfList) {
+            nameToDpid.put(swc.getName(), swc.getDpid());
+            String swtype = swc.getType();
+            switch (swtype) {
+            case SEGMENT_ROUTER:
+                SwitchConfig sr = new SegmentRouterConfig(swc);
+                configuredSwitches.put(sr.getDpid(), sr);
+                break;
+            default:
+                throw new NetworkConfigException.UnknownSwitchType(swtype,
+                        swc.getName());
+            }
+        }
+    }
+
+    private void createTypeSpecificLinkConfig(List<LinkConfig> lkConfList) {
+        for (LinkConfig lkc : lkConfList) {
+            String lktype = lkc.getType();
+            switch (lktype) {
+            case PKT_LINK:
+                PktLinkConfig pk = new PktLinkConfig(lkc);
+                for (Link lt : pk.getLinkTupleList()) {
+                    configuredLinks.put(lt, pk);
+                }
+                break;
+            default:
+                throw new NetworkConfigException.UnknownLinkType(lktype,
+                        lkc.getNodeDpid1(), lkc.getNodeDpid2());
+            }
+        }
+    }
+
+    private void validateSwitchConfig(List<SwitchConfig> swConfList) {
+        Set<DeviceId> swDpids = new HashSet<DeviceId>();
+        Set<String> swNames = new HashSet<String>();
+        for (SwitchConfig swc : swConfList) {
+            if (swc.getNodeDpid() == null || swc.getDpid() == null) {
+                throw new NetworkConfigException.DpidNotSpecified(swc.getName());
+            }
+            // ensure both String and DeviceId values of dpid are set
+            if (!swc.getDpid().equals(DeviceId.deviceId(swc.getNodeDpid()))) {
+                throw new NetworkConfigException.SwitchDpidNotConverted(
+                        swc.getName());
+            }
+            if (swc.getName() == null) {
+                throw new NetworkConfigException.NameNotSpecified(swc.getDpid());
+            }
+            if (swc.getType() == null) {
+                throw new NetworkConfigException.SwitchTypeNotSpecified(
+                        swc.getDpid());
+            }
+            if (!swDpids.add(swc.getDpid())) {
+                throw new NetworkConfigException.DuplicateDpid(swc.getDpid());
+            }
+            if (!swNames.add(swc.getName())) {
+                throw new NetworkConfigException.DuplicateName(swc.getName());
+            }
+            // TODO Add more validations
+        }
+    }
+
+    private void validateLinkConfig(List<LinkConfig> lkConfList) {
+        for (LinkConfig lkc : lkConfList) {
+            if (lkc.getNodeDpid1() == null || lkc.getNodeDpid2() == null) {
+                throw new NetworkConfigException.LinkDpidNotSpecified(
+                        lkc.getNodeDpid1(), lkc.getNodeDpid2());
+            }
+            // ensure both String and Long values are set
+            if (!lkc.getDpid1().equals(DeviceId.deviceId(lkc.getNodeDpid1())) ||
+                    !lkc.getDpid2().equals(DeviceId.deviceId(lkc.getNodeDpid2()))) {
+                throw new NetworkConfigException.LinkDpidNotConverted(
+                        lkc.getNodeDpid1(), lkc.getNodeDpid2());
+            }
+            if (lkc.getType() == null) {
+                throw new NetworkConfigException.LinkTypeNotSpecified(
+                        lkc.getNodeDpid1(), lkc.getNodeDpid2());
+            }
+            if (configuredSwitches.get(lkc.getDpid1()) == null) {
+                throw new NetworkConfigException.LinkForUnknownSwitchConfig(
+                        lkc.getNodeDpid1());
+            }
+            if (configuredSwitches.get(lkc.getDpid2()) == null) {
+                throw new NetworkConfigException.LinkForUnknownSwitchConfig(
+                        lkc.getNodeDpid2());
+            }
+            // TODO add more validations
+        }
+
+    }
+
+    private LinkConfig getConfiguredLink(Link linkTuple) {
+        LinkConfig lkc = null;
+        // first try the unidirectional link with the ports assigned
+        lkc = configuredLinks.get(linkTuple);
+        return lkc;
+    }
+
+
+    /**
+     * Initializes the network configuration manager module by
+     * loading and parsing the network configuration file.
+     */
+    public void init() {
+        loadNetworkConfig();
+        configuredSwitches = new ConcurrentHashMap<DeviceId, SwitchConfig>();
+        configuredLinks = new ConcurrentHashMap<Link, LinkConfig>();
+        nameToDpid = new HashMap<String, DeviceId>();
+        parseNetworkConfig();
+    }
+}

+package org.onosproject.segmentrouting.config;
+
+import java.util.List;
+
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Link;
+import org.onosproject.segmentrouting.config.NetworkConfig.LinkConfig;
+import org.onosproject.segmentrouting.config.NetworkConfig.SwitchConfig;
+
+/**
+ * Exposes methods to retrieve network configuration.
+ *
+ * TODO: currently only startup-configuration is exposed and such configuration
+ * cannot be changed at runtime. Need to add runtime support for changes to
+ * configuration (via REST/CLI) in future releases.
+ *
+ * TODO: return immutable objects or defensive copies of network config so that
+ * users of this API do not inadvertently or maliciously change network config.
+ */
+public interface NetworkConfigService {
+
+    /**
+     * Suggests the action to be taken by the caller given the configuration
+     * associated with the queried network-object (eg. switch, link etc.).
+     */
+    public enum NetworkConfigState {
+        /**
+         * Associated network object has been configured to not be allowed in
+         * the network.
+         */
+        DENY,
+
+        /**
+         * Associated network object has been configured to be allowed in the
+         * network.
+         */
+        ACCEPT,
+
+        /**
+         * Associated network object has been configured to be allowed in the
+         * network. In addition, there are configured parameters that should be
+         * added to the object.
+         */
+        ACCEPT_ADD,
+    }
+
+    /**
+     * Returns the configuration outcome (accept, deny etc.), and any configured
+     * parameters to the caller, in response to a query for the configuration
+     * associated with a switch.
+     */
+    public class SwitchConfigStatus {
+        private NetworkConfigState configState;
+        private SwitchConfig switchConfig;
+        private String msg;
+
+        SwitchConfigStatus(NetworkConfigState configState,
+                SwitchConfig switchConfig, String msg) {
+            this.configState = configState;
+            this.switchConfig = switchConfig;
+            this.msg = msg;
+        }
+
+        SwitchConfigStatus(NetworkConfigState configState,
+                SwitchConfig switchConfig) {
+            this.configState = configState;
+            this.switchConfig = switchConfig;
+            this.msg = "";
+        }
+
+        /**
+         * Returns the configuration state for the switch.
+         *
+         * @return non-null NetworkConfigState
+         */
+        public NetworkConfigState getConfigState() {
+            return configState;
+        }
+
+        /**
+         * Returns the switch configuration, which may be null if no
+         * configuration exists, or if the configuration state disallows the
+         * switch.
+         *
+         * @return SwitchConfig, the switch configuration, or null
+         */
+        public SwitchConfig getSwitchConfig() {
+            return switchConfig;
+        }
+
+        /**
+         * User readable string typically used to specify the reason why a
+         * switch is being disallowed.
+         *
+         * @return A non-null but possibly empty String
+         */
+        public String getMsg() {
+            return msg;
+        }
+
+    }
+
+    /**
+     * Reserved for future use.
+     *
+     * Returns the configuration outcome (accept, deny etc.), and any configured
+     * parameters to the caller, in response to a query for the configuration
+     * associated with a link.
+     */
+    public class LinkConfigStatus {
+        private NetworkConfigState configState;
+        private LinkConfig linkConfig;
+        private String msg;
+
+        LinkConfigStatus(NetworkConfigState configState,
+                LinkConfig linkConfig, String msg) {
+            this.configState = configState;
+            this.linkConfig = linkConfig;
+            this.msg = msg;
+        }
+
+        LinkConfigStatus(NetworkConfigState configState,
+                LinkConfig linkConfig) {
+            this.configState = configState;
+            this.linkConfig = linkConfig;
+            this.msg = "";
+        }
+
+        /**
+         * Returns the configuration state for the link.
+         *
+         * @return non-null NetworkConfigState
+         */
+        public NetworkConfigState getConfigState() {
+            return configState;
+        }
+
+        /**
+         * Returns the link configuration, which may be null if no configuration
+         * exists, or if the configuration state disallows the link.
+         *
+         * @return SwitchConfig, the switch configuration, or null
+         */
+        public LinkConfig getLinkConfig() {
+            return linkConfig;
+        }
+
+        /**
+         * User readable string typically used to specify the reason why a link
+         * is being disallowed.
+         *
+         * @return msg A non-null but possibly empty String
+         */
+        public String getMsg() {
+            return msg;
+        }
+
+    }
+
+    /**
+     * Checks the switch configuration (if any) associated with the 'dpid'.
+     * Determines if the switch should be allowed or denied according to
+     * configuration rules.
+     *
+     * The method always returns a non-null SwitchConfigStatus. The enclosed
+     * ConfigState contains the result of the check. The enclosed SwitchConfig
+     * may or may not be null, depending on the outcome of the check.
+     *
+     * @param dpid device id of the switch to be queried
+     * @return SwitchConfigStatus with outcome of check and associated config.
+     */
+    public SwitchConfigStatus checkSwitchConfig(DeviceId dpid);
+
+    /**
+     * Reserved for future use.
+     *
+     * Checks the link configuration (if any) associated with the 'link'.
+     * Determines if the link should be allowed or denied according to
+     * configuration rules. Note that the 'link' is a unidirectional link which
+     * checked against configuration that is typically defined for a
+     * bidirectional link. The caller may make a second call if it wishes to
+     * check the 'reverse' direction.
+     *
+     * Also note that the configuration may not specify ports for a given
+     * bidirectional link. In such cases, the configuration applies to all links
+     * between the two switches. This method will check the given 'link' against
+     * such configuration.
+
+     * The method always returns a non-null LinkConfigStatus. The enclosed
+     * ConfigState contains the result of the check. The enclosed LinkConfig may
+     * or may not be null, depending on the outcome of the check.
+     *
+     * @param linkTuple unidirectional link to be queried
+     * @return LinkConfigStatus with outcome of check and associated config.
+     */
+    public LinkConfigStatus checkLinkConfig(Link linkTuple);
+
+    /**
+     * Retrieves a list of switches that have been configured, and have been
+     * determined to be 'allowed' in the network, according to configuration
+     * rules.
+     *
+     * Note that it is possible that there are other switches that are allowed
+     * in the network that have NOT been configured. Such switches will not be a
+     * part of the returned list.
+     *
+     * Also note that it is possible that some switches will not be discovered
+     * and the only way the controller can know about these switches is via
+     * configuration. Such switches will be included in this list. It is up to
+     * the caller to determine which SwitchConfig applies to non-discovered
+     * switches.
+     *
+     * @return a non-null List of SwitchConfig which may be empty
+     */
+    public List<SwitchConfig> getConfiguredAllowedSwitches();
+
+    /**
+     * Reserved for future use.
+     *
+     * Retrieves a list of links that have been configured, and have been
+     * determined to be 'allowed' in the network, according to configuration
+     * rules.
+     *
+     * Note that it is possible that there are other links that are allowed in
+     * the network that have NOT been configured. Such links will not be a part
+     * of the returned list.
+     *
+     * Also note that it is possible that some links will not be discovered and
+     * the only way the controller can know about these links is via
+     * configuration. Such links will be included in this list. It is up to the
+     * caller to determine which LinkConfig applies to non-discovered links.
+     *
+     * In addition, note that the LinkConfig applies to the configured
+     * bi-directional link, which may or may not have declared ports. The
+     * associated unidirectional LinkTuple can be retrieved from the
+     * getLinkTupleList() method in the LinkConfig object.
+     *
+     * @return a non-null List of LinkConfig which may be empty
+     */
+    public List<LinkConfig> getConfiguredAllowedLinks();
+
+    /**
+     * Retrieves the Dpid associated with a 'name' for a configured switch
+     * object. This method does not check of the switches are 'allowed' by
+     * config.
+     *
+     * @param name device name
+     * @return the Dpid corresponding to a given 'name', or null if no
+     *         configured switch was found for the given 'name'.
+     */
+    public DeviceId getDpidForName(String name);
+
+}

+package org.onosproject.segmentrouting.config;
+
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.onosproject.net.Link;
+import org.onosproject.segmentrouting.config.NetworkConfig.LinkConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+/**
+ * Reserved for future use.
+ * Configuration for a link between two packet-switches.
+ */
+public class PktLinkConfig extends LinkConfig {
+    protected static final Logger log = LoggerFactory
+            .getLogger(PktLinkConfig.class);
+    private int port1;
+    private int port2;
+    private String nodeName1;
+    private String nodeName2;
+    private List<Link> linkTupleList;
+
+    public PktLinkConfig(LinkConfig lkc) {
+        nodeDpid1 = lkc.getNodeDpid1();
+        nodeDpid2 = lkc.getNodeDpid2();
+        dpid1 = lkc.getDpid1();
+        dpid2 = lkc.getDpid2();
+        type = lkc.getType();
+        allowed = lkc.isAllowed();
+        params = lkc.getParams();
+        publishAttributes = new ConcurrentHashMap<String, String>();
+        parseParams();
+        validateParams();
+        setPublishAttributes();
+    }
+
+    // ********************
+    // Packet Link Configuration
+    // ********************
+
+    public int getPort1() {
+        return port1;
+    }
+
+    public void setPort1(int port1) {
+        this.port1 = port1;
+    }
+
+    public int getPort2() {
+        return port2;
+    }
+
+    public void setPort2(int port2) {
+        this.port2 = port2;
+    }
+
+    public String getNodeName1() {
+        return nodeName1;
+    }
+
+    public void setNodeName1(String nodeName1) {
+        this.nodeName1 = nodeName1;
+    }
+
+    public String getNodeName2() {
+        return nodeName2;
+    }
+
+    public void setNodeName2(String nodeName2) {
+        this.nodeName2 = nodeName2;
+    }
+
+    /**
+     * Returns the two unidirectional links corresponding to the packet-link
+     * configuration. It is possible that the ports in the LinkTuple have
+     * portnumber '0', implying that the configuration applies to all links
+     * between the two switches.
+     *
+     * @return a list of LinkTuple with exactly 2 unidirectional links
+     */
+    public List<Link> getLinkTupleList() {
+        return linkTupleList;
+    }
+
+    private void setPublishAttributes() {
+
+    }
+
+    private void parseParams() {
+        if (params == null) {
+            throw new PktLinkParamsNotSpecified(nodeDpid1, nodeDpid2);
+        }
+        Set<Entry<String, JsonNode>> m = params.entrySet();
+        for (Entry<String, JsonNode> e : m) {
+            String key = e.getKey();
+            JsonNode j = e.getValue();
+            if (key.equals("nodeName1")) {
+                setNodeName1(j.asText());
+            } else if (key.equals("nodeName2")) {
+                setNodeName2(j.asText());
+            } else if (key.equals("port1")) {
+                setPort1(j.asInt());
+            } else if (key.equals("port2")) {
+                setPort2(j.asInt());
+            } else {
+                throw new UnknownPktLinkConfig(key, nodeDpid1, nodeDpid2);
+            }
+        }
+    }
+
+    private void validateParams() {
+        // TODO - wrong-names, duplicate links,
+        // duplicate use of port, is switch-allowed for which link is allowed?
+        // valid port numbers
+    }
+
+    public static class PktLinkParamsNotSpecified extends RuntimeException {
+        private static final long serialVersionUID = 6247582323691265513L;
+
+        public PktLinkParamsNotSpecified(String dpidA, String dpidB) {
+            super();
+            log.error("Params required for packet link - not specified "
+                    + "for link between switch1:{} and switch2:{}",
+                    dpidA, dpidB);
+        }
+    }
+
+    public static class UnknownPktLinkConfig extends RuntimeException {
+        private static final long serialVersionUID = -5750132094884129179L;
+
+        public UnknownPktLinkConfig(String key, String dpidA, String dpidB) {
+            super();
+            log.error("Unknown packet-link config {} for link between"
+                    + " dpid1: {} and dpid2: {}", key,
+                    dpidA, dpidB);
+        }
+    }
+
+}

+package org.onosproject.segmentrouting.config;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.onosproject.net.DeviceId;
+import org.onosproject.segmentrouting.config.NetworkConfig.SwitchConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Manages additional configuration for switches configured as Segment Routers.
+ */
+public class SegmentRouterConfig extends SwitchConfig {
+    protected static final Logger log = LoggerFactory
+            .getLogger(SegmentRouterConfig.class);
+    private String routerIp;
+    private String routerMac;
+    private int nodeSid;
+    private boolean isEdgeRouter;
+    private List<AdjacencySid> adjacencySids;
+    private List<Subnet> subnets;
+
+    public static final String ROUTER_IP = "routerIp";
+    public static final String ROUTER_MAC = "routerMac";
+    public static final String NODE_SID = "nodeSid";
+    public static final String ADJACENCY_SIDS = "adjacencySids";
+    public static final String SUBNETS = "subnets";
+    public static final String ISEDGE = "isEdgeRouter";
+    private static final int SRGB_MAX = 1000;
+
+    /**
+     * Parses and validates the additional configuration parameters applicable
+     * to segment routers.
+     *
+     * @param swc switch configuration
+     */
+    public SegmentRouterConfig(SwitchConfig swc) {
+        this.setName(swc.getName());
+        this.setDpid(swc.getDpid());
+        this.setType(swc.getType());
+        this.setLatitude(swc.getLatitude());
+        this.setLongitude(swc.getLongitude());
+        this.setParams(swc.getParams());
+        this.setAllowed(swc.isAllowed());
+        publishAttributes = new ConcurrentHashMap<String, String>();
+        adjacencySids = new ArrayList<AdjacencySid>();
+        subnets = new ArrayList<Subnet>();
+        parseParams();
+        validateParams();
+        setPublishAttributes();
+    }
+
+    /**
+     * Returns the configured segment router IP address.
+     *
+     * @return ip address in string format
+     */
+    public String getRouterIp() {
+        return routerIp;
+    }
+
+    public void setRouterIp(String routerIp) {
+        this.routerIp = routerIp;
+    }
+
+    /**
+     * Returns the configured segment router mac address.
+     *
+     * @return mac address in string format
+     */
+    public String getRouterMac() {
+        return routerMac;
+    }
+
+    public void setRouterMac(String routerMac) {
+        this.routerMac = routerMac;
+    }
+
+    /**
+     * Returns the configured sID for a segment router.
+     *
+     * @return segment identifier
+     */
+    public int getNodeSid() {
+        return nodeSid;
+    }
+
+    public void setNodeSid(int nodeSid) {
+        this.nodeSid = nodeSid;
+    }
+
+    /**
+     * Returns the flag that indicates the configured segment router
+     * is edge or backbone router.
+     *
+     * @return boolean
+     */
+    public boolean isEdgeRouter() {
+        return isEdgeRouter;
+    }
+
+    public void setIsEdgeRouter(boolean isEdge) {
+        this.isEdgeRouter = isEdge;
+    }
+
+    /**
+     * Class representing segment router adjacency identifier.
+     */
+    public static class AdjacencySid {
+        private int adjSid;
+        private List<Integer> ports;
+
+        public AdjacencySid(int adjSid, List<Integer> ports) {
+            this.ports = ports;
+            this.adjSid = adjSid;
+        }
+
+        /**
+         * Returns the list of ports part of a segment
+         * router adjacency identifier.
+         *
+         * @return list of integers
+         */
+        public List<Integer> getPorts() {
+            return ports;
+        }
+
+        public void setPorts(List<Integer> ports) {
+            this.ports = ports;
+        }
+
+        /**
+         * Returns the configured adjacency id of a segment router.
+         *
+         * @return integer
+         */
+        public int getAdjSid() {
+            return adjSid;
+        }
+
+        public void setAdjSid(int adjSid) {
+            this.adjSid = adjSid;
+        }
+    }
+
+    /**
+     * Returns the configured adjacent segment IDs for a segment router.
+     *
+     * @return list of adjacency identifier
+     */
+    public List<AdjacencySid> getAdjacencySids() {
+        return adjacencySids;
+    }
+
+    public void setAdjacencySids(List<AdjacencySid> adjacencySids) {
+        this.adjacencySids = adjacencySids;
+    }
+
+    /**
+     * Class representing a subnet attached to a segment router.
+     */
+    public static class Subnet {
+        private int portNo;
+        private String subnetIp;
+
+        public Subnet(int portNo, String subnetIp) {
+            this.portNo = portNo;
+            this.subnetIp = subnetIp;
+        }
+
+        /**
+         * Returns the port number of segment router on
+         * which subnet is attached.
+         *
+         * @return integer
+         */
+        public int getPortNo() {
+            return portNo;
+        }
+
+        public void setPortNo(int portNo) {
+            this.portNo = portNo;
+        }
+
+        /**
+         * Returns the configured subnet address.
+         *
+         * @return subnet ip address in string format
+         */
+        public String getSubnetIp() {
+            return subnetIp;
+        }
+
+        public void setSubnetIp(String subnetIp) {
+            this.subnetIp = subnetIp;
+        }
+    }
+
+    /**
+     * Returns the configured subnets for a segment router.
+     *
+     * @return list of subnets
+     */
+    public List<Subnet> getSubnets() {
+        return subnets;
+    }
+
+    public void setSubnets(List<Subnet> subnets) {
+        this.subnets = subnets;
+    }
+
+    // ********************
+    // Helper methods
+    // ********************
+
+    private void parseParams() {
+        if (params == null) {
+            throw new NetworkConfigException.ParamsNotSpecified(name);
+        }
+
+        Set<Entry<String, JsonNode>> m = params.entrySet();
+        for (Entry<String, JsonNode> e : m) {
+            String key = e.getKey();
+            JsonNode j = e.getValue();
+            if (key.equals("routerIp")) {
+                setRouterIp(j.asText());
+            } else if (key.equals("routerMac")) {
+                setRouterMac(j.asText());
+            } else if (key.equals("nodeSid")) {
+                setNodeSid(j.asInt());
+            } else if (key.equals("isEdgeRouter")) {
+                setIsEdgeRouter(j.asBoolean());
+            } else if (key.equals("adjacencySids") || key.equals("subnets")) {
+                getInnerParams(j, key);
+            } else {
+                throw new UnknownSegmentRouterConfig(key, dpid);
+            }
+        }
+    }
+
+    private void getInnerParams(JsonNode j, String innerParam) {
+        Iterator<JsonNode> innerList = j.elements();
+        while (innerList.hasNext()) {
+            Iterator<Entry<String, JsonNode>> f = innerList.next().fields();
+            int portNo = -1;
+            int adjSid = -1;
+            String subnetIp = null;
+            List<Integer> ports = null;
+            while (f.hasNext()) {
+                Entry<String, JsonNode> fe = f.next();
+                if (fe.getKey().equals("portNo")) {
+                    portNo = fe.getValue().asInt();
+                } else if (fe.getKey().equals("adjSid")) {
+                    adjSid = fe.getValue().asInt();
+                } else if (fe.getKey().equals("subnetIp")) {
+                    subnetIp = fe.getValue().asText();
+                } else if (fe.getKey().equals("ports")) {
+                    if (fe.getValue().isArray()) {
+                        Iterator<JsonNode> i = fe.getValue().elements();
+                        ports = new ArrayList<Integer>();
+                        while (i.hasNext()) {
+                            ports.add(i.next().asInt());
+                        }
+                    }
+                } else {
+                    throw new UnknownSegmentRouterConfig(fe.getKey(), dpid);
+                }
+            }
+            if (innerParam.equals("adjacencySids")) {
+                AdjacencySid ads = new AdjacencySid(adjSid, ports);
+                adjacencySids.add(ads);
+            } else {
+                Subnet sip = new Subnet(portNo, subnetIp);
+                subnets.add(sip);
+            }
+        }
+    }
+
+    private void validateParams() {
+        if (routerIp == null) {
+            throw new IpNotSpecified(dpid);
+        }
+        if (routerMac == null) {
+            throw new MacNotSpecified(dpid);
+        }
+        if (isEdgeRouter && subnets.isEmpty()) {
+            throw new SubnetNotSpecifiedInEdgeRouter(dpid);
+        }
+        if (!isEdgeRouter && !subnets.isEmpty()) {
+            throw new SubnetSpecifiedInBackboneRouter(dpid);
+        }
+        if (nodeSid > SRGB_MAX) {
+            throw new NodeLabelNotInSRGB(nodeSid, dpid);
+        }
+        for (AdjacencySid as : adjacencySids) {
+            int label = as.getAdjSid();
+            List<Integer> plist = as.getPorts();
+            if (label <= SRGB_MAX) {
+                throw new AdjacencyLabelInSRGB(label, dpid);
+            }
+            if (plist.size() <= 1) {
+                throw new AdjacencyLabelNotEnoughPorts(label, dpid);
+            }
+        }
+
+
+        // TODO more validations
+    }
+
+    /**
+     * Setting publishAttributes implies that this is the configuration that
+     * will be added to Topology.Switch object before it is published on the
+     * channel to other controller instances.
+     */
+    private void setPublishAttributes() {
+        publishAttributes.put(ROUTER_IP, routerIp);
+        publishAttributes.put(ROUTER_MAC, routerMac);
+        publishAttributes.put(NODE_SID, String.valueOf(nodeSid));
+        publishAttributes.put(ISEDGE, String.valueOf(isEdgeRouter));
+        ObjectMapper mapper = new ObjectMapper();
+        try {
+            publishAttributes.put(ADJACENCY_SIDS,
+                    mapper.writeValueAsString(adjacencySids));
+            publishAttributes.put(SUBNETS,
+                    mapper.writeValueAsString(subnets));
+        } catch (JsonProcessingException e) {
+            log.error("Error while writing SR config: {}", e.getCause());
+        } catch (IOException e) {
+            log.error("Error while writing SR config: {}", e.getCause());
+        }
+    }
+
+    // ********************
+    // Exceptions
+    // ********************
+
+    public static class IpNotSpecified extends RuntimeException {
+        private static final long serialVersionUID = -3001502553646331686L;
+
+        public IpNotSpecified(DeviceId dpid) {
+            super();
+            log.error("Router IP address not specified for SR config dpid:{}",
+                    dpid);
+        }
+    }
+
+    public static class MacNotSpecified extends RuntimeException {
+        private static final long serialVersionUID = -5850132094884129179L;
+
+        public MacNotSpecified(DeviceId dpid) {
+            super();
+            log.error("Router Mac address not specified for SR config dpid:{}",
+                    dpid);
+        }
+    }
+
+    public static class UnknownSegmentRouterConfig extends RuntimeException {
+        private static final long serialVersionUID = -5750132094884129179L;
+
+        public UnknownSegmentRouterConfig(String key, DeviceId dpid) {
+            super();
+            log.error("Unknown Segment Router config {} in dpid: {}", key,
+                    dpid);
+        }
+    }
+
+    public static class SubnetNotSpecifiedInEdgeRouter extends RuntimeException {
+        private static final long serialVersionUID = -5855458472668581268L;
+
+        public SubnetNotSpecifiedInEdgeRouter(DeviceId dpid) {
+            super();
+            log.error("Subnet was not specified for edge router in dpid: {}",
+                    dpid);
+        }
+    }
+
+    public static class SubnetSpecifiedInBackboneRouter extends RuntimeException {
+        private static final long serialVersionUID = 1L;
+
+        public SubnetSpecifiedInBackboneRouter(DeviceId dpid) {
+            super();
+            log.error("Subnet was specified in backbone router in dpid: {}",
+                    dpid);
+        }
+    }
+
+    public static class NodeLabelNotInSRGB extends RuntimeException {
+        private static final long serialVersionUID = -8482670903748519526L;
+
+        public NodeLabelNotInSRGB(int label, DeviceId dpid) {
+            super();
+            log.error("Node sif {} specified in not in global label-base "
+                    + "in dpid: {}", label,
+                    dpid);
+        }
+    }
+
+    public static class AdjacencyLabelInSRGB extends RuntimeException {
+        private static final long serialVersionUID = -8482670903748519526L;
+
+        public AdjacencyLabelInSRGB(int label, DeviceId dpid) {
+            super();
+            log.error("Adjaceny label {} specified from global label-base "
+                    + "in dpid: {}", label,
+                    dpid);
+        }
+    }
+
+    public static class AdjacencyLabelNotEnoughPorts extends RuntimeException {
+        private static final long serialVersionUID = -8482670903748519526L;
+
+        public AdjacencyLabelNotEnoughPorts(int label, DeviceId dpid) {
+            super();
+            log.error("Adjaceny label {} must be specified for at least 2 ports. "
+                    + "Adjacency labels for single ports are auto-generated "
+                    + "in dpid: {}", label,
+                    dpid);
+        }
+    }
+}

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.onosproject.grouphandler;
+package org.onosproject.segmentrouting.grouphandler;
 
 
 import java.util.Arrays;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.HashSet;

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.onosproject.grouphandler;
+package org.onosproject.segmentrouting.grouphandler;
 
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static org.slf4j.LoggerFactory.getLogger;
 import static org.slf4j.LoggerFactory.getLogger;

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.onosproject.grouphandler;
+package org.onosproject.segmentrouting.grouphandler;
 
 
 import java.util.Arrays;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.HashSet;

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.onosproject.grouphandler;
+package org.onosproject.segmentrouting.grouphandler;
 
 
 import java.util.List;
 import java.util.List;
 
 

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.onosproject.grouphandler;
+package org.onosproject.segmentrouting.grouphandler;
 
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 

@@ -14,7 +14,7 @@
  * limitations under the License.
  * limitations under the License.
  */
  */
 
 
-package org.onosproject.grouphandler;
+package org.onosproject.segmentrouting.grouphandler;
 
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.onosproject.grouphandler;
+package org.onosproject.segmentrouting.grouphandler;
 
 
 import static org.slf4j.LoggerFactory.getLogger;
 import static org.slf4j.LoggerFactory.getLogger;
 
 
@@ -26,7 +26,7 @@ import java.util.List;
 import org.onlab.packet.MplsLabel;
 import org.onlab.packet.MplsLabel;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.GroupId;
 import org.onosproject.core.GroupId;
-import org.onosproject.grouphandler.GroupBucketIdentifier.BucketOutputType;
+import org.onosproject.segmentrouting.grouphandler.GroupBucketIdentifier.BucketOutputType;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.PortNumber;
 import org.onosproject.net.PortNumber;
 import org.onosproject.net.flow.DefaultTrafficTreatment;
 import org.onosproject.net.flow.DefaultTrafficTreatment;

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.onosproject.grouphandler;
+package org.onosproject.segmentrouting.grouphandler;
 
 
 import java.util.List;
 import java.util.List;
 
 

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.onosproject.grouphandler;
+package org.onosproject.segmentrouting.grouphandler;
 
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 

+{
+  "comment": " Multilayer topology description and configuration",
+  "restrictSwitches": true,
+  "restrictLinks": true,
+
+  "switchConfig":
+             [
+               { "nodeDpid" : "of:0000000000000001", "name": "Dallas-R1", "type": "Router_SR", "allowed": true,
+                 "latitude": 80.80, "longitude": 90.10,
+                 "params": { "routerIp": "192.168.0.1/32",
+                             "routerMac": "00:00:01:01:01:80",
+                             "nodeSid": 101,
+                             "isEdgeRouter" : true,
+                             "adjacencySids": [
+                                               { "ports": [ 4, 5 ], "adjSid": 10234 },
+                                               { "ports": [ 6, 7 ], "adjSid": 29019 }
+                                               ],
+                             "subnets": [
+                                         { "portNo": 1, "subnetIp": "10.0.1.128/24" }
+                                         ]
+                             }
+                 },
+
+               { "nodeDpid": "of:0000000000000002", "name": "Dallas-R2", "type": "Router_SR", "allowed": true,
+                 "latitude": 80.80, "longitude": 90.10,
+                 "params": { "routerIp": "192.168.0.2/32",
+                             "routerMac": "00:00:02:02:02:80",
+                             "nodeSid": 102,
+                             "isEdgeRouter" : false,
+                             "adjacencySids": [
+                                               { "ports": [ 1, 2 ], "adjSid": 12453 },
+                                               { "ports": [ 2, 3 ], "adjSid": 23333 },
+                                               { "ports": [ 3, 1 ], "adjSid": 22233 }
+                                               ]
+                             }
+                 },
+
+               { "nodeDpid": "of:0000000000000003", "name": "Dallas-R3", "type": "Router_SR", "allowed": true,
+                 "latitude": 80.80, "longitude": 90.10,
+                 "params": { "routerIp": "192.168.0.3/32",
+                             "routerMac": "00:00:03:03:03:80",
+                             "nodeSid": 103,
+                             "isEdgeRouter" : false
+                             }
+                 },
+
+		{ "nodeDpid": "of:0000000000000004", "name": "Dallas-R4", "type": "Router_SR", "allowed": true,
+                 "latitude": 80.80, "longitude": 90.10,
+                 "params": { "routerIp": "192.168.0.4/32",
+                             "routerMac": "00:00:04:04:04:80",
+                             "nodeSid": 104,
+                             "isEdgeRouter" : false
+                             }
+                 },
+
+		{ "nodeDpid": "of:0000000000000005", "name": "Dallas-R5", "type": "Router_SR", "allowed": true,
+                 "latitude": 80.80, "longitude": 90.10,
+                 "params": { "routerIp": "192.168.0.5/32",
+                             "routerMac": "00:00:05:05:05:80",
+                             "nodeSid": 105,
+                             "isEdgeRouter" : false
+                             }
+                 },
+
+		{ "nodeDpid": "of:0000000000000006", "name": "Dallas-R6", "type": "Router_SR", "allowed": true,
+                 "latitude": 80.80, "longitude": 90.10,
+                 "params": { "routerIp": "192.168.0.6/32",
+                             "routerMac": "00:00:07:07:07:80",
+                             "nodeSid": 106,
+                             "isEdgeRouter" : true,
+                             "subnets": [
+                                         { "portNo": 1, "subnetIp": "7.7.7.128/24" }
+                                         ]
+                             }
+                 }
+
+               ]
+}