Make vRouter components into separate apps.
This allows us to leverage the ONOS app subsystem for selecting which
components to load.
CORD-710
Change-Id: Ibd7c4c1afd2caa137b44c085e7b6b5b4a1082521
diff --git a/apps/routing/fibinstaller/BUCK b/apps/routing/fibinstaller/BUCK
new file mode 100644
index 0000000..b77e51b
--- /dev/null
+++ b/apps/routing/fibinstaller/BUCK
@@ -0,0 +1,30 @@
+COMPILE_DEPS = [
+ '//lib:CORE_DEPS',
+ '//incubator/api:onos-incubator-api',
+ '//apps/routing-api:onos-apps-routing-api',
+]
+
+TEST_DEPS = [
+ '//lib:TEST_ADAPTERS',
+ '//incubator/api:onos-incubator-api-tests',
+ '//apps/routing-api:onos-apps-routing-api-tests',
+]
+
+osgi_jar_with_tests (
+ deps = COMPILE_DEPS,
+ test_deps = TEST_DEPS,
+)
+
+BUNDLES = [
+ '//apps/routing/fibinstaller:onos-apps-routing-fibinstaller',
+ '//apps/routing-api:onos-apps-routing-api',
+]
+
+onos_app (
+ app_name = 'org.onosproject.fibinstaller',
+ title = 'FIB installer app',
+ category = 'Traffic Steering',
+ url = 'http://onosproject.org',
+ description = 'Installs routing rules into switches',
+ included_bundles = BUNDLES,
+)
diff --git a/apps/routing/fibinstaller/pom.xml b/apps/routing/fibinstaller/pom.xml
new file mode 100644
index 0000000..5cb98e6
--- /dev/null
+++ b/apps/routing/fibinstaller/pom.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ ~ Copyright 2017-present Open Networking Laboratory
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <parent>
+ <artifactId>onos-app-routing-parent</artifactId>
+ <groupId>org.onosproject</groupId>
+ <version>1.9.0-SNAPSHOT</version>
+ </parent>
+ <modelVersion>4.0.0</modelVersion>
+
+ <artifactId>onos-apps-routing-fibinstaller</artifactId>
+ <packaging>bundle</packaging>
+
+
+</project>
diff --git a/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/SingleSwitchFibInstaller.java b/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/SingleSwitchFibInstaller.java
new file mode 100644
index 0000000..c6b3af4
--- /dev/null
+++ b/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/SingleSwitchFibInstaller.java
@@ -0,0 +1,567 @@
+/*
+ * Copyright 2017-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.routing.fibinstaller;
+
+import com.google.common.collect.ConcurrentHashMultiset;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multiset;
+import com.google.common.collect.Sets;
+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.Modified;
+import org.apache.felix.scr.annotations.Property;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpPrefix;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onlab.util.Tools;
+import org.onosproject.app.ApplicationService;
+import org.onosproject.cfg.ComponentConfigService;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.incubator.net.config.basics.McastConfig;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceService;
+import org.onosproject.incubator.net.routing.ResolvedRoute;
+import org.onosproject.incubator.net.routing.RouteEvent;
+import org.onosproject.incubator.net.routing.RouteListener;
+import org.onosproject.incubator.net.routing.RouteService;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.config.ConfigFactory;
+import org.onosproject.net.config.NetworkConfigEvent;
+import org.onosproject.net.config.NetworkConfigListener;
+import org.onosproject.net.config.NetworkConfigRegistry;
+import org.onosproject.net.config.NetworkConfigService;
+import org.onosproject.net.config.basics.SubjectFactories;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.flow.DefaultTrafficSelector;
+import org.onosproject.net.flow.DefaultTrafficTreatment;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flow.criteria.Criteria;
+import org.onosproject.net.flowobjective.DefaultFilteringObjective;
+import org.onosproject.net.flowobjective.DefaultForwardingObjective;
+import org.onosproject.net.flowobjective.DefaultNextObjective;
+import org.onosproject.net.flowobjective.DefaultObjectiveContext;
+import org.onosproject.net.flowobjective.FilteringObjective;
+import org.onosproject.net.flowobjective.FlowObjectiveService;
+import org.onosproject.net.flowobjective.ForwardingObjective;
+import org.onosproject.net.flowobjective.NextObjective;
+import org.onosproject.net.flowobjective.ObjectiveContext;
+import org.onosproject.routing.AsyncDeviceFetcher;
+import org.onosproject.routing.NextHop;
+import org.onosproject.routing.NextHopGroupKey;
+import org.onosproject.routing.RouterInterfaceManager;
+import org.onosproject.routing.RoutingService;
+import org.onosproject.routing.config.RouterConfig;
+import org.osgi.service.component.ComponentContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Dictionary;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Programs routes to a single OpenFlow switch.
+ */
+@Component(immediate = true)
+public class SingleSwitchFibInstaller {
+
+ private final Logger log = LoggerFactory.getLogger(getClass());
+ private static final String APP_NAME = "org.onosproject.vrouter";
+
+ private static final int PRIORITY_OFFSET = 100;
+ private static final int PRIORITY_MULTIPLIER = 5;
+
+ // FIXME: This should be eliminated when we have an API in SR that
+ // programs the fabric switches for VR
+ public static final short ASSIGNED_VLAN = 4094;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected CoreService coreService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected RouteService routeService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected InterfaceService interfaceService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected NetworkConfigService networkConfigService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected NetworkConfigRegistry networkConfigRegistry;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected ComponentConfigService componentConfigService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected FlowObjectiveService flowObjectiveService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected DeviceService deviceService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected ApplicationService applicationService;
+
+ @Property(name = "routeToNextHop", boolValue = false,
+ label = "Install a /32 or /128 route to each next hop")
+ private boolean routeToNextHop = false;
+
+ // Device id of data-plane switch - should be learned from config
+ private DeviceId deviceId;
+
+ private ConnectPoint controlPlaneConnectPoint;
+
+ private RouterInterfaceManager interfaceManager;
+ private AsyncDeviceFetcher asyncDeviceFetcher;
+
+ private ApplicationId coreAppId;
+ private ApplicationId routerAppId;
+ private ApplicationId vrouterAppId;
+
+ // Reference count for how many times a next hop is used by a route
+ private final Multiset<IpAddress> nextHopsCount = ConcurrentHashMultiset.create();
+
+ // Mapping from prefix to its current next hop
+ private final Map<IpPrefix, IpAddress> prefixToNextHop = Maps.newHashMap();
+
+ // Mapping from next hop IP to next hop object containing group info
+ private final Map<IpAddress, Integer> nextHops = Maps.newHashMap();
+
+ private final InternalRouteListener routeListener = new InternalRouteListener();
+ private final InternalNetworkConfigListener configListener = new InternalNetworkConfigListener();
+
+ private ConfigFactory<ApplicationId, McastConfig> mcastConfigFactory =
+ new ConfigFactory<ApplicationId, McastConfig>(SubjectFactories.APP_SUBJECT_FACTORY,
+ McastConfig.class, "multicast") {
+ @Override
+ public McastConfig createConfig() {
+ return new McastConfig();
+ }
+ };
+
+ @Activate
+ protected void activate(ComponentContext context) {
+ componentConfigService.registerProperties(getClass());
+ modified(context);
+
+ coreAppId = coreService.registerApplication(CoreService.CORE_APP_NAME);
+ routerAppId = coreService.registerApplication(RoutingService.ROUTER_APP_ID);
+ vrouterAppId = coreService.registerApplication(APP_NAME);
+
+ networkConfigRegistry.registerConfigFactory(mcastConfigFactory);
+
+ networkConfigService.addListener(configListener);
+
+ asyncDeviceFetcher = AsyncDeviceFetcher.create(deviceService);
+
+ processRouterConfig();
+
+ // FIXME: There can be an issue when this component is deactivated before vRouter.
+ // This will be addressed in CORD-710.
+ applicationService.registerDeactivateHook(vrouterAppId, () -> cleanUp());
+
+ log.info("Started");
+ }
+
+ @Deactivate
+ protected void deactivate() {
+ // FIXME: This will also remove flows when an instance goes down.
+ // This is a temporary solution and should be addressed in CORD-710.
+ cleanUp();
+
+ asyncDeviceFetcher.shutdown();
+ networkConfigService.removeListener(configListener);
+
+ componentConfigService.unregisterProperties(getClass(), false);
+
+ log.info("Stopped");
+ }
+
+ @Modified
+ protected void modified(ComponentContext context) {
+ Dictionary<?, ?> properties = context.getProperties();
+ if (properties == null) {
+ return;
+ }
+
+ String strRouteToNextHop = Tools.get(properties, "routeToNextHop");
+ routeToNextHop = Boolean.parseBoolean(strRouteToNextHop);
+
+ log.info("routeToNextHop set to {}", routeToNextHop);
+ }
+
+ private void processRouterConfig() {
+ RouterConfig routerConfig =
+ networkConfigService.getConfig(routerAppId, RoutingService.ROUTER_CONFIG_CLASS);
+
+ if (routerConfig == null) {
+ log.info("Router config not available");
+ return;
+ }
+
+ Set<String> interfaces = Sets.newHashSet(routerConfig.getInterfaces());
+
+ if (deviceId == null) {
+ controlPlaneConnectPoint = routerConfig.getControlPlaneConnectPoint();
+ log.info("Control Plane Connect Point: {}", controlPlaneConnectPoint);
+
+ deviceId = routerConfig.getControlPlaneConnectPoint().deviceId();
+ log.info("Router device ID is {}", deviceId);
+
+ routeService.addListener(routeListener);
+ asyncDeviceFetcher.getDevice(deviceId).whenComplete((deviceId, e) ->
+ interfaceManager = createRouter(deviceId, interfaces));
+ } else {
+ interfaceManager.changeConfiguredInterfaces(interfaces);
+ }
+ }
+
+ /*
+ * Removes filtering objectives and routes before deactivate.
+ */
+ private void cleanUp() {
+ //remove the route listener
+ routeService.removeListener(routeListener);
+
+ //clean up the routes.
+ for (Map.Entry<IpPrefix, IpAddress> routes: prefixToNextHop.entrySet()) {
+ deleteRoute(new ResolvedRoute(routes.getKey(), null, null, null));
+ }
+
+ if (interfaceManager != null) {
+ interfaceManager.cleanup();
+ }
+ }
+
+ private RouterInterfaceManager createRouter(DeviceId deviceId, Set<String> configuredInterfaces) {
+ return new RouterInterfaceManager(deviceId,
+ configuredInterfaces,
+ interfaceService,
+ this::provisionInterface,
+ this::unprovisionInterface);
+ }
+
+ private void updateRoute(ResolvedRoute route) {
+ addNextHop(route);
+
+ Integer nextId;
+ synchronized (this) {
+ nextId = nextHops.get(route.nextHop());
+ }
+
+ flowObjectiveService.forward(deviceId,
+ generateRibForwardingObj(route.prefix(), nextId).add());
+ log.trace("Sending forwarding objective {} -> nextId:{}", route, nextId);
+ }
+
+ private synchronized void deleteRoute(ResolvedRoute route) {
+ //Integer nextId = nextHops.get(route.nextHop());
+
+ /* Group group = deleteNextHop(route.prefix());
+ if (group == null) {
+ log.warn("Group not found when deleting {}", route);
+ return;
+ }*/
+
+ flowObjectiveService.forward(deviceId,
+ generateRibForwardingObj(route.prefix(), null).remove());
+ }
+
+ private ForwardingObjective.Builder generateRibForwardingObj(IpPrefix prefix,
+ Integer nextId) {
+ TrafficSelector selector = buildIpSelectorFromIpPrefix(prefix).build();
+ int priority = prefix.prefixLength() * PRIORITY_MULTIPLIER + PRIORITY_OFFSET;
+
+ ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective.builder()
+ .fromApp(routerAppId)
+ .makePermanent()
+ .withSelector(selector)
+ .withPriority(priority)
+ .withFlag(ForwardingObjective.Flag.SPECIFIC);
+
+ if (nextId == null) {
+ // Route withdraws are not specified with next hops. Generating
+ // dummy treatment as there is no equivalent nextId info.
+ fwdBuilder.withTreatment(DefaultTrafficTreatment.builder().build());
+ } else {
+ fwdBuilder.nextStep(nextId);
+ }
+ return fwdBuilder;
+ }
+
+ /**
+ * Method to build IPv4 or IPv6 selector.
+ *
+ * @param prefixToMatch the prefix to match
+ * @return the traffic selector builder
+ */
+ private TrafficSelector.Builder buildIpSelectorFromIpPrefix(IpPrefix prefixToMatch) {
+ TrafficSelector.Builder selectorBuilder = DefaultTrafficSelector.builder();
+ // If the prefix is IPv4
+ if (prefixToMatch.isIp4()) {
+ selectorBuilder.matchEthType(Ethernet.TYPE_IPV4);
+ selectorBuilder.matchIPDst(prefixToMatch);
+ return selectorBuilder;
+ }
+ // If the prefix is IPv6
+ selectorBuilder.matchEthType(Ethernet.TYPE_IPV6);
+ selectorBuilder.matchIPv6Dst(prefixToMatch);
+ return selectorBuilder;
+ }
+
+ private synchronized void addNextHop(ResolvedRoute route) {
+ prefixToNextHop.put(route.prefix(), route.nextHop());
+ if (nextHopsCount.count(route.nextHop()) == 0) {
+ // There was no next hop in the multiset
+ Interface egressIntf = interfaceService.getMatchingInterface(route.nextHop());
+ if (egressIntf == null) {
+ log.warn("no egress interface found for {}", route);
+ return;
+ }
+
+ NextHopGroupKey groupKey = new NextHopGroupKey(route.nextHop());
+
+ NextHop nextHop = new NextHop(route.nextHop(), route.nextHopMac(), groupKey);
+
+ TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder()
+ .setEthSrc(egressIntf.mac())
+ .setEthDst(nextHop.mac());
+
+ TrafficSelector.Builder metabuilder = null;
+ if (!egressIntf.vlan().equals(VlanId.NONE)) {
+ treatment.pushVlan()
+ .setVlanId(egressIntf.vlan())
+ .setVlanPcp((byte) 0);
+ } else {
+ // untagged outgoing port may require internal vlan in some pipelines
+ metabuilder = DefaultTrafficSelector.builder();
+ metabuilder.matchVlanId(VlanId.vlanId(ASSIGNED_VLAN));
+ }
+
+ treatment.setOutput(egressIntf.connectPoint().port());
+
+ int nextId = flowObjectiveService.allocateNextId();
+ NextObjective.Builder nextBuilder = DefaultNextObjective.builder()
+ .withId(nextId)
+ .addTreatment(treatment.build())
+ .withType(NextObjective.Type.SIMPLE)
+ .fromApp(routerAppId);
+ if (metabuilder != null) {
+ nextBuilder.withMeta(metabuilder.build());
+ }
+
+ NextObjective nextObjective = nextBuilder.add(); // TODO add callbacks
+ flowObjectiveService.next(deviceId, nextObjective);
+
+ nextHops.put(nextHop.ip(), nextId);
+
+ if (routeToNextHop) {
+ // Install route to next hop
+ ForwardingObjective fob =
+ generateRibForwardingObj(IpPrefix.valueOf(route.nextHop(), 32), nextId).add();
+ flowObjectiveService.forward(deviceId, fob);
+ }
+ }
+
+ nextHopsCount.add(route.nextHop());
+ }
+
+ /*private synchronized Group deleteNextHop(IpPrefix prefix) {
+ IpAddress nextHopIp = prefixToNextHop.remove(prefix);
+ NextHop nextHop = nextHops.get(nextHopIp);
+ if (nextHop == null) {
+ log.warn("No next hop found when removing prefix {}", prefix);
+ return null;
+ }
+
+ Group group = groupService.getGroup(deviceId,
+ new DefaultGroupKey(appKryo.
+ serialize(nextHop.group())));
+
+ // FIXME disabling group deletes for now until we verify the logic is OK
+ if (nextHopsCount.remove(nextHopIp, 1) <= 1) {
+ // There was one or less next hops, so there are now none
+
+ log.debug("removing group for next hop {}", nextHop);
+
+ nextHops.remove(nextHopIp);
+
+ groupService.removeGroup(deviceId,
+ new DefaultGroupKey(appKryo.build().serialize(nextHop.group())),
+ appId);
+ }
+
+ return group;
+ }*/
+
+ private void provisionInterface(Interface intf) {
+ updateInterfaceFilters(intf, true);
+ }
+
+ private void unprovisionInterface(Interface intf) {
+ updateInterfaceFilters(intf, false);
+ }
+
+ /**
+ * Installs or removes flow objectives relating to an interface.
+ *
+ * @param intf interface to update objectives for
+ * @param install true to install the objectives, false to remove them
+ */
+ private void updateInterfaceFilters(Interface intf, boolean install) {
+ updateFilteringObjective(intf, install);
+ updateMcastFilteringObjective(intf, install);
+ }
+
+ /**
+ * Installs or removes unicast filtering objectives relating to an interface.
+ *
+ * @param intf interface to update objectives for
+ * @param install true to install the objectives, false to remove them
+ */
+ private void updateFilteringObjective(Interface intf, boolean install) {
+ VlanId assignedVlan = (egressVlan().equals(VlanId.NONE)) ?
+ VlanId.vlanId(ASSIGNED_VLAN) :
+ egressVlan();
+
+ FilteringObjective.Builder fob = DefaultFilteringObjective.builder();
+ // first add filter for the interface
+ fob.withKey(Criteria.matchInPort(intf.connectPoint().port()))
+ .addCondition(Criteria.matchEthDst(intf.mac()))
+ .addCondition(Criteria.matchVlanId(intf.vlan()));
+ fob.withPriority(PRIORITY_OFFSET);
+ if (intf.vlan() == VlanId.NONE) {
+ TrafficTreatment tt = DefaultTrafficTreatment.builder()
+ .pushVlan().setVlanId(assignedVlan).build();
+ fob.withMeta(tt);
+ }
+ fob.permit().fromApp(routerAppId);
+ sendFilteringObjective(install, fob, intf);
+
+ if (controlPlaneConnectPoint != null) {
+ // then add the same mac/vlan filters for control-plane connect point
+ fob.withKey(Criteria.matchInPort(controlPlaneConnectPoint.port()));
+ sendFilteringObjective(install, fob, intf);
+ }
+ }
+
+ /**
+ * Installs or removes multicast filtering objectives relating to an interface.
+ *
+ * @param intf interface to update objectives for
+ * @param install true to install the objectives, false to remove them
+ */
+ private void updateMcastFilteringObjective(Interface intf, boolean install) {
+ VlanId assignedVlan = (egressVlan().equals(VlanId.NONE)) ?
+ VlanId.vlanId(ASSIGNED_VLAN) :
+ egressVlan();
+
+ FilteringObjective.Builder fob = DefaultFilteringObjective.builder();
+ // first add filter for the interface
+ fob.withKey(Criteria.matchInPort(intf.connectPoint().port()))
+ .addCondition(Criteria.matchEthDstMasked(MacAddress.IPV4_MULTICAST,
+ MacAddress.IPV4_MULTICAST_MASK))
+ .addCondition(Criteria.matchVlanId(ingressVlan()));
+ fob.withPriority(PRIORITY_OFFSET);
+ TrafficTreatment tt = DefaultTrafficTreatment.builder()
+ .pushVlan().setVlanId(assignedVlan).build();
+ fob.withMeta(tt);
+
+ fob.permit().fromApp(routerAppId);
+ sendFilteringObjective(install, fob, intf);
+ }
+
+ private void sendFilteringObjective(boolean install, FilteringObjective.Builder fob,
+ Interface intf) {
+
+ ObjectiveContext context = new DefaultObjectiveContext(
+ (objective) -> log.info("Installed filter for interface {}", intf),
+ (objective, error) ->
+ log.error("Failed to install filter for interface {}: {}", intf, error));
+
+ FilteringObjective filter = install ? fob.add(context) : fob.remove(context);
+
+ flowObjectiveService.filter(deviceId, filter);
+ }
+
+ private VlanId ingressVlan() {
+ McastConfig mcastConfig =
+ networkConfigService.getConfig(coreAppId, McastConfig.class);
+ return (mcastConfig != null) ? mcastConfig.ingressVlan() : VlanId.NONE;
+ }
+
+ private VlanId egressVlan() {
+ McastConfig mcastConfig =
+ networkConfigService.getConfig(coreAppId, McastConfig.class);
+ return (mcastConfig != null) ? mcastConfig.egressVlan() : VlanId.NONE;
+ }
+
+ /**
+ * Listener for route changes.
+ */
+ private class InternalRouteListener implements RouteListener {
+ @Override
+ public void event(RouteEvent event) {
+ ResolvedRoute route = event.subject();
+ switch (event.type()) {
+ case ROUTE_ADDED:
+ case ROUTE_UPDATED:
+ updateRoute(route);
+ break;
+ case ROUTE_REMOVED:
+ deleteRoute(route);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ /**
+ * Listener for network config events.
+ */
+ private class InternalNetworkConfigListener implements NetworkConfigListener {
+ @Override
+ public void event(NetworkConfigEvent event) {
+ if (event.configClass().equals(RoutingService.ROUTER_CONFIG_CLASS)) {
+ switch (event.type()) {
+ case CONFIG_ADDED:
+ case CONFIG_UPDATED:
+ processRouterConfig();
+ break;
+ case CONFIG_REGISTERED:
+ break;
+ case CONFIG_UNREGISTERED:
+ break;
+ case CONFIG_REMOVED:
+ cleanUp();
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+}
diff --git a/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/package-info.java b/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/package-info.java
new file mode 100644
index 0000000..669754d
--- /dev/null
+++ b/apps/routing/fibinstaller/src/main/java/org/onosproject/routing/fibinstaller/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2017-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Single switch FIB installer.
+ */
+package org.onosproject.routing.fibinstaller;
diff --git a/apps/routing/fibinstaller/src/test/java/org/onosproject/routing/fibinstaller/SingleSwitchFibInstallerTest.java b/apps/routing/fibinstaller/src/test/java/org/onosproject/routing/fibinstaller/SingleSwitchFibInstallerTest.java
new file mode 100644
index 0000000..f7736f7
--- /dev/null
+++ b/apps/routing/fibinstaller/src/test/java/org/onosproject/routing/fibinstaller/SingleSwitchFibInstallerTest.java
@@ -0,0 +1,431 @@
+/*
+ * Copyright 2017-present Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.routing.fibinstaller;
+
+import com.google.common.collect.Sets;
+import org.easymock.EasyMock;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.packet.Ethernet;
+import org.onlab.packet.Ip4Prefix;
+import org.onlab.packet.IpAddress;
+import org.onlab.packet.IpPrefix;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onosproject.TestApplicationId;
+import org.onosproject.app.ApplicationService;
+import org.onosproject.cfg.ComponentConfigService;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceListener;
+import org.onosproject.incubator.net.intf.InterfaceService;
+import org.onosproject.incubator.net.intf.InterfaceServiceAdapter;
+import org.onosproject.incubator.net.routing.ResolvedRoute;
+import org.onosproject.incubator.net.routing.RouteEvent;
+import org.onosproject.incubator.net.routing.RouteListener;
+import org.onosproject.incubator.net.routing.RouteServiceAdapter;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.config.NetworkConfigListener;
+import org.onosproject.net.config.NetworkConfigRegistry;
+import org.onosproject.net.config.NetworkConfigService;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.device.DeviceServiceAdapter;
+import org.onosproject.net.flow.DefaultTrafficSelector;
+import org.onosproject.net.flow.DefaultTrafficTreatment;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flowobjective.DefaultForwardingObjective;
+import org.onosproject.net.flowobjective.DefaultNextObjective;
+import org.onosproject.net.flowobjective.FlowObjectiveService;
+import org.onosproject.net.flowobjective.ForwardingObjective;
+import org.onosproject.net.flowobjective.NextObjective;
+import org.onosproject.net.host.InterfaceIpAddress;
+import org.onosproject.routing.RoutingService;
+import org.onosproject.routing.config.RouterConfig;
+import org.osgi.service.component.ComponentContext;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.anyString;
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.createNiceMock;
+import static org.easymock.EasyMock.eq;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.expectLastCall;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.reset;
+import static org.easymock.EasyMock.verify;
+
+/**
+ * Unit tests for SingleSwitchFibInstaller.
+ */
+public class SingleSwitchFibInstallerTest {
+
+ private static final DeviceId DEVICE_ID = DeviceId.deviceId("of:0000000000000001");
+
+ private static final ConnectPoint SW1_ETH1 = new ConnectPoint(
+ DEVICE_ID, PortNumber.portNumber(1));
+
+ private static final ConnectPoint SW1_ETH2 = new ConnectPoint(
+ DEVICE_ID, PortNumber.portNumber(2));
+
+ private static final int NEXT_ID = 11;
+
+ private static final VlanId VLAN1 = VlanId.vlanId((short) 1);
+ private static final MacAddress MAC1 = MacAddress.valueOf("00:00:00:00:00:01");
+ private static final MacAddress MAC2 = MacAddress.valueOf("00:00:00:00:00:02");
+
+ private static final IpPrefix PREFIX1 = Ip4Prefix.valueOf("1.1.1.0/24");
+ private static final IpAddress NEXT_HOP1 = IpAddress.valueOf("192.168.10.1");
+ private static final IpAddress NEXT_HOP2 = IpAddress.valueOf("192.168.20.1");
+ private static final InterfaceIpAddress INTF1 =
+ InterfaceIpAddress.valueOf("192.168.10.2/24");
+ private static final InterfaceIpAddress INTF2 =
+ InterfaceIpAddress.valueOf("192.168.20.2/24");
+
+ private final Set<Interface> interfaces = Sets.newHashSet();
+ private InterfaceService interfaceService;
+ private NetworkConfigService networkConfigService;
+ private NetworkConfigRegistry networkConfigRegistry;
+ private FlowObjectiveService flowObjectiveService;
+ private ApplicationService applicationService;
+ private DeviceService deviceService;
+ private static final ApplicationId APPID = TestApplicationId.create("foo");
+
+ private RouteListener routeListener;
+ private DeviceListener deviceListener;
+
+ private RouterConfig routerConfig;
+ private SingleSwitchFibInstaller sSfibInstaller;
+ private InterfaceListener interfaceListener;
+
+ @Before
+ public void setUp() throws Exception {
+ sSfibInstaller = new SingleSwitchFibInstaller();
+
+ sSfibInstaller.componentConfigService = createNiceMock(ComponentConfigService.class);
+
+ ComponentContext mockContext = createNiceMock(ComponentContext.class);
+
+ routerConfig = new TestRouterConfig();
+ interfaceService = createMock(InterfaceService.class);
+
+ networkConfigService = createMock(NetworkConfigService.class);
+ networkConfigService.addListener(anyObject(NetworkConfigListener.class));
+ expectLastCall().anyTimes();
+ networkConfigRegistry = createMock(NetworkConfigRegistry.class);
+ flowObjectiveService = createMock(FlowObjectiveService.class);
+ applicationService = createNiceMock(ApplicationService.class);
+ replay(applicationService);
+ deviceService = new TestDeviceService();
+ CoreService coreService = createNiceMock(CoreService.class);
+ expect(coreService.registerApplication(anyString())).andReturn(APPID).anyTimes();
+ replay(coreService);
+
+ sSfibInstaller.networkConfigService = networkConfigService;
+ sSfibInstaller.networkConfigRegistry = networkConfigRegistry;
+ sSfibInstaller.interfaceService = interfaceService;
+ sSfibInstaller.flowObjectiveService = flowObjectiveService;
+ sSfibInstaller.applicationService = applicationService;
+ sSfibInstaller.coreService = coreService;
+ sSfibInstaller.routeService = new TestRouteService();
+ sSfibInstaller.deviceService = deviceService;
+
+ setUpNetworkConfigService();
+ setUpInterfaceService();
+ sSfibInstaller.activate(mockContext);
+ }
+
+ /**
+ * Sets up InterfaceService.
+ */
+ private void setUpInterfaceService() {
+ interfaceService.addListener(anyObject(InterfaceListener.class));
+ expectLastCall().andDelegateTo(new TestInterfaceService());
+
+ // Interface with no VLAN
+ Interface sw1Eth1 = new Interface("intf1", SW1_ETH1,
+ Collections.singletonList(INTF1), MAC1, VlanId.NONE);
+ expect(interfaceService.getMatchingInterface(NEXT_HOP1)).andReturn(sw1Eth1);
+ interfaces.add(sw1Eth1);
+
+ // Interface with a VLAN
+ Interface sw2Eth1 = new Interface("intf2", SW1_ETH2,
+ Collections.singletonList(INTF2), MAC2, VLAN1);
+ expect(interfaceService.getMatchingInterface(NEXT_HOP2)).andReturn(sw2Eth1);
+ interfaces.add(sw2Eth1);
+
+ expect(interfaceService.getInterfaces()).andReturn(interfaces);
+
+ replay(interfaceService);
+ }
+
+ /*
+ * Sets up NetworkConfigService.
+ */
+ private void setUpNetworkConfigService() {
+ expect(networkConfigService.getConfig(
+ anyObject(ApplicationId.class), eq(RoutingService.ROUTER_CONFIG_CLASS))).
+ andReturn(routerConfig);
+ replay(networkConfigService);
+ }
+
+ /**
+ * Sets up FlowObjectiveService.
+ */
+ private void setUpFlowObjectiveService() {
+ expect(flowObjectiveService.allocateNextId()).andReturn(NEXT_ID);
+ replay(flowObjectiveService);
+ }
+
+ /**
+ * Creates a next objective with the given parameters.
+ *
+ * @param srcMac source MAC address
+ * @param dstMac destination MAC address
+ * @param port port number
+ * @param vlan vlan ID
+ * @param add whether to create an add objective or remove objective
+ * @return new next objective
+ */
+ private NextObjective createNextObjective(MacAddress srcMac,
+ MacAddress dstMac,
+ PortNumber port,
+ VlanId vlan,
+ boolean add) {
+ TrafficTreatment.Builder treatment = DefaultTrafficTreatment.builder()
+ .setEthSrc(srcMac)
+ .setEthDst(dstMac);
+ TrafficSelector.Builder metabuilder = null;
+ if (!vlan.equals(VlanId.NONE)) {
+ treatment.pushVlan()
+ .setVlanId(vlan)
+ .setVlanPcp((byte) 0);
+ } else {
+ metabuilder = DefaultTrafficSelector.builder();
+ metabuilder.matchVlanId(VlanId.vlanId(SingleSwitchFibInstaller.ASSIGNED_VLAN));
+ }
+
+ treatment.setOutput(port);
+ NextObjective.Builder nextBuilder = DefaultNextObjective.builder()
+ .withId(NEXT_ID)
+ .addTreatment(treatment.build())
+ .withType(NextObjective.Type.SIMPLE)
+ .fromApp(APPID);
+ if (metabuilder != null) {
+ nextBuilder.withMeta(metabuilder.build());
+ }
+
+ return add ? nextBuilder.add() : nextBuilder.remove();
+ }
+
+ /**
+ * Creates a new forwarding objective with the given parameters.
+ *
+ * @param prefix IP prefix
+ * @param add whether to create an add objective or a remove objective
+ * @return new forwarding objective
+ */
+ private ForwardingObjective createForwardingObjective(IpPrefix prefix,
+ boolean add) {
+ TrafficSelector selector = DefaultTrafficSelector.builder()
+ .matchEthType(Ethernet.TYPE_IPV4)
+ .matchIPDst(prefix)
+ .build();
+
+ int priority = prefix.prefixLength() * 5 + 100;
+ ForwardingObjective.Builder fwdBuilder = DefaultForwardingObjective.builder()
+ .fromApp(APPID)
+ .makePermanent()
+ .withSelector(selector)
+ .withPriority(priority)
+ .withFlag(ForwardingObjective.Flag.SPECIFIC);
+
+ if (add) {
+ fwdBuilder.nextStep(NEXT_ID);
+ } else {
+ fwdBuilder.withTreatment(DefaultTrafficTreatment.builder().build());
+ }
+
+ return add ? fwdBuilder.add() : fwdBuilder.remove();
+ }
+
+ /**
+ * Tests adding a route.
+ *
+ * We verify that the flowObjectiveService records the correct state and that the
+ * correct flow is submitted to the flowObjectiveService.
+ */
+ @Test
+ public void testRouteAdd() {
+ ResolvedRoute resolvedRoute = new ResolvedRoute(PREFIX1, NEXT_HOP1, MAC1, SW1_ETH1);
+
+ // Create the next objective
+ NextObjective nextObjective = createNextObjective(MAC1, MAC1, SW1_ETH1.port(), VlanId.NONE, true);
+ flowObjectiveService.next(DEVICE_ID, nextObjective);
+
+ // Create the flow objective
+ ForwardingObjective fwd = createForwardingObjective(PREFIX1, true);
+ flowObjectiveService.forward(DEVICE_ID, fwd);
+ EasyMock.expectLastCall().once();
+ setUpFlowObjectiveService();
+
+ // Send in the add event
+ RouteEvent routeEvent = new RouteEvent(RouteEvent.Type.ROUTE_ADDED, resolvedRoute);
+ routeListener.event(routeEvent);
+ verify(flowObjectiveService);
+ }
+
+ /**
+ * Tests adding a route with to a next hop in a VLAN.
+ *
+ * We verify that the flowObjectiveService records the correct state and that the
+ * correct flowObjectiveService is submitted to the flowObjectiveService.
+ */
+ @Test
+ public void testRouteAddWithVlan() {
+ ResolvedRoute route = new ResolvedRoute(PREFIX1, NEXT_HOP2, MAC2, SW1_ETH2);
+
+ // Create the next objective
+ NextObjective nextObjective = createNextObjective(MAC2, MAC2, SW1_ETH2.port(), VLAN1, true);
+ flowObjectiveService.next(DEVICE_ID, nextObjective);
+
+ // Create the flow objective
+ ForwardingObjective fwd = createForwardingObjective(PREFIX1, true);
+ flowObjectiveService.forward(DEVICE_ID, fwd);
+ EasyMock.expectLastCall().once();
+ setUpFlowObjectiveService();
+
+ // Send in the add event
+ routeListener.event(new RouteEvent(RouteEvent.Type.ROUTE_ADDED, route));
+
+ verify(flowObjectiveService);
+ }
+
+ /**
+ * Tests updating a route.
+ *
+ * We verify that the flowObjectiveService records the correct state and that the
+ * correct flow is submitted to the flowObjectiveService.
+ */
+ @Test
+ public void testRouteUpdate() {
+ // Firstly add a route
+ testRouteAdd();
+ reset(flowObjectiveService);
+
+ ResolvedRoute oldRoute = new ResolvedRoute(PREFIX1, NEXT_HOP1, MAC1, SW1_ETH1);
+ ResolvedRoute route = new ResolvedRoute(PREFIX1, NEXT_HOP2, MAC2, SW1_ETH2);
+
+ // Create the next objective
+ NextObjective nextObjective = createNextObjective(MAC2, MAC2, SW1_ETH2.port(), VLAN1, true);
+ flowObjectiveService.next(DEVICE_ID, nextObjective);
+
+ // Create the flow objective
+ ForwardingObjective fwd = createForwardingObjective(PREFIX1, true);
+ flowObjectiveService.forward(DEVICE_ID, fwd);
+ EasyMock.expectLastCall().once();
+ setUpFlowObjectiveService();
+
+ // Send in the update event
+ routeListener.event(new RouteEvent(RouteEvent.Type.ROUTE_UPDATED, route, oldRoute));
+
+ verify(flowObjectiveService);
+ }
+
+ /**
+ * Tests deleting a route.
+ *
+ * We verify that the flowObjectiveService records the correct state and that the
+ * correct flow is withdrawn from the flowObjectiveService.
+ */
+ @Test
+ public void testRouteDelete() {
+ // Firstly add a route
+ testRouteAdd();
+
+ // Construct the existing route
+ ResolvedRoute route = new ResolvedRoute(PREFIX1, NEXT_HOP1, MAC1, SW1_ETH1);
+
+ // Create the flow objective
+ reset(flowObjectiveService);
+ ForwardingObjective fwd = createForwardingObjective(PREFIX1, false);
+ flowObjectiveService.forward(DEVICE_ID, fwd);
+ replay(flowObjectiveService);
+
+ // Send in the delete event
+ routeListener.event(new RouteEvent(RouteEvent.Type.ROUTE_REMOVED, route));
+
+ verify(flowObjectiveService);
+ }
+
+ private class TestInterfaceService extends InterfaceServiceAdapter {
+ @Override
+ public void addListener(InterfaceListener listener) {
+ interfaceListener = listener;
+ }
+ }
+
+ private class TestRouteService extends RouteServiceAdapter {
+ @Override
+ public void addListener(RouteListener listener) {
+ SingleSwitchFibInstallerTest.this.routeListener = listener;
+ }
+ }
+
+ private class TestRouterConfig extends RouterConfig {
+
+ @Override
+ public List<String> getInterfaces() {
+ ArrayList<String> interfaces = new ArrayList<>();
+ interfaces.add("of:0000000000000001/1");
+ interfaces.add("of:0000000000000001/2");
+ return interfaces;
+ }
+
+ @Override
+ public ConnectPoint getControlPlaneConnectPoint() {
+ return SW1_ETH1;
+ }
+
+ @Override
+ public boolean getOspfEnabled() {
+ return true;
+ }
+ }
+
+ private class TestDeviceService extends DeviceServiceAdapter {
+
+ @Override
+ public boolean isAvailable(DeviceId deviceId) {
+ return true;
+ }
+
+ @Override
+ public void addListener(DeviceListener listener) {
+ SingleSwitchFibInstallerTest.this.deviceListener = listener;
+ }
+ }
+}