blob: 6d5d0b27987b3a18926b654c3e2476c0e125d74a [file] [log] [blame]
sangho80f11cb2015-04-01 13:05:26 -07001/*
Brian O'Connor0947d7e2017-08-03 21:12:30 -07002 * Copyright 2015-present Open Networking Foundation
sangho80f11cb2015-04-01 13:05:26 -07003 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package org.onosproject.segmentrouting;
17
Andreas Pantelopoulosafc637f2017-12-20 18:04:27 -080018import com.fasterxml.jackson.databind.ObjectMapper;
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -070019import com.fasterxml.jackson.databind.node.ObjectNode;
Jonathan Hart61e24e12017-11-30 18:23:42 -080020import com.google.common.collect.HashMultimap;
21import com.google.common.collect.ImmutableMap;
22import com.google.common.collect.Maps;
23import com.google.common.collect.Multimap;
Charles Chanf0ae41e2017-08-23 13:55:39 -070024import com.google.common.collect.Sets;
sangho80f11cb2015-04-01 13:05:26 -070025import org.apache.felix.scr.annotations.Activate;
26import org.apache.felix.scr.annotations.Component;
27import org.apache.felix.scr.annotations.Deactivate;
Charles Chan873661e2017-11-30 15:37:50 -080028import org.apache.felix.scr.annotations.Modified;
29import org.apache.felix.scr.annotations.Property;
sangho80f11cb2015-04-01 13:05:26 -070030import org.apache.felix.scr.annotations.Reference;
31import org.apache.felix.scr.annotations.ReferenceCardinality;
sangho27462c62015-05-14 00:39:53 -070032import org.apache.felix.scr.annotations.Service;
sangho80f11cb2015-04-01 13:05:26 -070033import org.onlab.packet.Ethernet;
Pier Ventreb6b81d52016-12-02 08:16:05 -080034import org.onlab.packet.ICMP6;
Charles Chan77277672015-10-20 16:24:19 -070035import org.onlab.packet.IPv4;
Pier Ventreb6a7f342016-11-26 21:05:22 -080036import org.onlab.packet.IPv6;
Jonghwan Hyune5ef7622017-08-25 17:48:36 -070037import org.onlab.packet.IpAddress;
Charles Chan77277672015-10-20 16:24:19 -070038import org.onlab.packet.IpPrefix;
Jonathan Hart54541d12016-04-12 15:39:44 -070039import org.onlab.packet.VlanId;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -070040import org.onlab.util.KryoNamespace;
Charles Chan873661e2017-11-30 15:37:50 -080041import org.onlab.util.Tools;
Saurav Dasc3604f12016-03-23 11:22:49 -070042import org.onosproject.cfg.ComponentConfigService;
sangho80f11cb2015-04-01 13:05:26 -070043import org.onosproject.core.ApplicationId;
44import org.onosproject.core.CoreService;
45import org.onosproject.event.Event;
Jonathan Hart54541d12016-04-12 15:39:44 -070046import org.onosproject.mastership.MastershipService;
Pier Ventreb6a7f342016-11-26 21:05:22 -080047import org.onosproject.net.ConnectPoint;
Jonathan Hart54541d12016-04-12 15:39:44 -070048import org.onosproject.net.Device;
49import org.onosproject.net.DeviceId;
Charles Chanf0ae41e2017-08-23 13:55:39 -070050import org.onosproject.net.Host;
51import org.onosproject.net.HostId;
Jonathan Hart54541d12016-04-12 15:39:44 -070052import org.onosproject.net.Link;
53import org.onosproject.net.Port;
Charles Chanf4586112015-11-09 16:37:23 -080054import org.onosproject.net.PortNumber;
Jonghwan Hyune5ef7622017-08-25 17:48:36 -070055import org.onosproject.net.config.ConfigException;
Charles Chan72f556a2015-10-05 17:50:33 -070056import org.onosproject.net.config.ConfigFactory;
57import org.onosproject.net.config.NetworkConfigEvent;
Charles Chan72f556a2015-10-05 17:50:33 -070058import org.onosproject.net.config.NetworkConfigListener;
Jonathan Hart54541d12016-04-12 15:39:44 -070059import org.onosproject.net.config.NetworkConfigRegistry;
Ray Milkeyae0068a2017-08-15 11:02:29 -070060import org.onosproject.net.config.basics.InterfaceConfig;
61import org.onosproject.net.config.basics.McastConfig;
Charles Chan72f556a2015-10-05 17:50:33 -070062import org.onosproject.net.config.basics.SubjectFactories;
Jonathan Hart54541d12016-04-12 15:39:44 -070063import org.onosproject.net.device.DeviceEvent;
64import org.onosproject.net.device.DeviceListener;
65import org.onosproject.net.device.DeviceService;
Charles Chanf4586112015-11-09 16:37:23 -080066import org.onosproject.net.flow.TrafficSelector;
67import org.onosproject.net.flow.TrafficTreatment;
Jonathan Hart54541d12016-04-12 15:39:44 -070068import org.onosproject.net.flowobjective.FlowObjectiveService;
Charles Chanf4586112015-11-09 16:37:23 -080069import org.onosproject.net.host.HostEvent;
70import org.onosproject.net.host.HostListener;
Charles Chan873661e2017-11-30 15:37:50 -080071import org.onosproject.net.host.HostLocationProbingService;
Pier Ventreb6a7f342016-11-26 21:05:22 -080072import org.onosproject.net.host.HostService;
Jonghwan Hyune5ef7622017-08-25 17:48:36 -070073import org.onosproject.net.host.InterfaceIpAddress;
Ray Milkeyae0068a2017-08-15 11:02:29 -070074import org.onosproject.net.intf.Interface;
75import org.onosproject.net.intf.InterfaceService;
Pier Ventreb6a7f342016-11-26 21:05:22 -080076import org.onosproject.net.link.LinkEvent;
77import org.onosproject.net.link.LinkListener;
78import org.onosproject.net.link.LinkService;
Charles Chanc91c8782016-03-30 17:54:24 -070079import org.onosproject.net.mcast.McastEvent;
80import org.onosproject.net.mcast.McastListener;
81import org.onosproject.net.mcast.MulticastRouteService;
Ray Milkeyae0068a2017-08-15 11:02:29 -070082import org.onosproject.net.neighbour.NeighbourResolutionService;
Pier Ventreb6a7f342016-11-26 21:05:22 -080083import org.onosproject.net.packet.InboundPacket;
84import org.onosproject.net.packet.PacketContext;
85import org.onosproject.net.packet.PacketProcessor;
86import org.onosproject.net.packet.PacketService;
Pier Ventref3cf5b92016-11-09 14:17:26 -080087import org.onosproject.net.topology.PathService;
Charles Chanc91c8782016-03-30 17:54:24 -070088import org.onosproject.net.topology.TopologyService;
Charles Chanf0ae41e2017-08-23 13:55:39 -070089import org.onosproject.routeservice.ResolvedRoute;
Ray Milkeyae0068a2017-08-15 11:02:29 -070090import org.onosproject.routeservice.RouteEvent;
91import org.onosproject.routeservice.RouteListener;
92import org.onosproject.routeservice.RouteService;
Charles Chanc91c8782016-03-30 17:54:24 -070093import org.onosproject.segmentrouting.config.DeviceConfigNotFoundException;
94import org.onosproject.segmentrouting.config.DeviceConfiguration;
Pier Ventre6b19e482016-11-07 16:21:04 -080095import org.onosproject.segmentrouting.config.PwaasConfig;
Pier Ventre6b19e482016-11-07 16:21:04 -080096import org.onosproject.segmentrouting.config.SegmentRoutingAppConfig;
Ray Milkeyae0068a2017-08-15 11:02:29 -070097import org.onosproject.segmentrouting.config.SegmentRoutingDeviceConfig;
Charles Chan82f19972016-05-17 13:13:55 -070098import org.onosproject.segmentrouting.config.XConnectConfig;
Charles Chanc91c8782016-03-30 17:54:24 -070099import org.onosproject.segmentrouting.grouphandler.DefaultGroupHandler;
Saurav Das261c3002017-06-13 15:35:54 -0700100import org.onosproject.segmentrouting.grouphandler.DestinationSet;
101import org.onosproject.segmentrouting.grouphandler.NextNeighbors;
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -0700102import org.onosproject.segmentrouting.pwaas.DefaultL2Tunnel;
103import org.onosproject.segmentrouting.pwaas.DefaultL2TunnelPolicy;
Ray Milkeyae0068a2017-08-15 11:02:29 -0700104import org.onosproject.segmentrouting.pwaas.L2TunnelHandler;
Saurav Das261c3002017-06-13 15:35:54 -0700105import org.onosproject.segmentrouting.storekey.DestinationSetNextObjectiveStoreKey;
Charles Chan1eaf4802016-04-18 13:44:03 -0700106import org.onosproject.segmentrouting.storekey.PortNextObjectiveStoreKey;
Charles Chan10b0fb72017-02-02 16:20:42 -0800107import org.onosproject.segmentrouting.storekey.VlanNextObjectiveStoreKey;
Charles Chan82f19972016-05-17 13:13:55 -0700108import org.onosproject.segmentrouting.storekey.XConnectStoreKey;
Jonathan Hart54541d12016-04-12 15:39:44 -0700109import org.onosproject.store.serializers.KryoNamespaces;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700110import org.onosproject.store.service.EventuallyConsistentMap;
111import org.onosproject.store.service.EventuallyConsistentMapBuilder;
112import org.onosproject.store.service.StorageService;
113import org.onosproject.store.service.WallClockTimestamp;
Charles Chan873661e2017-11-30 15:37:50 -0800114import org.osgi.service.component.ComponentContext;
sangho80f11cb2015-04-01 13:05:26 -0700115import org.slf4j.Logger;
116import org.slf4j.LoggerFactory;
117
Jonathan Hart61e24e12017-11-30 18:23:42 -0800118import java.util.Collections;
Charles Chan873661e2017-11-30 15:37:50 -0800119import java.util.Dictionary;
Jonathan Hart61e24e12017-11-30 18:23:42 -0800120import java.util.HashSet;
121import java.util.List;
122import java.util.Map;
123import java.util.Map.Entry;
124import java.util.Optional;
125import java.util.Set;
126import java.util.concurrent.ConcurrentHashMap;
127import java.util.concurrent.ConcurrentLinkedQueue;
128import java.util.concurrent.Executors;
129import java.util.concurrent.ScheduledExecutorService;
130import java.util.concurrent.ScheduledFuture;
131import java.util.concurrent.TimeUnit;
132import java.util.concurrent.atomic.AtomicBoolean;
133import java.util.stream.Collectors;
sangho80f11cb2015-04-01 13:05:26 -0700134
Charles Chand6d25332016-02-26 22:19:52 -0800135import static com.google.common.base.Preconditions.checkState;
Pier Ventreadb4ae62016-11-23 09:57:42 -0800136import static org.onlab.packet.Ethernet.TYPE_ARP;
Yuta HIGUCHIebee2f12016-07-21 16:54:33 -0700137import static org.onlab.util.Tools.groupedThreads;
Charles Chand6d25332016-02-26 22:19:52 -0800138
Charles Chanb7f75ac2016-01-11 18:28:54 -0800139/**
140 * Segment routing manager.
141 */
Jonathan Hart54541d12016-04-12 15:39:44 -0700142@Service
143@Component(immediate = true)
sangho27462c62015-05-14 00:39:53 -0700144public class SegmentRoutingManager implements SegmentRoutingService {
sangho80f11cb2015-04-01 13:05:26 -0700145
Charles Chan46fdfaf2016-11-09 20:51:44 -0800146 private static Logger log = LoggerFactory.getLogger(SegmentRoutingManager.class);
Charles Chan910be6a2017-08-23 14:46:43 -0700147 private static final String NOT_MASTER = "Current instance is not the master of {}. Ignore.";
sangho80f11cb2015-04-01 13:05:26 -0700148
149 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chandebfea32016-10-24 14:52:01 -0700150 private ComponentConfigService compCfgService;
sangho80f11cb2015-04-01 13:05:26 -0700151
152 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Pier Ventreb6a7f342016-11-26 21:05:22 -0800153 private NeighbourResolutionService neighbourResolutionService;
154
155 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Pier Ventref3cf5b92016-11-09 14:17:26 -0800156 public PathService pathService;
157
158 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chandebfea32016-10-24 14:52:01 -0700159 CoreService coreService;
sangho80f11cb2015-04-01 13:05:26 -0700160
161 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chandebfea32016-10-24 14:52:01 -0700162 PacketService packetService;
sangho80f11cb2015-04-01 13:05:26 -0700163
164 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chandebfea32016-10-24 14:52:01 -0700165 HostService hostService;
sangho80f11cb2015-04-01 13:05:26 -0700166
167 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chan873661e2017-11-30 15:37:50 -0800168 HostLocationProbingService probingService;
169
170 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chandebfea32016-10-24 14:52:01 -0700171 DeviceService deviceService;
sangho80f11cb2015-04-01 13:05:26 -0700172
173 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Pier Ventref3cf5b92016-11-09 14:17:26 -0800174 public FlowObjectiveService flowObjectiveService;
sangho80f11cb2015-04-01 13:05:26 -0700175
176 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chandebfea32016-10-24 14:52:01 -0700177 LinkService linkService;
sangho27462c62015-05-14 00:39:53 -0700178
Charles Chan82ab1932016-01-30 23:22:37 -0800179 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Pier Ventref3cf5b92016-11-09 14:17:26 -0800180 public MastershipService mastershipService;
Charles Chandebfea32016-10-24 14:52:01 -0700181
182 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Pier Ventref3cf5b92016-11-09 14:17:26 -0800183 public StorageService storageService;
Charles Chandebfea32016-10-24 14:52:01 -0700184
185 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
186 MulticastRouteService multicastRouteService;
187
188 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
189 TopologyService topologyService;
190
191 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chandebfea32016-10-24 14:52:01 -0700192 RouteService routeService;
Charles Chan82ab1932016-01-30 23:22:37 -0800193
194 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chan46fdfaf2016-11-09 20:51:44 -0800195 public NetworkConfigRegistry cfgService;
Charles Chan82ab1932016-01-30 23:22:37 -0800196
Saurav Dasc3604f12016-03-23 11:22:49 -0700197 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chan46fdfaf2016-11-09 20:51:44 -0800198 public InterfaceService interfaceService;
199
Charles Chan873661e2017-11-30 15:37:50 -0800200 @Property(name = "activeProbing", boolValue = true,
201 label = "Enable active probing to discover dual-homed hosts.")
202 boolean activeProbing = true;
203
Charles Chandebfea32016-10-24 14:52:01 -0700204 ArpHandler arpHandler = null;
205 IcmpHandler icmpHandler = null;
206 IpHandler ipHandler = null;
207 RoutingRulePopulator routingRulePopulator = null;
Ray Milkeyb85de082017-04-05 09:42:04 -0700208 ApplicationId appId;
209 DeviceConfiguration deviceConfiguration = null;
sangho80f11cb2015-04-01 13:05:26 -0700210
Charles Chandebfea32016-10-24 14:52:01 -0700211 DefaultRoutingHandler defaultRoutingHandler = null;
sangho27462c62015-05-14 00:39:53 -0700212 private TunnelHandler tunnelHandler = null;
213 private PolicyHandler policyHandler = null;
Charles Chan2b078ae2015-10-14 11:24:40 -0700214 private InternalPacketProcessor processor = null;
215 private InternalLinkListener linkListener = null;
216 private InternalDeviceListener deviceListener = null;
Charles Chan82f19972016-05-17 13:13:55 -0700217 private AppConfigHandler appCfgHandler = null;
Charles Chandebfea32016-10-24 14:52:01 -0700218 XConnectHandler xConnectHandler = null;
Charles Chan1eaf4802016-04-18 13:44:03 -0700219 private McastHandler mcastHandler = null;
Charles Chan3ed34d82017-06-22 18:03:14 -0700220 private HostHandler hostHandler = null;
Pier Ventreb6a7f342016-11-26 21:05:22 -0800221 private RouteHandler routeHandler = null;
Pier Ventreb6b81d52016-12-02 08:16:05 -0800222 private SegmentRoutingNeighbourDispatcher neighbourHandler = null;
Pier Ventre6b19e482016-11-07 16:21:04 -0800223 private L2TunnelHandler l2TunnelHandler = null;
sangho80f11cb2015-04-01 13:05:26 -0700224 private InternalEventHandler eventHandler = new InternalEventHandler();
Charles Chan82ab1932016-01-30 23:22:37 -0800225 private final InternalHostListener hostListener = new InternalHostListener();
Charles Chanc91c8782016-03-30 17:54:24 -0700226 private final InternalConfigListener cfgListener = new InternalConfigListener(this);
227 private final InternalMcastListener mcastListener = new InternalMcastListener();
Charles Chandebfea32016-10-24 14:52:01 -0700228 private final InternalRouteEventListener routeListener = new InternalRouteEventListener();
sangho80f11cb2015-04-01 13:05:26 -0700229
Srikanth Vavilapalli64505482015-04-21 13:04:13 -0700230 private ScheduledExecutorService executorService = Executors
Yuta HIGUCHIebee2f12016-07-21 16:54:33 -0700231 .newScheduledThreadPool(1, groupedThreads("SegmentRoutingManager", "event-%d", log));
sangho80f11cb2015-04-01 13:05:26 -0700232
Saurav Das2d94d312015-11-24 23:21:05 -0800233 @SuppressWarnings("unused")
sangho80f11cb2015-04-01 13:05:26 -0700234 private static ScheduledFuture<?> eventHandlerFuture = null;
Saurav Das2d94d312015-11-24 23:21:05 -0800235 @SuppressWarnings("rawtypes")
Yuta HIGUCHIebee2f12016-07-21 16:54:33 -0700236 private ConcurrentLinkedQueue<Event> eventQueue = new ConcurrentLinkedQueue<>();
Charles Chanf4586112015-11-09 16:37:23 -0800237 private Map<DeviceId, DefaultGroupHandler> groupHandlerMap =
Charles Chanb7f75ac2016-01-11 18:28:54 -0800238 new ConcurrentHashMap<>();
239 /**
Saurav Das261c3002017-06-13 15:35:54 -0700240 * Per device next objective ID store with (device id + destination set) as key.
Charles Chan53de91f2017-08-22 15:07:34 -0700241 * Used to keep track on MPLS group information.
Charles Chanb7f75ac2016-01-11 18:28:54 -0800242 */
Charles Chan873661e2017-11-30 15:37:50 -0800243 private EventuallyConsistentMap<DestinationSetNextObjectiveStoreKey, NextNeighbors>
Saurav Das261c3002017-06-13 15:35:54 -0700244 dsNextObjStore = null;
Charles Chanb7f75ac2016-01-11 18:28:54 -0800245 /**
Charles Chan53de91f2017-08-22 15:07:34 -0700246 * Per device next objective ID store with (device id + vlanid) as key.
247 * Used to keep track on L2 flood group information.
Charles Chanb7f75ac2016-01-11 18:28:54 -0800248 */
Charles Chan873661e2017-11-30 15:37:50 -0800249 private EventuallyConsistentMap<VlanNextObjectiveStoreKey, Integer>
Charles Chan10b0fb72017-02-02 16:20:42 -0800250 vlanNextObjStore = null;
Charles Chanb7f75ac2016-01-11 18:28:54 -0800251 /**
Charles Chan53de91f2017-08-22 15:07:34 -0700252 * Per device next objective ID store with (device id + port + treatment + meta) as key.
253 * Used to keep track on L2 interface group and L3 unicast group information.
Charles Chanb7f75ac2016-01-11 18:28:54 -0800254 */
Charles Chan873661e2017-11-30 15:37:50 -0800255 private EventuallyConsistentMap<PortNextObjectiveStoreKey, Integer>
Saurav Das2d94d312015-11-24 23:21:05 -0800256 portNextObjStore = null;
Charles Chan10b0fb72017-02-02 16:20:42 -0800257
Saurav Das62ae6792017-05-15 15:34:25 -0700258 // Local store for all links seen and their present status, used for
259 // optimized routing. The existence of the link in the keys is enough to know
260 // if the link has been "seen-before" by this instance of the controller.
261 // The boolean value indicates if the link is currently up or not.
262 // XXX Currently the optimized routing logic depends on "forgetting" a link
263 // when a switch goes down, but "remembering" it when only the link goes down.
264 // Consider changing this logic so we can use the Link Service instead of
265 // a local cache.
266 private Map<Link, Boolean> seenLinks = new ConcurrentHashMap<>();
267
Saurav Das2d94d312015-11-24 23:21:05 -0800268 private EventuallyConsistentMap<String, Tunnel> tunnelStore = null;
269 private EventuallyConsistentMap<String, Policy> policyStore = null;
sangho4a5c42a2015-05-20 22:16:38 -0700270
Saurav Das261c3002017-06-13 15:35:54 -0700271 private AtomicBoolean programmingScheduled = new AtomicBoolean();
272
Charles Chanc91c8782016-03-30 17:54:24 -0700273 private final ConfigFactory<DeviceId, SegmentRoutingDeviceConfig> deviceConfigFactory =
Charles Chan82f19972016-05-17 13:13:55 -0700274 new ConfigFactory<DeviceId, SegmentRoutingDeviceConfig>(
275 SubjectFactories.DEVICE_SUBJECT_FACTORY,
Charles Chanc91c8782016-03-30 17:54:24 -0700276 SegmentRoutingDeviceConfig.class, "segmentrouting") {
Charles Chan72f556a2015-10-05 17:50:33 -0700277 @Override
Charles Chan82ab1932016-01-30 23:22:37 -0800278 public SegmentRoutingDeviceConfig createConfig() {
279 return new SegmentRoutingDeviceConfig();
Charles Chan72f556a2015-10-05 17:50:33 -0700280 }
281 };
Pier Ventre6b19e482016-11-07 16:21:04 -0800282
Charles Chanc91c8782016-03-30 17:54:24 -0700283 private final ConfigFactory<ApplicationId, SegmentRoutingAppConfig> appConfigFactory =
Charles Chan82f19972016-05-17 13:13:55 -0700284 new ConfigFactory<ApplicationId, SegmentRoutingAppConfig>(
285 SubjectFactories.APP_SUBJECT_FACTORY,
Charles Chanc91c8782016-03-30 17:54:24 -0700286 SegmentRoutingAppConfig.class, "segmentrouting") {
Charles Chan82ab1932016-01-30 23:22:37 -0800287 @Override
288 public SegmentRoutingAppConfig createConfig() {
289 return new SegmentRoutingAppConfig();
290 }
291 };
Pier Ventre6b19e482016-11-07 16:21:04 -0800292
Charles Chan82f19972016-05-17 13:13:55 -0700293 private final ConfigFactory<ApplicationId, XConnectConfig> xConnectConfigFactory =
294 new ConfigFactory<ApplicationId, XConnectConfig>(
295 SubjectFactories.APP_SUBJECT_FACTORY,
296 XConnectConfig.class, "xconnect") {
297 @Override
298 public XConnectConfig createConfig() {
299 return new XConnectConfig();
300 }
301 };
Pier Ventre6b19e482016-11-07 16:21:04 -0800302
Charles Chanc91c8782016-03-30 17:54:24 -0700303 private ConfigFactory<ApplicationId, McastConfig> mcastConfigFactory =
Charles Chan82f19972016-05-17 13:13:55 -0700304 new ConfigFactory<ApplicationId, McastConfig>(
305 SubjectFactories.APP_SUBJECT_FACTORY,
Charles Chanc91c8782016-03-30 17:54:24 -0700306 McastConfig.class, "multicast") {
307 @Override
308 public McastConfig createConfig() {
309 return new McastConfig();
310 }
311 };
312
Pier Ventre6b19e482016-11-07 16:21:04 -0800313 private final ConfigFactory<ApplicationId, PwaasConfig> pwaasConfigFactory =
314 new ConfigFactory<ApplicationId, PwaasConfig>(
315 SubjectFactories.APP_SUBJECT_FACTORY,
316 PwaasConfig.class, "pwaas") {
317 @Override
318 public PwaasConfig createConfig() {
319 return new PwaasConfig();
320 }
321 };
322
Charles Chan3ed34d82017-06-22 18:03:14 -0700323 private static final Object THREAD_SCHED_LOCK = new Object();
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700324 private static int numOfEventsQueued = 0;
325 private static int numOfEventsExecuted = 0;
sangho80f11cb2015-04-01 13:05:26 -0700326 private static int numOfHandlerExecution = 0;
327 private static int numOfHandlerScheduled = 0;
328
Charles Chan1963f4f2016-02-18 14:22:42 -0800329 /**
330 * Segment Routing App ID.
331 */
Charles Chan46fdfaf2016-11-09 20:51:44 -0800332 public static final String APP_NAME = "org.onosproject.segmentrouting";
Charles Chan10b0fb72017-02-02 16:20:42 -0800333
Charles Chanb7f75ac2016-01-11 18:28:54 -0800334 /**
335 * The default VLAN ID assigned to the interfaces without subnet config.
336 */
Charles Chan10b0fb72017-02-02 16:20:42 -0800337 public static final VlanId INTERNAL_VLAN = VlanId.vlanId((short) 4094);
Saurav Das7c305372015-10-28 12:39:42 -0700338
sangho80f11cb2015-04-01 13:05:26 -0700339 @Activate
Charles Chan873661e2017-11-30 15:37:50 -0800340 protected void activate(ComponentContext context) {
Charles Chan46fdfaf2016-11-09 20:51:44 -0800341 appId = coreService.registerApplication(APP_NAME);
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700342
343 log.debug("Creating EC map nsnextobjectivestore");
Saurav Das261c3002017-06-13 15:35:54 -0700344 EventuallyConsistentMapBuilder<DestinationSetNextObjectiveStoreKey, NextNeighbors>
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700345 nsNextObjMapBuilder = storageService.eventuallyConsistentMapBuilder();
Saurav Das261c3002017-06-13 15:35:54 -0700346 dsNextObjStore = nsNextObjMapBuilder
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700347 .withName("nsnextobjectivestore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700348 .withSerializer(createSerializer())
Madan Jampani675ae202015-06-24 19:05:56 -0700349 .withTimestampProvider((k, v) -> new WallClockTimestamp())
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700350 .build();
Saurav Das261c3002017-06-13 15:35:54 -0700351 log.trace("Current size {}", dsNextObjStore.size());
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700352
Charles Chan10b0fb72017-02-02 16:20:42 -0800353 log.debug("Creating EC map vlannextobjectivestore");
354 EventuallyConsistentMapBuilder<VlanNextObjectiveStoreKey, Integer>
355 vlanNextObjMapBuilder = storageService.eventuallyConsistentMapBuilder();
356 vlanNextObjStore = vlanNextObjMapBuilder
357 .withName("vlannextobjectivestore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700358 .withSerializer(createSerializer())
Charles Chan77277672015-10-20 16:24:19 -0700359 .withTimestampProvider((k, v) -> new WallClockTimestamp())
360 .build();
361
Saurav Das2d94d312015-11-24 23:21:05 -0800362 log.debug("Creating EC map subnetnextobjectivestore");
363 EventuallyConsistentMapBuilder<PortNextObjectiveStoreKey, Integer>
364 portNextObjMapBuilder = storageService.eventuallyConsistentMapBuilder();
365 portNextObjStore = portNextObjMapBuilder
366 .withName("portnextobjectivestore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700367 .withSerializer(createSerializer())
Saurav Das2d94d312015-11-24 23:21:05 -0800368 .withTimestampProvider((k, v) -> new WallClockTimestamp())
369 .build();
370
sangho4a5c42a2015-05-20 22:16:38 -0700371 EventuallyConsistentMapBuilder<String, Tunnel> tunnelMapBuilder =
372 storageService.eventuallyConsistentMapBuilder();
sangho4a5c42a2015-05-20 22:16:38 -0700373 tunnelStore = tunnelMapBuilder
374 .withName("tunnelstore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700375 .withSerializer(createSerializer())
Madan Jampani675ae202015-06-24 19:05:56 -0700376 .withTimestampProvider((k, v) -> new WallClockTimestamp())
sangho4a5c42a2015-05-20 22:16:38 -0700377 .build();
378
379 EventuallyConsistentMapBuilder<String, Policy> policyMapBuilder =
380 storageService.eventuallyConsistentMapBuilder();
sangho4a5c42a2015-05-20 22:16:38 -0700381 policyStore = policyMapBuilder
382 .withName("policystore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700383 .withSerializer(createSerializer())
Madan Jampani675ae202015-06-24 19:05:56 -0700384 .withTimestampProvider((k, v) -> new WallClockTimestamp())
sangho4a5c42a2015-05-20 22:16:38 -0700385 .build();
386
Saurav Dasc3604f12016-03-23 11:22:49 -0700387 compCfgService.preSetProperty("org.onosproject.net.group.impl.GroupManager",
Pier Luigib9632ba2017-01-12 18:14:58 -0800388 "purgeOnDisconnection", "true");
Saurav Dasc3604f12016-03-23 11:22:49 -0700389 compCfgService.preSetProperty("org.onosproject.net.flow.impl.FlowRuleManager",
Pier Luigib9632ba2017-01-12 18:14:58 -0800390 "purgeOnDisconnection", "true");
Pier Luigib9632ba2017-01-12 18:14:58 -0800391 compCfgService.preSetProperty("org.onosproject.provider.host.impl.HostLocationProvider",
392 "requestInterceptsEnabled", "false");
Charles Chanc1909e12017-08-08 15:13:37 -0700393 compCfgService.preSetProperty("org.onosproject.net.neighbour.impl.NeighbourResolutionManager",
Pier Luigibc976df2017-01-12 22:46:39 -0800394 "requestInterceptsEnabled", "false");
Charles Chan9597f8d2017-07-24 15:56:10 -0700395 compCfgService.preSetProperty("org.onosproject.dhcprelay.DhcpRelayManager",
Pier Luigibc976df2017-01-12 22:46:39 -0800396 "arpEnabled", "false");
Pier Luigi0ebeb312017-02-02 22:31:34 -0800397 compCfgService.preSetProperty("org.onosproject.net.host.impl.HostManager",
398 "greedyLearningIpv6", "true");
Charles Chancf8ea472017-02-28 15:15:17 -0800399 compCfgService.preSetProperty("org.onosproject.routing.cpr.ControlPlaneRedirectManager",
400 "forceUnprovision", "true");
Charles Chanc7b73c72017-08-10 16:57:28 -0700401 compCfgService.preSetProperty("org.onosproject.routeservice.store.RouteStoreImpl",
Charles Chan4c95c0d2017-07-20 16:16:25 -0700402 "distributed", "true");
Charles Chan804772f2017-08-14 11:42:11 -0700403 compCfgService.preSetProperty("org.onosproject.provider.host.impl.HostLocationProvider",
404 "multihomingEnabled", "true");
Charles Chan0c9c19f2017-11-29 19:54:20 -0800405 compCfgService.preSetProperty("org.onosproject.provider.lldp.impl.LldpLinkProvider",
406 "staleLinkAge", "15000");
407 compCfgService.preSetProperty("org.onosproject.net.host.impl.HostManager",
408 "allowDuplicateIps", "false");
Charles Chan873661e2017-11-30 15:37:50 -0800409 compCfgService.registerProperties(getClass());
410 modified(context);
Saurav Dasc3604f12016-03-23 11:22:49 -0700411
Charles Chan2b078ae2015-10-14 11:24:40 -0700412 processor = new InternalPacketProcessor();
413 linkListener = new InternalLinkListener();
414 deviceListener = new InternalDeviceListener();
Charles Chan82f19972016-05-17 13:13:55 -0700415 appCfgHandler = new AppConfigHandler(this);
416 xConnectHandler = new XConnectHandler(this);
Charles Chan1eaf4802016-04-18 13:44:03 -0700417 mcastHandler = new McastHandler(this);
418 hostHandler = new HostHandler(this);
Charles Chandebfea32016-10-24 14:52:01 -0700419 routeHandler = new RouteHandler(this);
Pier Ventreb6b81d52016-12-02 08:16:05 -0800420 neighbourHandler = new SegmentRoutingNeighbourDispatcher(this);
Pier Ventre6b19e482016-11-07 16:21:04 -0800421 l2TunnelHandler = new L2TunnelHandler(this);
Charles Chan2b078ae2015-10-14 11:24:40 -0700422
Charles Chand6d25332016-02-26 22:19:52 -0800423 cfgService.addListener(cfgListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700424 cfgService.registerConfigFactory(deviceConfigFactory);
425 cfgService.registerConfigFactory(appConfigFactory);
Charles Chan82f19972016-05-17 13:13:55 -0700426 cfgService.registerConfigFactory(xConnectConfigFactory);
Charles Chanc91c8782016-03-30 17:54:24 -0700427 cfgService.registerConfigFactory(mcastConfigFactory);
Pier Ventre6b19e482016-11-07 16:21:04 -0800428 cfgService.registerConfigFactory(pwaasConfigFactory);
Charles Chan6961f222018-01-04 14:26:07 -0800429
430 cfgListener.configureNetwork();
431
Charles Chan82ab1932016-01-30 23:22:37 -0800432 hostService.addListener(hostListener);
Charles Chan2b078ae2015-10-14 11:24:40 -0700433 packetService.addProcessor(processor, PacketProcessor.director(2));
434 linkService.addListener(linkListener);
435 deviceService.addListener(deviceListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700436 multicastRouteService.addListener(mcastListener);
Charles Chanfd48c222017-06-19 00:43:31 -0700437 routeService.addListener(routeListener);
Charles Chan2b078ae2015-10-14 11:24:40 -0700438
Andreas Pantelopoulos75eef062018-01-11 07:53:48 -0800439 l2TunnelHandler.init();
440
sangho80f11cb2015-04-01 13:05:26 -0700441 log.info("Started");
442 }
443
Jonathan Hart54541d12016-04-12 15:39:44 -0700444 private KryoNamespace.Builder createSerializer() {
445 return new KryoNamespace.Builder()
446 .register(KryoNamespaces.API)
Saurav Das261c3002017-06-13 15:35:54 -0700447 .register(DestinationSetNextObjectiveStoreKey.class,
Charles Chan10b0fb72017-02-02 16:20:42 -0800448 VlanNextObjectiveStoreKey.class,
Saurav Das261c3002017-06-13 15:35:54 -0700449 DestinationSet.class,
450 NextNeighbors.class,
Jonathan Hart54541d12016-04-12 15:39:44 -0700451 Tunnel.class,
452 DefaultTunnel.class,
453 Policy.class,
454 TunnelPolicy.class,
455 Policy.Type.class,
456 PortNextObjectiveStoreKey.class,
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -0700457 XConnectStoreKey.class,
458 DefaultL2Tunnel.class,
459 DefaultL2TunnelPolicy.class
Jonathan Hart54541d12016-04-12 15:39:44 -0700460 );
461 }
462
sangho80f11cb2015-04-01 13:05:26 -0700463 @Deactivate
464 protected void deactivate() {
Charles Chan72f556a2015-10-05 17:50:33 -0700465 cfgService.removeListener(cfgListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700466 cfgService.unregisterConfigFactory(deviceConfigFactory);
467 cfgService.unregisterConfigFactory(appConfigFactory);
Charles Chandebfea32016-10-24 14:52:01 -0700468 cfgService.unregisterConfigFactory(xConnectConfigFactory);
Charles Chanc91c8782016-03-30 17:54:24 -0700469 cfgService.unregisterConfigFactory(mcastConfigFactory);
Pier Ventre6b19e482016-11-07 16:21:04 -0800470 cfgService.unregisterConfigFactory(pwaasConfigFactory);
Charles Chan873661e2017-11-30 15:37:50 -0800471 compCfgService.unregisterProperties(getClass(), false);
Charles Chan72f556a2015-10-05 17:50:33 -0700472
Charles Chanfd48c222017-06-19 00:43:31 -0700473 hostService.removeListener(hostListener);
sangho80f11cb2015-04-01 13:05:26 -0700474 packetService.removeProcessor(processor);
Charles Chan2b078ae2015-10-14 11:24:40 -0700475 linkService.removeListener(linkListener);
476 deviceService.removeListener(deviceListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700477 multicastRouteService.removeListener(mcastListener);
Charles Chandebfea32016-10-24 14:52:01 -0700478 routeService.removeListener(routeListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700479
Charles Chan2e71ef32017-02-23 15:44:08 -0800480 neighbourResolutionService.unregisterNeighbourHandlers(appId);
481
sangho80f11cb2015-04-01 13:05:26 -0700482 processor = null;
Charles Chan2b078ae2015-10-14 11:24:40 -0700483 linkListener = null;
Charles Chanc91c8782016-03-30 17:54:24 -0700484 deviceListener = null;
Charles Chan2b078ae2015-10-14 11:24:40 -0700485 groupHandlerMap.clear();
486
Saurav Das261c3002017-06-13 15:35:54 -0700487 dsNextObjStore.destroy();
Charles Chan10b0fb72017-02-02 16:20:42 -0800488 vlanNextObjStore.destroy();
Charles Chanc91c8782016-03-30 17:54:24 -0700489 portNextObjStore.destroy();
Charles Chanc91c8782016-03-30 17:54:24 -0700490 tunnelStore.destroy();
491 policyStore.destroy();
sangho80f11cb2015-04-01 13:05:26 -0700492 log.info("Stopped");
493 }
494
Charles Chan873661e2017-11-30 15:37:50 -0800495 @Modified
496 private void modified(ComponentContext context) {
497 Dictionary<?, ?> properties = context.getProperties();
498 if (properties == null) {
499 return;
500 }
501
502 String strActiveProving = Tools.get(properties, "activeProbing");
503 boolean expectActiveProbing = Boolean.parseBoolean(strActiveProving);
504
505 if (expectActiveProbing != activeProbing) {
506 activeProbing = expectActiveProbing;
507 log.info("{} active probing", activeProbing ? "Enabling" : "Disabling");
508 }
509 }
510
sangho27462c62015-05-14 00:39:53 -0700511 @Override
512 public List<Tunnel> getTunnels() {
513 return tunnelHandler.getTunnels();
514 }
515
516 @Override
sanghobd812f82015-06-29 14:58:47 -0700517 public TunnelHandler.Result createTunnel(Tunnel tunnel) {
518 return tunnelHandler.createTunnel(tunnel);
sangho27462c62015-05-14 00:39:53 -0700519 }
520
521 @Override
sanghobd812f82015-06-29 14:58:47 -0700522 public TunnelHandler.Result removeTunnel(Tunnel tunnel) {
sangho27462c62015-05-14 00:39:53 -0700523 for (Policy policy: policyHandler.getPolicies()) {
524 if (policy.type() == Policy.Type.TUNNEL_FLOW) {
525 TunnelPolicy tunnelPolicy = (TunnelPolicy) policy;
526 if (tunnelPolicy.tunnelId().equals(tunnel.id())) {
527 log.warn("Cannot remove the tunnel used by a policy");
sanghobd812f82015-06-29 14:58:47 -0700528 return TunnelHandler.Result.TUNNEL_IN_USE;
sangho27462c62015-05-14 00:39:53 -0700529 }
530 }
531 }
sanghobd812f82015-06-29 14:58:47 -0700532 return tunnelHandler.removeTunnel(tunnel);
sangho27462c62015-05-14 00:39:53 -0700533 }
534
535 @Override
sanghobd812f82015-06-29 14:58:47 -0700536 public PolicyHandler.Result removePolicy(Policy policy) {
537 return policyHandler.removePolicy(policy);
sangho27462c62015-05-14 00:39:53 -0700538 }
539
540 @Override
sanghobd812f82015-06-29 14:58:47 -0700541 public PolicyHandler.Result createPolicy(Policy policy) {
542 return policyHandler.createPolicy(policy);
sangho27462c62015-05-14 00:39:53 -0700543 }
544
545 @Override
546 public List<Policy> getPolicies() {
547 return policyHandler.getPolicies();
548 }
549
Saurav Das07c74602016-04-27 18:35:50 -0700550 @Override
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -0700551 public List<DefaultL2Tunnel> getL2Tunnels() {
552 return l2TunnelHandler.getL2Tunnels();
553 }
554
555 @Override
556 public List<DefaultL2TunnelPolicy> getL2Policies() {
557 return l2TunnelHandler.getL2Policies();
558 }
559
560 @Override
561 public L2TunnelHandler.Result addPseudowire(String tunnelId, String pwLabel, String cP1,
562 String cP1InnerVlan, String cP1OuterVlan, String cP2,
563 String cP2InnerVlan, String cP2OuterVlan,
564 String mode, String sdTag) {
Andreas Pantelopoulosafc637f2017-12-20 18:04:27 -0800565 // Try to inject an empty Pwaas config if it is not found for the first time
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -0700566 PwaasConfig config = cfgService.getConfig(appId(), PwaasConfig.class);
567 if (config == null) {
Andreas Pantelopoulosafc637f2017-12-20 18:04:27 -0800568 log.debug("Pwaas config not found. Try to create an empty one.");
569 cfgService.applyConfig(appId(), PwaasConfig.class, new ObjectMapper().createObjectNode());
570 config = cfgService.getConfig(appId(), PwaasConfig.class);
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -0700571 }
572
573 ObjectNode object = config.addPseudowire(tunnelId, pwLabel,
574 cP1, cP1InnerVlan, cP1OuterVlan,
575 cP2, cP2InnerVlan, cP2OuterVlan,
576 mode, sdTag);
577 if (object == null) {
578 log.warn("Could not add pseudowire to the configuration!");
579 return L2TunnelHandler.Result.ADDITION_ERROR;
580 }
581
582 // inform everyone about the valid change in the pw configuration
583 cfgService.applyConfig(appId(), PwaasConfig.class, object);
584 return L2TunnelHandler.Result.SUCCESS;
585 }
586
587 @Override
588 public L2TunnelHandler.Result removePseudowire(String pwId) {
589
590 PwaasConfig config = cfgService.getConfig(appId(), PwaasConfig.class);
591 if (config == null) {
592 log.warn("Configuration for Pwaas class could not be found!");
593 return L2TunnelHandler.Result.CONFIG_NOT_FOUND;
594 }
595
596 ObjectNode object = config.removePseudowire(pwId);
597 if (object == null) {
598 log.warn("Could not delete pseudowire from configuration!");
599 return L2TunnelHandler.Result.REMOVAL_ERROR;
600 }
601
602 // sanity check, this should never fail since we removed a pw
603 // and we always check when we update the configuration
604 config.isValid();
605
606 // inform everyone
607 cfgService.applyConfig(appId(), PwaasConfig.class, object);
608
609 return L2TunnelHandler.Result.SUCCESS;
610 }
611
612 @Override
Saurav Das07c74602016-04-27 18:35:50 -0700613 public void rerouteNetwork() {
614 cfgListener.configureNetwork();
Saurav Das07c74602016-04-27 18:35:50 -0700615 }
616
Charles Chand7844e52016-10-20 17:02:44 -0700617 @Override
Pier Ventreb6a7f342016-11-26 21:05:22 -0800618 public Map<DeviceId, Set<IpPrefix>> getDeviceSubnetMap() {
619 Map<DeviceId, Set<IpPrefix>> deviceSubnetMap = Maps.newHashMap();
Jonathan Hart61e24e12017-11-30 18:23:42 -0800620 deviceConfiguration.getRouters().forEach(device ->
621 deviceSubnetMap.put(device, deviceConfiguration.getSubnets(device)));
Charles Chand7844e52016-10-20 17:02:44 -0700622 return deviceSubnetMap;
623 }
624
Saurav Das62ae6792017-05-15 15:34:25 -0700625
626 @Override
627 public ImmutableMap<DeviceId, EcmpShortestPathGraph> getCurrentEcmpSpg() {
628 if (defaultRoutingHandler != null) {
629 return defaultRoutingHandler.getCurrentEmcpSpgMap();
630 } else {
631 return null;
632 }
633 }
634
635 @Override
Saurav Das261c3002017-06-13 15:35:54 -0700636 public ImmutableMap<DestinationSetNextObjectiveStoreKey, NextNeighbors> getDestinationSet() {
637 if (dsNextObjStore != null) {
638 return ImmutableMap.copyOf(dsNextObjStore.entrySet());
Saurav Das62ae6792017-05-15 15:34:25 -0700639 } else {
640 return ImmutableMap.of();
641 }
642 }
643
Saurav Dasfbe74572017-08-03 18:30:35 -0700644 @Override
645 public void verifyGroups(DeviceId id) {
646 DefaultGroupHandler gh = groupHandlerMap.get(id);
647 if (gh != null) {
648 gh.triggerBucketCorrector();
649 }
650 }
651
sangho80f1f892015-05-19 11:57:42 -0700652 /**
Ray Milkeyb85de082017-04-05 09:42:04 -0700653 * Extracts the application ID from the manager.
654 *
655 * @return application ID
656 */
657 public ApplicationId appId() {
658 return appId;
659 }
660
661 /**
662 * Returns the device configuration.
663 *
664 * @return device configuration
665 */
666 public DeviceConfiguration deviceConfiguration() {
667 return deviceConfiguration;
668 }
669
670 /**
Saurav Das261c3002017-06-13 15:35:54 -0700671 * Per device next objective ID store with (device id + destination set) as key.
Charles Chan53de91f2017-08-22 15:07:34 -0700672 * Used to keep track on MPLS group information.
Ray Milkeyb85de082017-04-05 09:42:04 -0700673 *
674 * @return next objective ID store
675 */
Saurav Das261c3002017-06-13 15:35:54 -0700676 public EventuallyConsistentMap<DestinationSetNextObjectiveStoreKey, NextNeighbors>
677 dsNextObjStore() {
678 return dsNextObjStore;
Ray Milkeyb85de082017-04-05 09:42:04 -0700679 }
680
681 /**
Charles Chan53de91f2017-08-22 15:07:34 -0700682 * Per device next objective ID store with (device id + vlanid) as key.
683 * Used to keep track on L2 flood group information.
Ray Milkeyb85de082017-04-05 09:42:04 -0700684 *
685 * @return vlan next object store
686 */
687 public EventuallyConsistentMap<VlanNextObjectiveStoreKey, Integer> vlanNextObjStore() {
688 return vlanNextObjStore;
689 }
690
691 /**
Charles Chan53de91f2017-08-22 15:07:34 -0700692 * Per device next objective ID store with (device id + port + treatment + meta) as key.
693 * Used to keep track on L2 interface group and L3 unicast group information.
Ray Milkeyb85de082017-04-05 09:42:04 -0700694 *
695 * @return port next object store.
696 */
697 public EventuallyConsistentMap<PortNextObjectiveStoreKey, Integer> portNextObjStore() {
698 return portNextObjStore;
699 }
700
701 /**
Saurav Das261c3002017-06-13 15:35:54 -0700702 * Returns the MPLS-ECMP configuration which indicates whether ECMP on
703 * labeled packets should be programmed or not.
Pier Ventre7a78de22016-10-31 15:00:01 -0700704 *
705 * @return MPLS-ECMP value
706 */
707 public boolean getMplsEcmp() {
708 SegmentRoutingAppConfig segmentRoutingAppConfig = cfgService
709 .getConfig(this.appId, SegmentRoutingAppConfig.class);
710 return segmentRoutingAppConfig != null && segmentRoutingAppConfig.mplsEcmp();
711 }
712
713 /**
sangho80f1f892015-05-19 11:57:42 -0700714 * Returns the tunnel object with the tunnel ID.
715 *
716 * @param tunnelId Tunnel ID
717 * @return Tunnel reference
718 */
sangho27462c62015-05-14 00:39:53 -0700719 public Tunnel getTunnel(String tunnelId) {
720 return tunnelHandler.getTunnel(tunnelId);
721 }
722
Charles Chan90772a72017-02-08 15:52:08 -0800723 // TODO Consider moving these to InterfaceService
sangho80f11cb2015-04-01 13:05:26 -0700724 /**
Charles Chan10b0fb72017-02-02 16:20:42 -0800725 * Returns untagged VLAN configured on given connect point.
Charles Chan90772a72017-02-08 15:52:08 -0800726 * <p>
727 * Only returns the first match if there are multiple untagged VLAN configured
728 * on the connect point.
sangho80f11cb2015-04-01 13:05:26 -0700729 *
Charles Chan10b0fb72017-02-02 16:20:42 -0800730 * @param connectPoint connect point
731 * @return untagged VLAN or null if not configured
sangho80f11cb2015-04-01 13:05:26 -0700732 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700733 VlanId getUntaggedVlanId(ConnectPoint connectPoint) {
Charles Chan10b0fb72017-02-02 16:20:42 -0800734 return interfaceService.getInterfacesByPort(connectPoint).stream()
735 .filter(intf -> !intf.vlanUntagged().equals(VlanId.NONE))
736 .map(Interface::vlanUntagged)
737 .findFirst().orElse(null);
sangho80f11cb2015-04-01 13:05:26 -0700738 }
739
sangho27462c62015-05-14 00:39:53 -0700740 /**
Charles Chan90772a72017-02-08 15:52:08 -0800741 * Returns tagged VLAN configured on given connect point.
742 * <p>
743 * Returns all matches if there are multiple tagged VLAN configured
744 * on the connect point.
745 *
746 * @param connectPoint connect point
747 * @return tagged VLAN or empty set if not configured
748 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700749 Set<VlanId> getTaggedVlanId(ConnectPoint connectPoint) {
Charles Chan90772a72017-02-08 15:52:08 -0800750 Set<Interface> interfaces = interfaceService.getInterfacesByPort(connectPoint);
751 return interfaces.stream()
752 .map(Interface::vlanTagged)
Charles Chan3ed34d82017-06-22 18:03:14 -0700753 .flatMap(Set::stream)
Charles Chan90772a72017-02-08 15:52:08 -0800754 .collect(Collectors.toSet());
755 }
756
757 /**
758 * Returns native VLAN configured on given connect point.
759 * <p>
760 * Only returns the first match if there are multiple native VLAN configured
761 * on the connect point.
762 *
763 * @param connectPoint connect point
764 * @return native VLAN or null if not configured
765 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700766 VlanId getNativeVlanId(ConnectPoint connectPoint) {
Charles Chan90772a72017-02-08 15:52:08 -0800767 Set<Interface> interfaces = interfaceService.getInterfacesByPort(connectPoint);
768 return interfaces.stream()
769 .filter(intf -> !intf.vlanNative().equals(VlanId.NONE))
770 .map(Interface::vlanNative)
771 .findFirst()
772 .orElse(null);
773 }
774
775 /**
Charles Chand9265a32017-06-16 15:19:24 -0700776 * Returns internal VLAN for untagged hosts on given connect point.
777 * <p>
778 * The internal VLAN is either vlan-untagged for an access port,
779 * or vlan-native for a trunk port.
780 *
781 * @param connectPoint connect point
782 * @return internal VLAN or null if both vlan-untagged and vlan-native are undefined
783 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700784 VlanId getInternalVlanId(ConnectPoint connectPoint) {
Charles Chand9265a32017-06-16 15:19:24 -0700785 VlanId untaggedVlanId = getUntaggedVlanId(connectPoint);
786 VlanId nativeVlanId = getNativeVlanId(connectPoint);
787 return untaggedVlanId != null ? untaggedVlanId : nativeVlanId;
788 }
789
790 /**
Charles Chan3ed34d82017-06-22 18:03:14 -0700791 * Returns optional pair device ID of given device.
792 *
793 * @param deviceId device ID
794 * @return optional pair device ID. Might be empty if pair device is not configured
795 */
796 Optional<DeviceId> getPairDeviceId(DeviceId deviceId) {
797 SegmentRoutingDeviceConfig deviceConfig =
798 cfgService.getConfig(deviceId, SegmentRoutingDeviceConfig.class);
799 return Optional.ofNullable(deviceConfig).map(SegmentRoutingDeviceConfig::pairDeviceId);
800 }
801 /**
802 * Returns optional pair device local port of given device.
803 *
804 * @param deviceId device ID
805 * @return optional pair device ID. Might be empty if pair device is not configured
806 */
807 Optional<PortNumber> getPairLocalPorts(DeviceId deviceId) {
808 SegmentRoutingDeviceConfig deviceConfig =
809 cfgService.getConfig(deviceId, SegmentRoutingDeviceConfig.class);
810 return Optional.ofNullable(deviceConfig).map(SegmentRoutingDeviceConfig::pairLocalPort);
811 }
812
813 /**
Charles Chan910be6a2017-08-23 14:46:43 -0700814 * Determine if current instance is the master of given connect point.
815 *
816 * @param cp connect point
817 * @return true if current instance is the master of given connect point
818 */
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -0700819 public boolean isMasterOf(ConnectPoint cp) {
Charles Chan910be6a2017-08-23 14:46:43 -0700820 boolean isMaster = mastershipService.isLocalMaster(cp.deviceId());
821 if (!isMaster) {
822 log.debug(NOT_MASTER, cp);
823 }
824 return isMaster;
825 }
826
827 /**
Charles Chanf0ae41e2017-08-23 13:55:39 -0700828 * Returns locations of given resolved route.
829 *
830 * @param resolvedRoute resolved route
831 * @return locations of nexthop. Might be empty if next hop is not found
832 */
833 Set<ConnectPoint> nextHopLocations(ResolvedRoute resolvedRoute) {
834 HostId hostId = HostId.hostId(resolvedRoute.nextHopMac(), resolvedRoute.nextHopVlan());
835 return Optional.ofNullable(hostService.getHost(hostId))
836 .map(Host::locations).orElse(Sets.newHashSet())
837 .stream().map(l -> (ConnectPoint) l).collect(Collectors.toSet());
838 }
839
840 /**
Charles Chan90772a72017-02-08 15:52:08 -0800841 * Returns vlan port map of given device.
842 *
843 * @param deviceId device id
844 * @return vlan-port multimap
845 */
846 public Multimap<VlanId, PortNumber> getVlanPortMap(DeviceId deviceId) {
847 HashMultimap<VlanId, PortNumber> vlanPortMap = HashMultimap.create();
848
849 interfaceService.getInterfaces().stream()
850 .filter(intf -> intf.connectPoint().deviceId().equals(deviceId))
851 .forEach(intf -> {
852 vlanPortMap.put(intf.vlanUntagged(), intf.connectPoint().port());
Charles Chan3ed34d82017-06-22 18:03:14 -0700853 intf.vlanTagged().forEach(vlanTagged ->
854 vlanPortMap.put(vlanTagged, intf.connectPoint().port())
855 );
Charles Chan90772a72017-02-08 15:52:08 -0800856 vlanPortMap.put(intf.vlanNative(), intf.connectPoint().port());
857 });
858 vlanPortMap.removeAll(VlanId.NONE);
859
860 return vlanPortMap;
861 }
862
863 /**
Charles Chan10b0fb72017-02-02 16:20:42 -0800864 * Returns the next objective ID for the given vlan id. It is expected
Saurav Das2d94d312015-11-24 23:21:05 -0800865 * that the next-objective has been pre-created from configuration.
Charles Chan77277672015-10-20 16:24:19 -0700866 *
867 * @param deviceId Device ID
Charles Chan10b0fb72017-02-02 16:20:42 -0800868 * @param vlanId VLAN ID
Saurav Das2d94d312015-11-24 23:21:05 -0800869 * @return next objective ID or -1 if it was not found
Charles Chan77277672015-10-20 16:24:19 -0700870 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700871 int getVlanNextObjectiveId(DeviceId deviceId, VlanId vlanId) {
Charles Chan77277672015-10-20 16:24:19 -0700872 if (groupHandlerMap.get(deviceId) != null) {
Charles Chan10b0fb72017-02-02 16:20:42 -0800873 log.trace("getVlanNextObjectiveId query in device {}", deviceId);
874 return groupHandlerMap.get(deviceId).getVlanNextObjectiveId(vlanId);
Charles Chan77277672015-10-20 16:24:19 -0700875 } else {
Charles Chan10b0fb72017-02-02 16:20:42 -0800876 log.warn("getVlanNextObjectiveId query - groupHandler for "
Saurav Das2d94d312015-11-24 23:21:05 -0800877 + "device {} not found", deviceId);
878 return -1;
879 }
880 }
881
882 /**
883 * Returns the next objective ID for the given portNumber, given the treatment.
884 * There could be multiple different treatments to the same outport, which
Saurav Das2cb38292017-03-29 19:09:17 -0700885 * would result in different objectives. If the next object does not exist,
886 * and should be created, a new one is created and its id is returned.
Saurav Das2d94d312015-11-24 23:21:05 -0800887 *
888 * @param deviceId Device ID
889 * @param portNum port number on device for which NextObjective is queried
890 * @param treatment the actions to apply on the packets (should include outport)
891 * @param meta metadata passed into the creation of a Next Objective if necessary
Saurav Das2cb38292017-03-29 19:09:17 -0700892 * @param createIfMissing true if a next object should be created if not found
Saurav Das07c74602016-04-27 18:35:50 -0700893 * @return next objective ID or -1 if an error occurred during retrieval or creation
Saurav Das2d94d312015-11-24 23:21:05 -0800894 */
895 public int getPortNextObjectiveId(DeviceId deviceId, PortNumber portNum,
896 TrafficTreatment treatment,
Saurav Das2cb38292017-03-29 19:09:17 -0700897 TrafficSelector meta,
898 boolean createIfMissing) {
Saurav Das2d94d312015-11-24 23:21:05 -0800899 DefaultGroupHandler ghdlr = groupHandlerMap.get(deviceId);
900 if (ghdlr != null) {
Saurav Das2cb38292017-03-29 19:09:17 -0700901 return ghdlr.getPortNextObjectiveId(portNum, treatment, meta, createIfMissing);
Saurav Das2d94d312015-11-24 23:21:05 -0800902 } else {
Charles Chanb7f75ac2016-01-11 18:28:54 -0800903 log.warn("getPortNextObjectiveId query - groupHandler for device {}"
904 + " not found", deviceId);
905 return -1;
906 }
907 }
908
Saurav Das62ae6792017-05-15 15:34:25 -0700909 /**
910 * Returns the group handler object for the specified device id.
911 *
912 * @param devId the device identifier
913 * @return the groupHandler object for the device id, or null if not found
914 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700915 DefaultGroupHandler getGroupHandler(DeviceId devId) {
Saurav Das62ae6792017-05-15 15:34:25 -0700916 return groupHandlerMap.get(devId);
917 }
918
919 /**
Saurav Dasfbe74572017-08-03 18:30:35 -0700920 * Returns the default routing handler object.
921 *
922 * @return the default routing handler object
923 */
924 public DefaultRoutingHandler getRoutingHandler() {
925 return defaultRoutingHandler;
926 }
927
928 /**
Saurav Das62ae6792017-05-15 15:34:25 -0700929 * Returns true if this controller instance has seen this link before. The
930 * link may not be currently up, but as long as the link had been seen before
931 * this method will return true. The one exception is when the link was
932 * indeed seen before, but this controller instance was forced to forget it
933 * by a call to purgeSeenLink method.
934 *
935 * @param link the infrastructure link being queried
936 * @return true if this controller instance has seen this link before
937 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700938 boolean isSeenLink(Link link) {
Saurav Das62ae6792017-05-15 15:34:25 -0700939 return seenLinks.containsKey(link);
940 }
941
942 /**
943 * Updates the seen link store. Updates can be for links that are currently
944 * available or not.
945 *
946 * @param link the link to update in the seen-link local store
947 * @param up the status of the link, true if up, false if down
948 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700949 void updateSeenLink(Link link, boolean up) {
Saurav Das62ae6792017-05-15 15:34:25 -0700950 seenLinks.put(link, up);
951 }
952
953 /**
954 * Returns the status of a seen-link (up or down). If the link has not
955 * been seen-before, a null object is returned.
956 *
957 * @param link the infrastructure link being queried
958 * @return null if the link was not seen-before;
959 * true if the seen-link is up;
960 * false if the seen-link is down
961 */
Charles Chan873661e2017-11-30 15:37:50 -0800962 private Boolean isSeenLinkUp(Link link) {
Saurav Das62ae6792017-05-15 15:34:25 -0700963 return seenLinks.get(link);
964 }
965
966 /**
967 * Makes this controller instance forget a previously seen before link.
968 *
969 * @param link the infrastructure link to purge
970 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700971 private void purgeSeenLink(Link link) {
Saurav Das62ae6792017-05-15 15:34:25 -0700972 seenLinks.remove(link);
973 }
974
975 /**
976 * Returns the status of a link as parallel link. A parallel link
977 * is defined as a link which has common src and dst switches as another
978 * seen-link that is currently enabled. It is not necessary for the link being
979 * queried to be a seen-link.
980 *
981 * @param link the infrastructure link being queried
982 * @return true if a seen-link exists that is up, and shares the
983 * same src and dst switches as the link being queried
984 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700985 private boolean isParallelLink(Link link) {
Saurav Das62ae6792017-05-15 15:34:25 -0700986 for (Entry<Link, Boolean> seen : seenLinks.entrySet()) {
987 Link seenLink = seen.getKey();
988 if (seenLink.equals(link)) {
989 continue;
990 }
991 if (seenLink.src().deviceId().equals(link.src().deviceId()) &&
992 seenLink.dst().deviceId().equals(link.dst().deviceId()) &&
993 seen.getValue()) {
994 return true;
995 }
996 }
997 return false;
998 }
999
Saurav Das261c3002017-06-13 15:35:54 -07001000 /**
1001 * Returns true if the link being queried is a bidirectional link. A bidi
1002 * link is defined as a link, whose reverse link - ie. the link in the reverse
1003 * direction - has been seen-before and is up. It is not necessary for the link
1004 * being queried to be a seen-link.
1005 *
1006 * @param link the infrastructure link being queried
1007 * @return true if another unidirectional link exists in the reverse direction,
1008 * has been seen-before and is up
1009 */
Charles Chan873661e2017-11-30 15:37:50 -08001010 boolean isBidirectional(Link link) {
Saurav Das261c3002017-06-13 15:35:54 -07001011 Link reverseLink = linkService.getLink(link.dst(), link.src());
1012 if (reverseLink == null) {
1013 return false;
1014 }
1015 Boolean result = isSeenLinkUp(reverseLink);
1016 if (result == null) {
1017 return false;
1018 }
1019 return result.booleanValue();
1020 }
1021
1022 /**
1023 * Determines if the given link should be avoided in routing calculations
1024 * by policy or design.
1025 *
1026 * @param link the infrastructure link being queried
1027 * @return true if link should be avoided
1028 */
Charles Chan873661e2017-11-30 15:37:50 -08001029 boolean avoidLink(Link link) {
Saurav Das261c3002017-06-13 15:35:54 -07001030 // XXX currently only avoids all pair-links. In the future can be
1031 // extended to avoid any generic link
1032 DeviceId src = link.src().deviceId();
1033 PortNumber srcPort = link.src().port();
1034 if (deviceConfiguration == null || !deviceConfiguration.isConfigured(src)) {
1035 log.warn("Device {} not configured..cannot avoid link {}", src, link);
1036 return false;
1037 }
1038 DeviceId pairDev;
1039 PortNumber pairLocalPort, pairRemotePort = null;
1040 try {
1041 pairDev = deviceConfiguration.getPairDeviceId(src);
1042 pairLocalPort = deviceConfiguration.getPairLocalPort(src);
1043 if (pairDev != null) {
1044 pairRemotePort = deviceConfiguration.getPairLocalPort(pairDev);
1045 }
1046 } catch (DeviceConfigNotFoundException e) {
1047 log.warn("Pair dev for dev {} not configured..cannot avoid link {}",
1048 src, link);
1049 return false;
1050 }
1051
Charles Chan873661e2017-11-30 15:37:50 -08001052 return srcPort.equals(pairLocalPort) &&
Saurav Das261c3002017-06-13 15:35:54 -07001053 link.dst().deviceId().equals(pairDev) &&
Charles Chan873661e2017-11-30 15:37:50 -08001054 link.dst().port().equals(pairRemotePort);
Saurav Das261c3002017-06-13 15:35:54 -07001055 }
1056
sangho80f11cb2015-04-01 13:05:26 -07001057 private class InternalPacketProcessor implements PacketProcessor {
sangho80f11cb2015-04-01 13:05:26 -07001058 @Override
1059 public void process(PacketContext context) {
1060
1061 if (context.isHandled()) {
1062 return;
1063 }
1064
1065 InboundPacket pkt = context.inPacket();
1066 Ethernet ethernet = pkt.parsed();
Pier Luigi37a35432017-02-01 13:50:04 -08001067
1068 if (ethernet == null) {
1069 return;
1070 }
1071
Saurav Das261c3002017-06-13 15:35:54 -07001072 log.trace("Rcvd pktin from {}: {}", context.inPacket().receivedFrom(),
1073 ethernet);
Pier Ventreadb4ae62016-11-23 09:57:42 -08001074 if (ethernet.getEtherType() == TYPE_ARP) {
Saurav Das62ae6792017-05-15 15:34:25 -07001075 log.warn("Received unexpected ARP packet on {}",
1076 context.inPacket().receivedFrom());
Saurav Das368cf212017-03-15 15:15:14 -07001077 log.trace("{}", ethernet);
Pier Ventre6b2c1b32016-12-09 17:26:04 -08001078 return;
sangho80f11cb2015-04-01 13:05:26 -07001079 } else if (ethernet.getEtherType() == Ethernet.TYPE_IPV4) {
Pier Ventreb6b81d52016-12-02 08:16:05 -08001080 IPv4 ipv4Packet = (IPv4) ethernet.getPayload();
1081 //ipHandler.addToPacketBuffer(ipv4Packet);
1082 if (ipv4Packet.getProtocol() == IPv4.PROTOCOL_ICMP) {
1083 icmpHandler.processIcmp(ethernet, pkt.receivedFrom());
sangho80f11cb2015-04-01 13:05:26 -07001084 } else {
Charles Chand041ad82017-01-13 17:20:44 -08001085 // NOTE: We don't support IP learning at this moment so this
1086 // is not necessary. Also it causes duplication of DHCP packets.
Pier Ventre6b2c1b32016-12-09 17:26:04 -08001087 // ipHandler.processPacketIn(ipv4Packet, pkt.receivedFrom());
sangho80f11cb2015-04-01 13:05:26 -07001088 }
Pier Ventreb6a7f342016-11-26 21:05:22 -08001089 } else if (ethernet.getEtherType() == Ethernet.TYPE_IPV6) {
1090 IPv6 ipv6Packet = (IPv6) ethernet.getPayload();
Pier Ventreb6b81d52016-12-02 08:16:05 -08001091 //ipHandler.addToPacketBuffer(ipv6Packet);
Pier Luigi37a35432017-02-01 13:50:04 -08001092 // We deal with the packet only if the packet is a ICMP6 ECHO/REPLY
Pier Ventreb6b81d52016-12-02 08:16:05 -08001093 if (ipv6Packet.getNextHeader() == IPv6.PROTOCOL_ICMP6) {
1094 ICMP6 icmp6Packet = (ICMP6) ipv6Packet.getPayload();
1095 if (icmp6Packet.getIcmpType() == ICMP6.ECHO_REQUEST ||
1096 icmp6Packet.getIcmpType() == ICMP6.ECHO_REPLY) {
1097 icmpHandler.processIcmpv6(ethernet, pkt.receivedFrom());
1098 } else {
Saurav Das62ae6792017-05-15 15:34:25 -07001099 log.trace("Received ICMPv6 0x{} - not handled",
Charles Chand3727b72017-03-13 13:10:30 -07001100 Integer.toHexString(icmp6Packet.getIcmpType() & 0xff));
Pier Ventreb6b81d52016-12-02 08:16:05 -08001101 }
1102 } else {
1103 // NOTE: We don't support IP learning at this moment so this
1104 // is not necessary. Also it causes duplication of DHCPv6 packets.
1105 // ipHandler.processPacketIn(ipv6Packet, pkt.receivedFrom());
1106 }
sangho80f11cb2015-04-01 13:05:26 -07001107 }
1108 }
1109 }
1110
1111 private class InternalLinkListener implements LinkListener {
1112 @Override
1113 public void event(LinkEvent event) {
Charles Chan0cff8aa2017-03-29 16:39:05 -07001114 if (event.type() == LinkEvent.Type.LINK_ADDED ||
1115 event.type() == LinkEvent.Type.LINK_UPDATED ||
1116 event.type() == LinkEvent.Type.LINK_REMOVED) {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001117 log.debug("Event {} received from Link Service", event.type());
sangho80f11cb2015-04-01 13:05:26 -07001118 scheduleEventHandlerIfNotScheduled(event);
1119 }
1120 }
1121 }
1122
1123 private class InternalDeviceListener implements DeviceListener {
sangho80f11cb2015-04-01 13:05:26 -07001124 @Override
1125 public void event(DeviceEvent event) {
sangho80f11cb2015-04-01 13:05:26 -07001126 switch (event.type()) {
1127 case DEVICE_ADDED:
Saurav Dasf0f592d2016-11-18 15:21:57 -08001128 case PORT_UPDATED:
1129 case PORT_ADDED:
sanghofb7c7292015-04-13 15:15:58 -07001130 case DEVICE_UPDATED:
1131 case DEVICE_AVAILABILITY_CHANGED:
Saurav Das62ae6792017-05-15 15:34:25 -07001132 log.trace("Event {} received from Device Service", event.type());
sangho80f11cb2015-04-01 13:05:26 -07001133 scheduleEventHandlerIfNotScheduled(event);
1134 break;
1135 default:
1136 }
1137 }
1138 }
1139
Saurav Das2d94d312015-11-24 23:21:05 -08001140 @SuppressWarnings("rawtypes")
sangho80f11cb2015-04-01 13:05:26 -07001141 private void scheduleEventHandlerIfNotScheduled(Event event) {
Charles Chan3ed34d82017-06-22 18:03:14 -07001142 synchronized (THREAD_SCHED_LOCK) {
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001143 eventQueue.add(event);
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001144 numOfEventsQueued++;
1145
1146 if ((numOfHandlerScheduled - numOfHandlerExecution) == 0) {
1147 //No pending scheduled event handling threads. So start a new one.
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001148 eventHandlerFuture = executorService
1149 .schedule(eventHandler, 100, TimeUnit.MILLISECONDS);
1150 numOfHandlerScheduled++;
1151 }
Jonathan Hart54541d12016-04-12 15:39:44 -07001152 log.trace("numOfEventsQueued {}, numOfEventHandlerScheduled {}",
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001153 numOfEventsQueued,
1154 numOfHandlerScheduled);
sangho80f11cb2015-04-01 13:05:26 -07001155 }
sangho80f11cb2015-04-01 13:05:26 -07001156 }
1157
1158 private class InternalEventHandler implements Runnable {
Srikanth Vavilapalli37a461b2015-04-07 15:12:32 -07001159 @Override
sangho80f11cb2015-04-01 13:05:26 -07001160 public void run() {
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001161 try {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001162 while (true) {
Saurav Das2d94d312015-11-24 23:21:05 -08001163 @SuppressWarnings("rawtypes")
Charles Chan3ed34d82017-06-22 18:03:14 -07001164 Event event;
1165 synchronized (THREAD_SCHED_LOCK) {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001166 if (!eventQueue.isEmpty()) {
1167 event = eventQueue.poll();
1168 numOfEventsExecuted++;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001169 } else {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001170 numOfHandlerExecution++;
1171 log.debug("numOfHandlerExecution {} numOfEventsExecuted {}",
1172 numOfHandlerExecution, numOfEventsExecuted);
1173 break;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001174 }
sanghofb7c7292015-04-13 15:15:58 -07001175 }
Charles Chan0cff8aa2017-03-29 16:39:05 -07001176 if (event.type() == LinkEvent.Type.LINK_ADDED ||
1177 event.type() == LinkEvent.Type.LINK_UPDATED) {
Saurav Das62ae6792017-05-15 15:34:25 -07001178 // Note: do not update seenLinks here, otherwise every
1179 // link, even one seen for the first time, will be appear
1180 // to be a previously seen link
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001181 processLinkAdded((Link) event.subject());
1182 } else if (event.type() == LinkEvent.Type.LINK_REMOVED) {
Pier Ventre6d593892016-09-13 21:33:40 -07001183 Link linkRemoved = (Link) event.subject();
Saurav Das62ae6792017-05-15 15:34:25 -07001184 if (linkRemoved.type() == Link.Type.DIRECT) {
1185 updateSeenLink(linkRemoved, false);
1186 }
1187 // device availability check helps to ensure that
1188 // multiple link-removed events are actually treated as a
1189 // single switch removed event. purgeSeenLink is necessary
1190 // so we do rerouting (instead of rehashing) when switch
1191 // comes back.
Pier Ventre6d593892016-09-13 21:33:40 -07001192 if (linkRemoved.src().elementId() instanceof DeviceId &&
1193 !deviceService.isAvailable(linkRemoved.src().deviceId())) {
Saurav Das62ae6792017-05-15 15:34:25 -07001194 purgeSeenLink(linkRemoved);
Pier Ventre6d593892016-09-13 21:33:40 -07001195 continue;
1196 }
1197 if (linkRemoved.dst().elementId() instanceof DeviceId &&
1198 !deviceService.isAvailable(linkRemoved.dst().deviceId())) {
Saurav Das62ae6792017-05-15 15:34:25 -07001199 purgeSeenLink(linkRemoved);
Pier Ventre6d593892016-09-13 21:33:40 -07001200 continue;
1201 }
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001202 processLinkRemoved((Link) event.subject());
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001203 } else if (event.type() == DeviceEvent.Type.DEVICE_ADDED ||
1204 event.type() == DeviceEvent.Type.DEVICE_AVAILABILITY_CHANGED ||
1205 event.type() == DeviceEvent.Type.DEVICE_UPDATED) {
Saurav Das62af8802015-12-04 10:52:59 -08001206 DeviceId deviceId = ((Device) event.subject()).id();
1207 if (deviceService.isAvailable(deviceId)) {
Saurav Dasc28b3432015-10-30 17:45:38 -07001208 log.info("Processing device event {} for available device {}",
1209 event.type(), ((Device) event.subject()).id());
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001210 processDeviceAdded((Device) event.subject());
Saurav Dasc3604f12016-03-23 11:22:49 -07001211 } else {
1212 log.info("Processing device event {} for unavailable device {}",
1213 event.type(), ((Device) event.subject()).id());
1214 processDeviceRemoved((Device) event.subject());
1215 }
Saurav Dasf0f592d2016-11-18 15:21:57 -08001216 } else if (event.type() == DeviceEvent.Type.PORT_ADDED) {
Saurav Dasd1872b02016-12-02 15:43:47 -08001217 // typically these calls come when device is added first time
1218 // so port filtering rules are handled at the device_added event.
1219 // port added calls represent all ports on the device,
1220 // enabled or not.
Saurav Das62ae6792017-05-15 15:34:25 -07001221 log.trace("** PORT ADDED {}/{} -> {}",
Saurav Dasd1872b02016-12-02 15:43:47 -08001222 ((DeviceEvent) event).subject().id(),
1223 ((DeviceEvent) event).port().number(),
1224 event.type());
Saurav Dasf0f592d2016-11-18 15:21:57 -08001225 } else if (event.type() == DeviceEvent.Type.PORT_UPDATED) {
Saurav Dasd1872b02016-12-02 15:43:47 -08001226 // these calls happen for every subsequent event
1227 // ports enabled, disabled, switch goes away, comes back
Saurav Dasf0f592d2016-11-18 15:21:57 -08001228 log.info("** PORT UPDATED {}/{} -> {}",
1229 event.subject(),
1230 ((DeviceEvent) event).port(),
1231 event.type());
1232 processPortUpdated(((Device) event.subject()),
1233 ((DeviceEvent) event).port());
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001234 } else {
1235 log.warn("Unhandled event type: {}", event.type());
1236 }
sangho80f11cb2015-04-01 13:05:26 -07001237 }
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001238 } catch (Exception e) {
1239 log.error("SegmentRouting event handler "
1240 + "thread thrown an exception: {}", e);
sangho80f11cb2015-04-01 13:05:26 -07001241 }
sangho80f11cb2015-04-01 13:05:26 -07001242 }
1243 }
1244
sangho80f11cb2015-04-01 13:05:26 -07001245 private void processLinkAdded(Link link) {
Saurav Dasb149be12016-06-07 10:08:06 -07001246 log.info("** LINK ADDED {}", link.toString());
Saurav Das04944532017-12-19 16:08:42 -08001247 if (!isLinkValid(link)) {
Saurav Das62ae6792017-05-15 15:34:25 -07001248 return;
1249 }
Saurav Dasfe0b05e2017-08-14 16:44:43 -07001250 if (!deviceConfiguration.isConfigured(link.src().deviceId())) {
1251 updateSeenLink(link, true);
1252 // XXX revisit - what about devicePortMap
1253 log.warn("Source device of this link is not configured.. "
1254 + "not processing further");
1255 return;
1256 }
Saurav Das62ae6792017-05-15 15:34:25 -07001257
1258 //Irrespective of whether the local is a MASTER or not for this device,
1259 //create group handler instance and push default TTP flow rules if needed,
1260 //as in a multi-instance setup, instances can initiate groups for any device.
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001261 DefaultGroupHandler groupHandler = groupHandlerMap.get(link.src()
1262 .deviceId());
1263 if (groupHandler != null) {
Saurav Das62ae6792017-05-15 15:34:25 -07001264 groupHandler.portUpForLink(link);
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001265 } else {
Saurav Dasfe0b05e2017-08-14 16:44:43 -07001266 // XXX revisit/cleanup
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001267 Device device = deviceService.getDevice(link.src().deviceId());
1268 if (device != null) {
1269 log.warn("processLinkAdded: Link Added "
1270 + "Notification without Device Added "
1271 + "event, still handling it");
1272 processDeviceAdded(device);
1273 groupHandler = groupHandlerMap.get(link.src()
1274 .deviceId());
Saurav Das62ae6792017-05-15 15:34:25 -07001275 groupHandler.portUpForLink(link);
sangho80f11cb2015-04-01 13:05:26 -07001276 }
1277 }
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001278
Saurav Das261c3002017-06-13 15:35:54 -07001279 /*// process link only if it is bidirectional
1280 if (!isBidirectional(link)) {
1281 log.debug("Link not bidirectional.. waiting for other direction "
1282 + "src {} --> dst {} ", link.dst(), link.src());
1283 // note that if we are not processing for routing, it should at least
1284 // be considered a seen-link
1285 updateSeenLink(link, true);
1286 return;
1287 }
1288 TO DO this ensure that rehash is still done correctly even if link is
1289 not processed for rerouting - perhaps rehash in both directions when
1290 it ultimately becomes bidi?
1291 */
1292
1293 log.debug("Starting optimized route population process for link "
1294 + "{} --> {}", link.src(), link.dst());
Saurav Das62ae6792017-05-15 15:34:25 -07001295 boolean seenBefore = isSeenLink(link);
1296 defaultRoutingHandler.populateRoutingRulesForLinkStatusChange(null, link, null);
Saurav Das261c3002017-06-13 15:35:54 -07001297
1298 // It's possible that linkUp causes no route-path change as ECMP graph does
1299 // not change if the link is a parallel link (same src-dst as another link.
1300 // However we still need to update ECMP hash groups to include new buckets
1301 // for the link that has come up.
Saurav Das62ae6792017-05-15 15:34:25 -07001302 if (mastershipService.isLocalMaster(link.src().deviceId())) {
Saurav Das261c3002017-06-13 15:35:54 -07001303 if (!seenBefore && isParallelLink(link)) {
Saurav Das62ae6792017-05-15 15:34:25 -07001304 // if link seen first time, we need to ensure hash-groups have all ports
Saurav Das261c3002017-06-13 15:35:54 -07001305 log.debug("Attempting retryHash for paralled first-time link {}", link);
Saurav Das62ae6792017-05-15 15:34:25 -07001306 groupHandler.retryHash(link, false, true);
1307 } else {
1308 //seen before-link
1309 if (isParallelLink(link)) {
Saurav Das261c3002017-06-13 15:35:54 -07001310 log.debug("Attempting retryHash for paralled seen-before "
1311 + "link {}", link);
Saurav Das62ae6792017-05-15 15:34:25 -07001312 groupHandler.retryHash(link, false, false);
1313 }
1314 }
1315 }
Charles Chan72779502016-04-23 17:36:10 -07001316
1317 mcastHandler.init();
sangho80f11cb2015-04-01 13:05:26 -07001318 }
1319
1320 private void processLinkRemoved(Link link) {
Saurav Dasb149be12016-06-07 10:08:06 -07001321 log.info("** LINK REMOVED {}", link.toString());
Saurav Das04944532017-12-19 16:08:42 -08001322 if (!isLinkValid(link)) {
1323 return;
1324 }
Saurav Das62ae6792017-05-15 15:34:25 -07001325 defaultRoutingHandler.populateRoutingRulesForLinkStatusChange(link, null, null);
1326
1327 // update local groupHandler stores
sangho2165d222015-05-01 09:38:25 -07001328 DefaultGroupHandler groupHandler = groupHandlerMap.get(link.src().deviceId());
1329 if (groupHandler != null) {
Saurav Das62ae6792017-05-15 15:34:25 -07001330 if (mastershipService.isLocalMaster(link.src().deviceId()) &&
1331 isParallelLink(link)) {
Saurav Dasfe0b05e2017-08-14 16:44:43 -07001332 log.debug("* retrying hash for parallel link removed:{}", link);
Saurav Das62ae6792017-05-15 15:34:25 -07001333 groupHandler.retryHash(link, true, false);
Saurav Dasfe0b05e2017-08-14 16:44:43 -07001334 } else {
1335 log.debug("Not attempting retry-hash for link removed: {} .. {}", link,
1336 (mastershipService.isLocalMaster(link.src().deviceId()))
1337 ? "not parallel" : "not master");
Saurav Das62ae6792017-05-15 15:34:25 -07001338 }
1339 // ensure local stores are updated
1340 groupHandler.portDown(link.src().port());
1341 } else {
1342 log.warn("group handler not found for dev:{} when removing link: {}",
1343 link.src().deviceId(), link);
sangho2165d222015-05-01 09:38:25 -07001344 }
Charles Chan72779502016-04-23 17:36:10 -07001345
1346 mcastHandler.processLinkDown(link);
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -07001347 l2TunnelHandler.processLinkDown(link);
sangho80f11cb2015-04-01 13:05:26 -07001348 }
1349
Saurav Das04944532017-12-19 16:08:42 -08001350 private boolean isLinkValid(Link link) {
1351 if (link.type() != Link.Type.DIRECT) {
1352 // NOTE: A DIRECT link might be transiently marked as INDIRECT
1353 // if BDDP is received before LLDP. We can safely ignore that
1354 // until the LLDP is received and the link is marked as DIRECT.
1355 log.info("Ignore link {}->{}. Link type is {} instead of DIRECT.",
1356 link.src(), link.dst(), link.type());
1357 return false;
1358 }
1359 DeviceId srcId = link.src().deviceId();
1360 DeviceId dstId = link.dst().deviceId();
1361 if (srcId.equals(dstId)) {
1362 log.warn("Links between ports on the same switch are not "
1363 + "allowed .. ignoring link {}", link);
1364 return false;
1365 }
1366 try {
1367 if (!deviceConfiguration.isEdgeDevice(srcId)
1368 && !deviceConfiguration.isEdgeDevice(dstId)) {
1369 // ignore links between spines
1370 // XXX revisit when handling multi-stage fabrics
1371 log.warn("Links between spines not allowed...ignoring "
1372 + "link {}", link);
1373 return false;
1374 }
1375 if (deviceConfiguration.isEdgeDevice(srcId)
1376 && deviceConfiguration.isEdgeDevice(dstId)) {
1377 // ignore links between leaves if they are not pair-links
1378 // XXX revisit if removing pair-link config or allowing more than
1379 // one pair-link
1380 if (deviceConfiguration.getPairDeviceId(srcId).equals(dstId)
1381 && deviceConfiguration.getPairLocalPort(srcId)
1382 .equals(link.src().port())
1383 && deviceConfiguration.getPairLocalPort(dstId)
1384 .equals(link.dst().port())) {
1385 // found pair link - allow it
1386 return true;
1387 } else {
1388 log.warn("Links between leaves other than pair-links are "
1389 + "not allowed...ignoring link {}", link);
1390 return false;
1391 }
1392 }
1393 } catch (DeviceConfigNotFoundException e) {
1394 // We still want to count the links in seenLinks even though there
1395 // is no config. So we let it return true
1396 log.warn("Could not check validity of link {} as subtending devices "
1397 + "are not yet configured", link);
1398 }
1399 return true;
1400 }
1401
sangho80f11cb2015-04-01 13:05:26 -07001402 private void processDeviceAdded(Device device) {
Saurav Dasb149be12016-06-07 10:08:06 -07001403 log.info("** DEVICE ADDED with ID {}", device.id());
Charles Chan9bd6aea2017-06-27 18:48:32 -07001404
1405 // NOTE: Punt ARP/NDP even when the device is not configured.
1406 // Host learning without network config is required for CORD config generator.
1407 routingRulePopulator.populateIpPunts(device.id());
1408 routingRulePopulator.populateArpNdpPunts(device.id());
1409
Charles Chan319d1a22015-11-03 10:42:14 -08001410 if (deviceConfiguration == null || !deviceConfiguration.isConfigured(device.id())) {
Saurav Das261c3002017-06-13 15:35:54 -07001411 log.warn("Device configuration unavailable. Device {} will be "
1412 + "processed after configuration.", device.id());
Saurav Das8ec0ec42015-11-03 14:39:27 -08001413 return;
1414 }
Charles Chan72779502016-04-23 17:36:10 -07001415 processDeviceAddedInternal(device.id());
1416 }
1417
1418 private void processDeviceAddedInternal(DeviceId deviceId) {
Saurav Dasc28b3432015-10-30 17:45:38 -07001419 // Irrespective of whether the local is a MASTER or not for this device,
1420 // we need to create a SR-group-handler instance. This is because in a
1421 // multi-instance setup, any instance can initiate forwarding/next-objectives
1422 // for any switch (even if this instance is a SLAVE or not even connected
1423 // to the switch). To handle this, a default-group-handler instance is necessary
1424 // per switch.
Charles Chan72779502016-04-23 17:36:10 -07001425 log.debug("Current groupHandlerMap devs: {}", groupHandlerMap.keySet());
1426 if (groupHandlerMap.get(deviceId) == null) {
Charles Chan319d1a22015-11-03 10:42:14 -08001427 DefaultGroupHandler groupHandler;
1428 try {
1429 groupHandler = DefaultGroupHandler.
Charles Chan72779502016-04-23 17:36:10 -07001430 createGroupHandler(deviceId,
1431 appId,
1432 deviceConfiguration,
1433 linkService,
1434 flowObjectiveService,
1435 this);
Charles Chan319d1a22015-11-03 10:42:14 -08001436 } catch (DeviceConfigNotFoundException e) {
1437 log.warn(e.getMessage() + " Aborting processDeviceAdded.");
1438 return;
1439 }
Saurav Das2b6a00f2017-12-05 15:00:23 -08001440 log.debug("updating groupHandlerMap with new grpHdlr for device: {}",
Charles Chan72779502016-04-23 17:36:10 -07001441 deviceId);
1442 groupHandlerMap.put(deviceId, groupHandler);
Saurav Das8ec0ec42015-11-03 14:39:27 -08001443 }
Saurav Dasb149be12016-06-07 10:08:06 -07001444
Charles Chan72779502016-04-23 17:36:10 -07001445 if (mastershipService.isLocalMaster(deviceId)) {
Saurav Dasf9332192017-02-18 14:05:44 -08001446 defaultRoutingHandler.populatePortAddressingRules(deviceId);
Charles Chandebfea32016-10-24 14:52:01 -07001447 hostHandler.init(deviceId);
Charles Chan82f19972016-05-17 13:13:55 -07001448 xConnectHandler.init(deviceId);
Charles Chan72779502016-04-23 17:36:10 -07001449 DefaultGroupHandler groupHandler = groupHandlerMap.get(deviceId);
Charles Chan10b0fb72017-02-02 16:20:42 -08001450 groupHandler.createGroupsFromVlanConfig();
Charles Chan72779502016-04-23 17:36:10 -07001451 routingRulePopulator.populateSubnetBroadcastRule(deviceId);
Charles Chan77277672015-10-20 16:24:19 -07001452 }
Charles Chan82ab1932016-01-30 23:22:37 -08001453
Charles Chandebfea32016-10-24 14:52:01 -07001454 appCfgHandler.init(deviceId);
1455 routeHandler.init(deviceId);
sangho80f11cb2015-04-01 13:05:26 -07001456 }
1457
Saurav Dasc3604f12016-03-23 11:22:49 -07001458 private void processDeviceRemoved(Device device) {
Saurav Das261c3002017-06-13 15:35:54 -07001459 dsNextObjStore.entrySet().stream()
Saurav Dasc3604f12016-03-23 11:22:49 -07001460 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
Charles Chan873661e2017-11-30 15:37:50 -08001461 .forEach(entry -> dsNextObjStore.remove(entry.getKey()));
Charles Chan10b0fb72017-02-02 16:20:42 -08001462 vlanNextObjStore.entrySet().stream()
Saurav Dasc3604f12016-03-23 11:22:49 -07001463 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
Charles Chan3ed34d82017-06-22 18:03:14 -07001464 .forEach(entry -> vlanNextObjStore.remove(entry.getKey()));
Saurav Dasc3604f12016-03-23 11:22:49 -07001465 portNextObjStore.entrySet().stream()
1466 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
Charles Chan3ed34d82017-06-22 18:03:14 -07001467 .forEach(entry -> portNextObjStore.remove(entry.getKey()));
Charles Chan17d75d82017-06-15 00:44:51 -07001468
1469 seenLinks.keySet().removeIf(key -> key.src().deviceId().equals(device.id()) ||
1470 key.dst().deviceId().equals(device.id()));
1471
Saurav Dasfbe74572017-08-03 18:30:35 -07001472 DefaultGroupHandler gh = groupHandlerMap.remove(device.id());
1473 if (gh != null) {
1474 gh.shutdown();
1475 }
Saurav Dasc3604f12016-03-23 11:22:49 -07001476 defaultRoutingHandler.purgeEcmpGraph(device.id());
Saurav Das62ae6792017-05-15 15:34:25 -07001477 // Note that a switch going down is associated with all of its links
1478 // going down as well, but it is treated as a single switch down event
1479 // while the link-downs are ignored.
1480 defaultRoutingHandler
1481 .populateRoutingRulesForLinkStatusChange(null, null, device.id());
Charles Chan72779502016-04-23 17:36:10 -07001482 mcastHandler.removeDevice(device.id());
Charles Chan82f19972016-05-17 13:13:55 -07001483 xConnectHandler.removeDevice(device.id());
Saurav Dasc3604f12016-03-23 11:22:49 -07001484 }
1485
Saurav Dasf0f592d2016-11-18 15:21:57 -08001486 private void processPortUpdated(Device device, Port port) {
1487 if (deviceConfiguration == null || !deviceConfiguration.isConfigured(device.id())) {
1488 log.warn("Device configuration uploading. Not handling port event for"
1489 + "dev: {} port: {}", device.id(), port.number());
1490 return;
1491 }
Saurav Dasf9332192017-02-18 14:05:44 -08001492
1493 if (!mastershipService.isLocalMaster(device.id())) {
1494 log.debug("Not master for dev:{} .. not handling port updated event"
1495 + "for port {}", device.id(), port.number());
1496 return;
1497 }
1498
1499 // first we handle filtering rules associated with the port
1500 if (port.isEnabled()) {
1501 log.info("Switchport {}/{} enabled..programming filters",
1502 device.id(), port.number());
Charles Chan43be46b2017-02-26 22:59:35 -08001503 routingRulePopulator.processSinglePortFilters(device.id(), port.number(), true);
Saurav Dasf9332192017-02-18 14:05:44 -08001504 } else {
1505 log.info("Switchport {}/{} disabled..removing filters",
1506 device.id(), port.number());
Charles Chan43be46b2017-02-26 22:59:35 -08001507 routingRulePopulator.processSinglePortFilters(device.id(), port.number(), false);
Saurav Dasf9332192017-02-18 14:05:44 -08001508 }
Saurav Dasf0f592d2016-11-18 15:21:57 -08001509
1510 // portUpdated calls are for ports that have gone down or up. For switch
1511 // to switch ports, link-events should take care of any re-routing or
1512 // group editing necessary for port up/down. Here we only process edge ports
1513 // that are already configured.
Saurav Das3fb28272017-03-04 16:08:47 -08001514 ConnectPoint cp = new ConnectPoint(device.id(), port.number());
1515 VlanId untaggedVlan = getUntaggedVlanId(cp);
1516 VlanId nativeVlan = getNativeVlanId(cp);
1517 Set<VlanId> taggedVlans = getTaggedVlanId(cp);
Charles Chan10b0fb72017-02-02 16:20:42 -08001518
Saurav Das3fb28272017-03-04 16:08:47 -08001519 if (untaggedVlan == null && nativeVlan == null && taggedVlans.isEmpty()) {
Saurav Das62ae6792017-05-15 15:34:25 -07001520 log.debug("Not handling port updated event for non-edge port (unconfigured) "
Saurav Dasf0f592d2016-11-18 15:21:57 -08001521 + "dev/port: {}/{}", device.id(), port.number());
1522 return;
1523 }
Saurav Das3fb28272017-03-04 16:08:47 -08001524 if (untaggedVlan != null) {
1525 processEdgePort(device, port, untaggedVlan, true);
1526 }
1527 if (nativeVlan != null) {
1528 processEdgePort(device, port, nativeVlan, true);
1529 }
1530 if (!taggedVlans.isEmpty()) {
1531 taggedVlans.forEach(tag -> processEdgePort(device, port, tag, false));
1532 }
Saurav Dasf0f592d2016-11-18 15:21:57 -08001533 }
1534
Saurav Das3fb28272017-03-04 16:08:47 -08001535 private void processEdgePort(Device device, Port port, VlanId vlanId,
1536 boolean popVlan) {
Saurav Dasf0f592d2016-11-18 15:21:57 -08001537 boolean portUp = port.isEnabled();
1538 if (portUp) {
Saurav Das3fb28272017-03-04 16:08:47 -08001539 log.info("Device:EdgePort {}:{} is enabled in vlan: {}", device.id(),
Charles Chan10b0fb72017-02-02 16:20:42 -08001540 port.number(), vlanId);
Charles Chan873661e2017-11-30 15:37:50 -08001541 hostHandler.processPortUp(new ConnectPoint(device.id(), port.number()));
Saurav Dasf0f592d2016-11-18 15:21:57 -08001542 } else {
Saurav Das3fb28272017-03-04 16:08:47 -08001543 log.info("Device:EdgePort {}:{} is disabled in vlan: {}", device.id(),
Charles Chan10b0fb72017-02-02 16:20:42 -08001544 port.number(), vlanId);
Saurav Dasf0f592d2016-11-18 15:21:57 -08001545 }
1546
Srikanth Vavilapalli64505482015-04-21 13:04:13 -07001547 DefaultGroupHandler groupHandler = groupHandlerMap.get(device.id());
sangho80f11cb2015-04-01 13:05:26 -07001548 if (groupHandler != null) {
Saurav Das3fb28272017-03-04 16:08:47 -08001549 groupHandler.processEdgePort(port.number(), vlanId, popVlan, portUp);
Saurav Dasf0f592d2016-11-18 15:21:57 -08001550 } else {
1551 log.warn("Group handler not found for dev:{}. Not handling edge port"
1552 + " {} event for port:{}", device.id(),
1553 (portUp) ? "UP" : "DOWN", port.number());
sangho80f11cb2015-04-01 13:05:26 -07001554 }
1555 }
sangho27462c62015-05-14 00:39:53 -07001556
Charles Chan8ca5a122017-10-20 16:06:55 -07001557 private void createOrUpdateDeviceConfiguration() {
1558 if (deviceConfiguration == null) {
1559 deviceConfiguration = new DeviceConfiguration(this);
1560 } else {
1561 deviceConfiguration.updateConfig();
1562 }
1563 }
1564
Pier Ventreb6a7f342016-11-26 21:05:22 -08001565 /**
1566 * Registers the given connect point with the NRS, this is necessary
1567 * to receive the NDP and ARP packets from the NRS.
1568 *
1569 * @param portToRegister connect point to register
1570 */
1571 public void registerConnectPoint(ConnectPoint portToRegister) {
Charles Chan2e71ef32017-02-23 15:44:08 -08001572 neighbourResolutionService.registerNeighbourHandler(
Pier Ventreb6a7f342016-11-26 21:05:22 -08001573 portToRegister,
1574 neighbourHandler,
1575 appId
1576 );
1577 }
1578
Charles Chan72f556a2015-10-05 17:50:33 -07001579 private class InternalConfigListener implements NetworkConfigListener {
Saurav Das261c3002017-06-13 15:35:54 -07001580 private static final long PROGRAM_DELAY = 2;
Charles Chan46fdfaf2016-11-09 20:51:44 -08001581 SegmentRoutingManager srManager;
Charles Chane7c61022015-10-07 14:21:45 -07001582
Charles Chanb7f75ac2016-01-11 18:28:54 -08001583 /**
1584 * Constructs the internal network config listener.
1585 *
Charles Chan46fdfaf2016-11-09 20:51:44 -08001586 * @param srManager segment routing manager
Charles Chanb7f75ac2016-01-11 18:28:54 -08001587 */
Charles Chan3ed34d82017-06-22 18:03:14 -07001588 InternalConfigListener(SegmentRoutingManager srManager) {
Charles Chan46fdfaf2016-11-09 20:51:44 -08001589 this.srManager = srManager;
Charles Chane7c61022015-10-07 14:21:45 -07001590 }
1591
Charles Chanb7f75ac2016-01-11 18:28:54 -08001592 /**
1593 * Reads network config and initializes related data structure accordingly.
1594 */
Charles Chan873661e2017-11-30 15:37:50 -08001595 void configureNetwork() {
Charles Chan8ca5a122017-10-20 16:06:55 -07001596 createOrUpdateDeviceConfiguration();
Charles Chane7c61022015-10-07 14:21:45 -07001597
Charles Chan46fdfaf2016-11-09 20:51:44 -08001598 arpHandler = new ArpHandler(srManager);
1599 icmpHandler = new IcmpHandler(srManager);
1600 ipHandler = new IpHandler(srManager);
1601 routingRulePopulator = new RoutingRulePopulator(srManager);
1602 defaultRoutingHandler = new DefaultRoutingHandler(srManager);
Charles Chane7c61022015-10-07 14:21:45 -07001603
1604 tunnelHandler = new TunnelHandler(linkService, deviceConfiguration,
1605 groupHandlerMap, tunnelStore);
1606 policyHandler = new PolicyHandler(appId, deviceConfiguration,
1607 flowObjectiveService,
1608 tunnelHandler, policyStore);
Saurav Das261c3002017-06-13 15:35:54 -07001609 // add a small delay to absorb multiple network config added notifications
1610 if (!programmingScheduled.get()) {
1611 programmingScheduled.set(true);
1612 executorService.schedule(new ConfigChange(), PROGRAM_DELAY,
1613 TimeUnit.SECONDS);
Charles Chane7c61022015-10-07 14:21:45 -07001614 }
Charles Chan72779502016-04-23 17:36:10 -07001615 mcastHandler.init();
Charles Chane7c61022015-10-07 14:21:45 -07001616 }
1617
Charles Chan72f556a2015-10-05 17:50:33 -07001618 @Override
1619 public void event(NetworkConfigEvent event) {
Charles Chan82ab1932016-01-30 23:22:37 -08001620 // TODO move this part to NetworkConfigEventHandler
1621 if (event.configClass().equals(SegmentRoutingDeviceConfig.class)) {
1622 switch (event.type()) {
1623 case CONFIG_ADDED:
Charles Chan68363b12017-06-26 15:25:09 -07001624 log.info("Segment Routing Device Config added for {}", event.subject());
Charles Chan82ab1932016-01-30 23:22:37 -08001625 configureNetwork();
1626 break;
1627 case CONFIG_UPDATED:
Charles Chan68363b12017-06-26 15:25:09 -07001628 log.info("Segment Routing Config updated for {}", event.subject());
Charles Chan8ca5a122017-10-20 16:06:55 -07001629 createOrUpdateDeviceConfiguration();
Charles Chan68363b12017-06-26 15:25:09 -07001630 // TODO support dynamic configuration
1631 break;
1632 default:
1633 break;
1634 }
1635 } else if (event.configClass().equals(InterfaceConfig.class)) {
1636 switch (event.type()) {
1637 case CONFIG_ADDED:
1638 log.info("Interface Config added for {}", event.subject());
1639 configureNetwork();
1640 break;
1641 case CONFIG_UPDATED:
1642 log.info("Interface Config updated for {}", event.subject());
Charles Chan8ca5a122017-10-20 16:06:55 -07001643 createOrUpdateDeviceConfiguration();
Jonghwan Hyune5ef7622017-08-25 17:48:36 -07001644
1645 // Following code will be uncommented when [CORD-634] is fully implemented.
1646 // [CORD-634] Add dynamic config support for interfaces
1647 updateInterface((InterfaceConfig) event.config().get(),
1648 (InterfaceConfig) event.prevConfig().get());
Charles Chan82ab1932016-01-30 23:22:37 -08001649 // TODO support dynamic configuration
1650 break;
1651 default:
1652 break;
Charles Chan2b078ae2015-10-14 11:24:40 -07001653 }
Charles Chan82ab1932016-01-30 23:22:37 -08001654 } else if (event.configClass().equals(SegmentRoutingAppConfig.class)) {
Charles Chan82f19972016-05-17 13:13:55 -07001655 checkState(appCfgHandler != null, "NetworkConfigEventHandler is not initialized");
Charles Chan82ab1932016-01-30 23:22:37 -08001656 switch (event.type()) {
1657 case CONFIG_ADDED:
Charles Chan82f19972016-05-17 13:13:55 -07001658 appCfgHandler.processAppConfigAdded(event);
Charles Chan82ab1932016-01-30 23:22:37 -08001659 break;
1660 case CONFIG_UPDATED:
Charles Chan82f19972016-05-17 13:13:55 -07001661 appCfgHandler.processAppConfigUpdated(event);
Charles Chan82ab1932016-01-30 23:22:37 -08001662 break;
1663 case CONFIG_REMOVED:
Charles Chan82f19972016-05-17 13:13:55 -07001664 appCfgHandler.processAppConfigRemoved(event);
1665 break;
1666 default:
1667 break;
1668 }
Charles Chandebfea32016-10-24 14:52:01 -07001669 configureNetwork();
Charles Chan82f19972016-05-17 13:13:55 -07001670 } else if (event.configClass().equals(XConnectConfig.class)) {
1671 checkState(xConnectHandler != null, "XConnectHandler is not initialized");
1672 switch (event.type()) {
1673 case CONFIG_ADDED:
1674 xConnectHandler.processXConnectConfigAdded(event);
1675 break;
1676 case CONFIG_UPDATED:
1677 xConnectHandler.processXConnectConfigUpdated(event);
1678 break;
1679 case CONFIG_REMOVED:
1680 xConnectHandler.processXConnectConfigRemoved(event);
Charles Chan82ab1932016-01-30 23:22:37 -08001681 break;
1682 default:
1683 break;
Charles Chan2b078ae2015-10-14 11:24:40 -07001684 }
Pier Ventre6b19e482016-11-07 16:21:04 -08001685 } else if (event.configClass().equals(PwaasConfig.class)) {
1686 checkState(l2TunnelHandler != null, "L2TunnelHandler is not initialized");
1687 switch (event.type()) {
1688 case CONFIG_ADDED:
1689 l2TunnelHandler.processPwaasConfigAdded(event);
1690 break;
1691 case CONFIG_UPDATED:
1692 l2TunnelHandler.processPwaasConfigUpdated(event);
1693 break;
1694 case CONFIG_REMOVED:
1695 l2TunnelHandler.processPwaasConfigRemoved(event);
1696 break;
1697 default:
1698 break;
1699 }
Charles Chan72f556a2015-10-05 17:50:33 -07001700 }
1701 }
Saurav Das261c3002017-06-13 15:35:54 -07001702
Charles Chanc4a68c32018-01-03 16:26:32 -08001703 @Override
1704 public boolean isRelevant(NetworkConfigEvent event) {
1705 if (event.configClass().equals(SegmentRoutingDeviceConfig.class) ||
1706 event.configClass().equals(SegmentRoutingAppConfig.class) ||
1707 event.configClass().equals(InterfaceConfig.class) ||
1708 event.configClass().equals(XConnectConfig.class) ||
1709 event.configClass().equals(PwaasConfig.class)) {
1710 return true;
1711 }
1712 log.debug("Ignore irrelevant event class {}", event.configClass().getName());
1713 return false;
1714 }
1715
Saurav Das261c3002017-06-13 15:35:54 -07001716 private final class ConfigChange implements Runnable {
1717 @Override
1718 public void run() {
1719 programmingScheduled.set(false);
1720 for (Device device : deviceService.getDevices()) {
1721 processDeviceAdded(device);
1722 }
1723 defaultRoutingHandler.startPopulationProcess();
1724 }
1725 }
Charles Chan72f556a2015-10-05 17:50:33 -07001726 }
Charles Chanf4586112015-11-09 16:37:23 -08001727
1728 private class InternalHostListener implements HostListener {
Charles Chanf4586112015-11-09 16:37:23 -08001729 @Override
1730 public void event(HostEvent event) {
Charles Chanf4586112015-11-09 16:37:23 -08001731 switch (event.type()) {
1732 case HOST_ADDED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001733 hostHandler.processHostAddedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001734 break;
1735 case HOST_MOVED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001736 hostHandler.processHostMovedEvent(event);
Charles Chan910be6a2017-08-23 14:46:43 -07001737 routeHandler.processHostMovedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001738 break;
1739 case HOST_REMOVED:
Charles Chand9265a32017-06-16 15:19:24 -07001740 hostHandler.processHostRemovedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001741 break;
1742 case HOST_UPDATED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001743 hostHandler.processHostUpdatedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001744 break;
1745 default:
1746 log.warn("Unsupported host event type: {}", event.type());
1747 break;
1748 }
1749 }
1750 }
1751
Charles Chanc91c8782016-03-30 17:54:24 -07001752 private class InternalMcastListener implements McastListener {
1753 @Override
1754 public void event(McastEvent event) {
1755 switch (event.type()) {
1756 case SOURCE_ADDED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001757 mcastHandler.processSourceAdded(event);
Charles Chanc91c8782016-03-30 17:54:24 -07001758 break;
1759 case SINK_ADDED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001760 mcastHandler.processSinkAdded(event);
Charles Chanc91c8782016-03-30 17:54:24 -07001761 break;
1762 case SINK_REMOVED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001763 mcastHandler.processSinkRemoved(event);
Charles Chanc91c8782016-03-30 17:54:24 -07001764 break;
1765 case ROUTE_ADDED:
1766 case ROUTE_REMOVED:
1767 default:
1768 break;
1769 }
1770 }
1771 }
Charles Chan41f5ec02016-06-13 18:54:31 -07001772
Charles Chandebfea32016-10-24 14:52:01 -07001773 private class InternalRouteEventListener implements RouteListener {
1774 @Override
1775 public void event(RouteEvent event) {
1776 switch (event.type()) {
1777 case ROUTE_ADDED:
1778 routeHandler.processRouteAdded(event);
1779 break;
1780 case ROUTE_UPDATED:
1781 routeHandler.processRouteUpdated(event);
1782 break;
1783 case ROUTE_REMOVED:
1784 routeHandler.processRouteRemoved(event);
1785 break;
Charles Chan910be6a2017-08-23 14:46:43 -07001786 case ALTERNATIVE_ROUTES_CHANGED:
1787 routeHandler.processAlternativeRoutesChanged(event);
1788 break;
Charles Chandebfea32016-10-24 14:52:01 -07001789 default:
1790 break;
1791 }
1792 }
1793 }
Saurav Das62ae6792017-05-15 15:34:25 -07001794
Jonghwan Hyune5ef7622017-08-25 17:48:36 -07001795 private void updateInterface(InterfaceConfig conf, InterfaceConfig prevConf) {
1796 try {
1797 Set<Interface> intfs = conf.getInterfaces();
1798 Set<Interface> prevIntfs = prevConf.getInterfaces();
1799
1800 // Now we only handle one interface config at each port.
1801 if (intfs.size() != 1 || prevIntfs.size() != 1) {
1802 log.warn("Interface update aborted - one at a time is allowed, " +
1803 "but {} / {}(prev) received.", intfs.size(), prevIntfs.size());
1804 return;
1805 }
1806
1807 Interface intf = intfs.stream().findFirst().get();
1808 Interface prevIntf = prevIntfs.stream().findFirst().get();
1809
1810 DeviceId deviceId = intf.connectPoint().deviceId();
1811 PortNumber portNum = intf.connectPoint().port();
1812
1813 if (!mastershipService.isLocalMaster(deviceId)) {
1814 log.debug("CONFIG_UPDATED event for interfaces should be " +
1815 "handled by master node for device {}", deviceId);
1816 return;
1817 }
1818
1819 removeSubnetConfig(prevIntf.connectPoint(),
1820 Sets.difference(new HashSet<>(prevIntf.ipAddressesList()),
1821 new HashSet<>(intf.ipAddressesList())));
1822
1823 if (prevIntf.vlanNative() != VlanId.NONE && !intf.vlanNative().equals(prevIntf.vlanNative())) {
1824 // RemoveVlanNative
1825 updateVlanConfigInternal(deviceId, portNum, prevIntf.vlanNative(), true, false);
1826 }
1827
1828 if (!prevIntf.vlanTagged().isEmpty() && !intf.vlanTagged().equals(prevIntf.vlanTagged())) {
1829 // RemoveVlanTagged
1830 prevIntf.vlanTagged().stream().filter(i -> !intf.vlanTagged().contains(i)).forEach(
1831 vlanId -> updateVlanConfigInternal(deviceId, portNum, vlanId, false, false)
1832 );
1833 }
1834
1835 if (prevIntf.vlanUntagged() != VlanId.NONE && !intf.vlanUntagged().equals(prevIntf.vlanUntagged())) {
1836 // RemoveVlanUntagged
1837 updateVlanConfigInternal(deviceId, portNum, prevIntf.vlanUntagged(), true, false);
1838 }
1839
1840 if (intf.vlanNative() != VlanId.NONE && !prevIntf.vlanNative().equals(intf.vlanNative())) {
1841 // AddVlanNative
1842 updateVlanConfigInternal(deviceId, portNum, intf.vlanNative(), true, true);
1843 }
1844
1845 if (!intf.vlanTagged().isEmpty() && !intf.vlanTagged().equals(prevIntf.vlanTagged())) {
1846 // AddVlanTagged
1847 intf.vlanTagged().stream().filter(i -> !prevIntf.vlanTagged().contains(i)).forEach(
1848 vlanId -> updateVlanConfigInternal(deviceId, portNum, vlanId, false, true)
1849 );
1850 }
1851
1852 if (intf.vlanUntagged() != VlanId.NONE && !prevIntf.vlanUntagged().equals(intf.vlanUntagged())) {
1853 // AddVlanUntagged
1854 updateVlanConfigInternal(deviceId, portNum, intf.vlanUntagged(), true, true);
1855 }
1856 addSubnetConfig(prevIntf.connectPoint(),
1857 Sets.difference(new HashSet<>(intf.ipAddressesList()),
1858 new HashSet<>(prevIntf.ipAddressesList())));
1859 } catch (ConfigException e) {
1860 log.error("Error in configuration");
1861 }
1862 }
1863
1864 private void updateVlanConfigInternal(DeviceId deviceId, PortNumber portNum,
1865 VlanId vlanId, boolean pushVlan, boolean install) {
1866 DefaultGroupHandler grpHandler = getGroupHandler(deviceId);
1867 if (grpHandler == null) {
1868 log.warn("Failed to retrieve group handler for device {}", deviceId);
1869 return;
1870 }
1871
1872 // Update filtering objective for a single port
1873 routingRulePopulator.updateSinglePortFilters(deviceId, portNum, pushVlan, vlanId, install);
1874
1875 // Update filtering objective for multicast ingress port
1876 mcastHandler.updateFilterToDevice(deviceId, portNum, vlanId, install);
1877
1878 int nextId = getVlanNextObjectiveId(deviceId, vlanId);
1879
1880 if (nextId != -1 && !install) {
1881 // Update next objective for a single port as an output port
1882 // Remove a single port from L2FG
1883 grpHandler.updateGroupFromVlanConfiguration(portNum, Collections.singleton(vlanId), nextId, install);
1884 // Remove L2 Bridging rule and L3 Unicast rule to the host
1885 hostHandler.processIntfVlanUpdatedEvent(deviceId, portNum, vlanId, pushVlan, install);
1886 // Remove broadcast forwarding rule and corresponding L2FG for VLAN
1887 // only if there is no port configured on that VLAN ID
1888 if (!getVlanPortMap(deviceId).containsKey(vlanId)) {
1889 // Remove broadcast forwarding rule for the VLAN
1890 routingRulePopulator.updateSubnetBroadcastRule(deviceId, vlanId, install);
1891 // Remove L2FG for VLAN
1892 grpHandler.removeBcastGroupFromVlan(deviceId, portNum, vlanId, pushVlan);
1893 } else {
1894 // Remove L2IG of the port
1895 grpHandler.removePortNextObjective(deviceId, portNum, vlanId, pushVlan);
1896 }
1897 } else if (install) {
1898 if (nextId != -1) {
1899 // Add a single port to L2FG
1900 grpHandler.updateGroupFromVlanConfiguration(portNum, Collections.singleton(vlanId), nextId, install);
1901 } else {
1902 // Create L2FG for VLAN
1903 grpHandler.createBcastGroupFromVlan(vlanId, Collections.singleton(portNum));
1904 routingRulePopulator.updateSubnetBroadcastRule(deviceId, vlanId, install);
1905 }
1906 hostHandler.processIntfVlanUpdatedEvent(deviceId, portNum, vlanId, pushVlan, install);
1907 } else {
1908 log.warn("Failed to retrieve next objective for vlan {} in device {}:{}", vlanId, deviceId, portNum);
1909 }
1910 }
1911
1912 private void removeSubnetConfig(ConnectPoint cp, Set<InterfaceIpAddress> ipAddressSet) {
1913 Set<IpPrefix> ipPrefixSet = ipAddressSet.stream().
1914 map(InterfaceIpAddress::subnetAddress).collect(Collectors.toSet());
1915
1916 Set<InterfaceIpAddress> deviceIntfIpAddrs = interfaceService.getInterfaces().stream()
1917 .filter(intf -> intf.connectPoint().deviceId().equals(cp.deviceId()))
1918 .filter(intf -> !intf.connectPoint().equals(cp))
1919 .flatMap(intf -> intf.ipAddressesList().stream())
1920 .collect(Collectors.toSet());
1921 // 1. Partial subnet population
1922 // Remove routing rules for removed subnet from previous configuration,
1923 // which does not also exist in other interfaces in the same device
1924 Set<IpPrefix> deviceIpPrefixSet = deviceIntfIpAddrs.stream()
1925 .map(InterfaceIpAddress::subnetAddress)
1926 .collect(Collectors.toSet());
1927
1928 defaultRoutingHandler.revokeSubnet(
1929 ipPrefixSet.stream()
1930 .filter(ipPrefix -> !deviceIpPrefixSet.contains(ipPrefix))
1931 .collect(Collectors.toSet()));
1932
1933 // 2. Interface IP punts
1934 // Remove IP punts for old Intf address
1935 Set<IpAddress> deviceIpAddrs = deviceIntfIpAddrs.stream()
1936 .map(InterfaceIpAddress::ipAddress)
1937 .collect(Collectors.toSet());
1938 ipAddressSet.stream()
1939 .map(InterfaceIpAddress::ipAddress)
1940 .filter(interfaceIpAddress -> !deviceIpAddrs.contains(interfaceIpAddress))
1941 .forEach(interfaceIpAddress ->
1942 routingRulePopulator.revokeSingleIpPunts(
1943 cp.deviceId(), interfaceIpAddress));
1944
1945 // 3. Host unicast routing rule
1946 // Remove unicast routing rule
1947 hostHandler.processIntfIpUpdatedEvent(cp, ipPrefixSet, false);
1948 }
1949
1950 private void addSubnetConfig(ConnectPoint cp, Set<InterfaceIpAddress> ipAddressSet) {
1951 Set<IpPrefix> ipPrefixSet = ipAddressSet.stream().
1952 map(InterfaceIpAddress::subnetAddress).collect(Collectors.toSet());
1953
1954 Set<InterfaceIpAddress> deviceIntfIpAddrs = interfaceService.getInterfaces().stream()
1955 .filter(intf -> intf.connectPoint().deviceId().equals(cp.deviceId()))
1956 .filter(intf -> !intf.connectPoint().equals(cp))
1957 .flatMap(intf -> intf.ipAddressesList().stream())
1958 .collect(Collectors.toSet());
1959 // 1. Partial subnet population
1960 // Add routing rules for newly added subnet, which does not also exist in
1961 // other interfaces in the same device
1962 Set<IpPrefix> deviceIpPrefixSet = deviceIntfIpAddrs.stream()
1963 .map(InterfaceIpAddress::subnetAddress)
1964 .collect(Collectors.toSet());
1965
1966 defaultRoutingHandler.populateSubnet(
1967 Collections.singleton(cp),
1968 ipPrefixSet.stream()
1969 .filter(ipPrefix -> !deviceIpPrefixSet.contains(ipPrefix))
1970 .collect(Collectors.toSet()));
1971
1972 // 2. Interface IP punts
1973 // Add IP punts for new Intf address
1974 Set<IpAddress> deviceIpAddrs = deviceIntfIpAddrs.stream()
1975 .map(InterfaceIpAddress::ipAddress)
1976 .collect(Collectors.toSet());
1977 ipAddressSet.stream()
1978 .map(InterfaceIpAddress::ipAddress)
1979 .filter(interfaceIpAddress -> !deviceIpAddrs.contains(interfaceIpAddress))
1980 .forEach(interfaceIpAddress ->
1981 routingRulePopulator.populateSingleIpPunts(
1982 cp.deviceId(), interfaceIpAddress));
1983
1984 // 3. Host unicast routing rule
1985 // Add unicast routing rule
1986 hostHandler.processIntfIpUpdatedEvent(cp, ipPrefixSet, true);
1987 }
sangho80f11cb2015-04-01 13:05:26 -07001988}