blob: 7a17d39c1a5e0c58e7cd9fe18a789807fb691b91 [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
Charles Chan873661e2017-11-30 15:37:50 -080018
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 Chan82ab1932016-01-30 23:22:37 -0800429 hostService.addListener(hostListener);
Charles Chan2b078ae2015-10-14 11:24:40 -0700430 packetService.addProcessor(processor, PacketProcessor.director(2));
431 linkService.addListener(linkListener);
432 deviceService.addListener(deviceListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700433 multicastRouteService.addListener(mcastListener);
Charles Chanfd48c222017-06-19 00:43:31 -0700434 routeService.addListener(routeListener);
Charles Chan2b078ae2015-10-14 11:24:40 -0700435
436 cfgListener.configureNetwork();
437
sangho80f11cb2015-04-01 13:05:26 -0700438 log.info("Started");
439 }
440
Jonathan Hart54541d12016-04-12 15:39:44 -0700441 private KryoNamespace.Builder createSerializer() {
442 return new KryoNamespace.Builder()
443 .register(KryoNamespaces.API)
Saurav Das261c3002017-06-13 15:35:54 -0700444 .register(DestinationSetNextObjectiveStoreKey.class,
Charles Chan10b0fb72017-02-02 16:20:42 -0800445 VlanNextObjectiveStoreKey.class,
Saurav Das261c3002017-06-13 15:35:54 -0700446 DestinationSet.class,
447 NextNeighbors.class,
Jonathan Hart54541d12016-04-12 15:39:44 -0700448 Tunnel.class,
449 DefaultTunnel.class,
450 Policy.class,
451 TunnelPolicy.class,
452 Policy.Type.class,
453 PortNextObjectiveStoreKey.class,
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -0700454 XConnectStoreKey.class,
455 DefaultL2Tunnel.class,
456 DefaultL2TunnelPolicy.class
Jonathan Hart54541d12016-04-12 15:39:44 -0700457 );
458 }
459
sangho80f11cb2015-04-01 13:05:26 -0700460 @Deactivate
461 protected void deactivate() {
Charles Chan72f556a2015-10-05 17:50:33 -0700462 cfgService.removeListener(cfgListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700463 cfgService.unregisterConfigFactory(deviceConfigFactory);
464 cfgService.unregisterConfigFactory(appConfigFactory);
Charles Chandebfea32016-10-24 14:52:01 -0700465 cfgService.unregisterConfigFactory(xConnectConfigFactory);
Charles Chanc91c8782016-03-30 17:54:24 -0700466 cfgService.unregisterConfigFactory(mcastConfigFactory);
Pier Ventre6b19e482016-11-07 16:21:04 -0800467 cfgService.unregisterConfigFactory(pwaasConfigFactory);
Charles Chan873661e2017-11-30 15:37:50 -0800468 compCfgService.unregisterProperties(getClass(), false);
Charles Chan72f556a2015-10-05 17:50:33 -0700469
Charles Chanfd48c222017-06-19 00:43:31 -0700470 hostService.removeListener(hostListener);
sangho80f11cb2015-04-01 13:05:26 -0700471 packetService.removeProcessor(processor);
Charles Chan2b078ae2015-10-14 11:24:40 -0700472 linkService.removeListener(linkListener);
473 deviceService.removeListener(deviceListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700474 multicastRouteService.removeListener(mcastListener);
Charles Chandebfea32016-10-24 14:52:01 -0700475 routeService.removeListener(routeListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700476
Charles Chan2e71ef32017-02-23 15:44:08 -0800477 neighbourResolutionService.unregisterNeighbourHandlers(appId);
478
sangho80f11cb2015-04-01 13:05:26 -0700479 processor = null;
Charles Chan2b078ae2015-10-14 11:24:40 -0700480 linkListener = null;
Charles Chanc91c8782016-03-30 17:54:24 -0700481 deviceListener = null;
Charles Chan2b078ae2015-10-14 11:24:40 -0700482 groupHandlerMap.clear();
483
Saurav Das261c3002017-06-13 15:35:54 -0700484 dsNextObjStore.destroy();
Charles Chan10b0fb72017-02-02 16:20:42 -0800485 vlanNextObjStore.destroy();
Charles Chanc91c8782016-03-30 17:54:24 -0700486 portNextObjStore.destroy();
Charles Chanc91c8782016-03-30 17:54:24 -0700487 tunnelStore.destroy();
488 policyStore.destroy();
sangho80f11cb2015-04-01 13:05:26 -0700489 log.info("Stopped");
490 }
491
Charles Chan873661e2017-11-30 15:37:50 -0800492 @Modified
493 private void modified(ComponentContext context) {
494 Dictionary<?, ?> properties = context.getProperties();
495 if (properties == null) {
496 return;
497 }
498
499 String strActiveProving = Tools.get(properties, "activeProbing");
500 boolean expectActiveProbing = Boolean.parseBoolean(strActiveProving);
501
502 if (expectActiveProbing != activeProbing) {
503 activeProbing = expectActiveProbing;
504 log.info("{} active probing", activeProbing ? "Enabling" : "Disabling");
505 }
506 }
507
sangho27462c62015-05-14 00:39:53 -0700508 @Override
509 public List<Tunnel> getTunnels() {
510 return tunnelHandler.getTunnels();
511 }
512
513 @Override
sanghobd812f82015-06-29 14:58:47 -0700514 public TunnelHandler.Result createTunnel(Tunnel tunnel) {
515 return tunnelHandler.createTunnel(tunnel);
sangho27462c62015-05-14 00:39:53 -0700516 }
517
518 @Override
sanghobd812f82015-06-29 14:58:47 -0700519 public TunnelHandler.Result removeTunnel(Tunnel tunnel) {
sangho27462c62015-05-14 00:39:53 -0700520 for (Policy policy: policyHandler.getPolicies()) {
521 if (policy.type() == Policy.Type.TUNNEL_FLOW) {
522 TunnelPolicy tunnelPolicy = (TunnelPolicy) policy;
523 if (tunnelPolicy.tunnelId().equals(tunnel.id())) {
524 log.warn("Cannot remove the tunnel used by a policy");
sanghobd812f82015-06-29 14:58:47 -0700525 return TunnelHandler.Result.TUNNEL_IN_USE;
sangho27462c62015-05-14 00:39:53 -0700526 }
527 }
528 }
sanghobd812f82015-06-29 14:58:47 -0700529 return tunnelHandler.removeTunnel(tunnel);
sangho27462c62015-05-14 00:39:53 -0700530 }
531
532 @Override
sanghobd812f82015-06-29 14:58:47 -0700533 public PolicyHandler.Result removePolicy(Policy policy) {
534 return policyHandler.removePolicy(policy);
sangho27462c62015-05-14 00:39:53 -0700535 }
536
537 @Override
sanghobd812f82015-06-29 14:58:47 -0700538 public PolicyHandler.Result createPolicy(Policy policy) {
539 return policyHandler.createPolicy(policy);
sangho27462c62015-05-14 00:39:53 -0700540 }
541
542 @Override
543 public List<Policy> getPolicies() {
544 return policyHandler.getPolicies();
545 }
546
Saurav Das07c74602016-04-27 18:35:50 -0700547 @Override
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -0700548 public List<DefaultL2Tunnel> getL2Tunnels() {
549 return l2TunnelHandler.getL2Tunnels();
550 }
551
552 @Override
553 public List<DefaultL2TunnelPolicy> getL2Policies() {
554 return l2TunnelHandler.getL2Policies();
555 }
556
557 @Override
558 public L2TunnelHandler.Result addPseudowire(String tunnelId, String pwLabel, String cP1,
559 String cP1InnerVlan, String cP1OuterVlan, String cP2,
560 String cP2InnerVlan, String cP2OuterVlan,
561 String mode, String sdTag) {
562
563 PwaasConfig config = cfgService.getConfig(appId(), PwaasConfig.class);
564 if (config == null) {
565 log.warn("Configuration for Pwaas class could not be found!");
566 return L2TunnelHandler.Result.CONFIG_NOT_FOUND;
567 }
568
569 ObjectNode object = config.addPseudowire(tunnelId, pwLabel,
570 cP1, cP1InnerVlan, cP1OuterVlan,
571 cP2, cP2InnerVlan, cP2OuterVlan,
572 mode, sdTag);
573 if (object == null) {
574 log.warn("Could not add pseudowire to the configuration!");
575 return L2TunnelHandler.Result.ADDITION_ERROR;
576 }
577
578 // inform everyone about the valid change in the pw configuration
579 cfgService.applyConfig(appId(), PwaasConfig.class, object);
580 return L2TunnelHandler.Result.SUCCESS;
581 }
582
583 @Override
584 public L2TunnelHandler.Result removePseudowire(String pwId) {
585
586 PwaasConfig config = cfgService.getConfig(appId(), PwaasConfig.class);
587 if (config == null) {
588 log.warn("Configuration for Pwaas class could not be found!");
589 return L2TunnelHandler.Result.CONFIG_NOT_FOUND;
590 }
591
592 ObjectNode object = config.removePseudowire(pwId);
593 if (object == null) {
594 log.warn("Could not delete pseudowire from configuration!");
595 return L2TunnelHandler.Result.REMOVAL_ERROR;
596 }
597
598 // sanity check, this should never fail since we removed a pw
599 // and we always check when we update the configuration
600 config.isValid();
601
602 // inform everyone
603 cfgService.applyConfig(appId(), PwaasConfig.class, object);
604
605 return L2TunnelHandler.Result.SUCCESS;
606 }
607
608 @Override
Saurav Das07c74602016-04-27 18:35:50 -0700609 public void rerouteNetwork() {
610 cfgListener.configureNetwork();
Saurav Das07c74602016-04-27 18:35:50 -0700611 }
612
Charles Chand7844e52016-10-20 17:02:44 -0700613 @Override
Pier Ventreb6a7f342016-11-26 21:05:22 -0800614 public Map<DeviceId, Set<IpPrefix>> getDeviceSubnetMap() {
615 Map<DeviceId, Set<IpPrefix>> deviceSubnetMap = Maps.newHashMap();
Jonathan Hart61e24e12017-11-30 18:23:42 -0800616 deviceConfiguration.getRouters().forEach(device ->
617 deviceSubnetMap.put(device, deviceConfiguration.getSubnets(device)));
Charles Chand7844e52016-10-20 17:02:44 -0700618 return deviceSubnetMap;
619 }
620
Saurav Das62ae6792017-05-15 15:34:25 -0700621
622 @Override
623 public ImmutableMap<DeviceId, EcmpShortestPathGraph> getCurrentEcmpSpg() {
624 if (defaultRoutingHandler != null) {
625 return defaultRoutingHandler.getCurrentEmcpSpgMap();
626 } else {
627 return null;
628 }
629 }
630
631 @Override
Saurav Das261c3002017-06-13 15:35:54 -0700632 public ImmutableMap<DestinationSetNextObjectiveStoreKey, NextNeighbors> getDestinationSet() {
633 if (dsNextObjStore != null) {
634 return ImmutableMap.copyOf(dsNextObjStore.entrySet());
Saurav Das62ae6792017-05-15 15:34:25 -0700635 } else {
636 return ImmutableMap.of();
637 }
638 }
639
Saurav Dasfbe74572017-08-03 18:30:35 -0700640 @Override
641 public void verifyGroups(DeviceId id) {
642 DefaultGroupHandler gh = groupHandlerMap.get(id);
643 if (gh != null) {
644 gh.triggerBucketCorrector();
645 }
646 }
647
sangho80f1f892015-05-19 11:57:42 -0700648 /**
Ray Milkeyb85de082017-04-05 09:42:04 -0700649 * Extracts the application ID from the manager.
650 *
651 * @return application ID
652 */
653 public ApplicationId appId() {
654 return appId;
655 }
656
657 /**
658 * Returns the device configuration.
659 *
660 * @return device configuration
661 */
662 public DeviceConfiguration deviceConfiguration() {
663 return deviceConfiguration;
664 }
665
666 /**
Saurav Das261c3002017-06-13 15:35:54 -0700667 * Per device next objective ID store with (device id + destination set) as key.
Charles Chan53de91f2017-08-22 15:07:34 -0700668 * Used to keep track on MPLS group information.
Ray Milkeyb85de082017-04-05 09:42:04 -0700669 *
670 * @return next objective ID store
671 */
Saurav Das261c3002017-06-13 15:35:54 -0700672 public EventuallyConsistentMap<DestinationSetNextObjectiveStoreKey, NextNeighbors>
673 dsNextObjStore() {
674 return dsNextObjStore;
Ray Milkeyb85de082017-04-05 09:42:04 -0700675 }
676
677 /**
Charles Chan53de91f2017-08-22 15:07:34 -0700678 * Per device next objective ID store with (device id + vlanid) as key.
679 * Used to keep track on L2 flood group information.
Ray Milkeyb85de082017-04-05 09:42:04 -0700680 *
681 * @return vlan next object store
682 */
683 public EventuallyConsistentMap<VlanNextObjectiveStoreKey, Integer> vlanNextObjStore() {
684 return vlanNextObjStore;
685 }
686
687 /**
Charles Chan53de91f2017-08-22 15:07:34 -0700688 * Per device next objective ID store with (device id + port + treatment + meta) as key.
689 * Used to keep track on L2 interface group and L3 unicast group information.
Ray Milkeyb85de082017-04-05 09:42:04 -0700690 *
691 * @return port next object store.
692 */
693 public EventuallyConsistentMap<PortNextObjectiveStoreKey, Integer> portNextObjStore() {
694 return portNextObjStore;
695 }
696
697 /**
Saurav Das261c3002017-06-13 15:35:54 -0700698 * Returns the MPLS-ECMP configuration which indicates whether ECMP on
699 * labeled packets should be programmed or not.
Pier Ventre7a78de22016-10-31 15:00:01 -0700700 *
701 * @return MPLS-ECMP value
702 */
703 public boolean getMplsEcmp() {
704 SegmentRoutingAppConfig segmentRoutingAppConfig = cfgService
705 .getConfig(this.appId, SegmentRoutingAppConfig.class);
706 return segmentRoutingAppConfig != null && segmentRoutingAppConfig.mplsEcmp();
707 }
708
709 /**
sangho80f1f892015-05-19 11:57:42 -0700710 * Returns the tunnel object with the tunnel ID.
711 *
712 * @param tunnelId Tunnel ID
713 * @return Tunnel reference
714 */
sangho27462c62015-05-14 00:39:53 -0700715 public Tunnel getTunnel(String tunnelId) {
716 return tunnelHandler.getTunnel(tunnelId);
717 }
718
Charles Chan90772a72017-02-08 15:52:08 -0800719 // TODO Consider moving these to InterfaceService
sangho80f11cb2015-04-01 13:05:26 -0700720 /**
Charles Chan10b0fb72017-02-02 16:20:42 -0800721 * Returns untagged VLAN configured on given connect point.
Charles Chan90772a72017-02-08 15:52:08 -0800722 * <p>
723 * Only returns the first match if there are multiple untagged VLAN configured
724 * on the connect point.
sangho80f11cb2015-04-01 13:05:26 -0700725 *
Charles Chan10b0fb72017-02-02 16:20:42 -0800726 * @param connectPoint connect point
727 * @return untagged VLAN or null if not configured
sangho80f11cb2015-04-01 13:05:26 -0700728 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700729 VlanId getUntaggedVlanId(ConnectPoint connectPoint) {
Charles Chan10b0fb72017-02-02 16:20:42 -0800730 return interfaceService.getInterfacesByPort(connectPoint).stream()
731 .filter(intf -> !intf.vlanUntagged().equals(VlanId.NONE))
732 .map(Interface::vlanUntagged)
733 .findFirst().orElse(null);
sangho80f11cb2015-04-01 13:05:26 -0700734 }
735
sangho27462c62015-05-14 00:39:53 -0700736 /**
Charles Chan90772a72017-02-08 15:52:08 -0800737 * Returns tagged VLAN configured on given connect point.
738 * <p>
739 * Returns all matches if there are multiple tagged VLAN configured
740 * on the connect point.
741 *
742 * @param connectPoint connect point
743 * @return tagged VLAN or empty set if not configured
744 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700745 Set<VlanId> getTaggedVlanId(ConnectPoint connectPoint) {
Charles Chan90772a72017-02-08 15:52:08 -0800746 Set<Interface> interfaces = interfaceService.getInterfacesByPort(connectPoint);
747 return interfaces.stream()
748 .map(Interface::vlanTagged)
Charles Chan3ed34d82017-06-22 18:03:14 -0700749 .flatMap(Set::stream)
Charles Chan90772a72017-02-08 15:52:08 -0800750 .collect(Collectors.toSet());
751 }
752
753 /**
754 * Returns native VLAN configured on given connect point.
755 * <p>
756 * Only returns the first match if there are multiple native VLAN configured
757 * on the connect point.
758 *
759 * @param connectPoint connect point
760 * @return native VLAN or null if not configured
761 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700762 VlanId getNativeVlanId(ConnectPoint connectPoint) {
Charles Chan90772a72017-02-08 15:52:08 -0800763 Set<Interface> interfaces = interfaceService.getInterfacesByPort(connectPoint);
764 return interfaces.stream()
765 .filter(intf -> !intf.vlanNative().equals(VlanId.NONE))
766 .map(Interface::vlanNative)
767 .findFirst()
768 .orElse(null);
769 }
770
771 /**
Charles Chand9265a32017-06-16 15:19:24 -0700772 * Returns internal VLAN for untagged hosts on given connect point.
773 * <p>
774 * The internal VLAN is either vlan-untagged for an access port,
775 * or vlan-native for a trunk port.
776 *
777 * @param connectPoint connect point
778 * @return internal VLAN or null if both vlan-untagged and vlan-native are undefined
779 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700780 VlanId getInternalVlanId(ConnectPoint connectPoint) {
Charles Chand9265a32017-06-16 15:19:24 -0700781 VlanId untaggedVlanId = getUntaggedVlanId(connectPoint);
782 VlanId nativeVlanId = getNativeVlanId(connectPoint);
783 return untaggedVlanId != null ? untaggedVlanId : nativeVlanId;
784 }
785
786 /**
Charles Chan3ed34d82017-06-22 18:03:14 -0700787 * Returns optional pair device ID of given device.
788 *
789 * @param deviceId device ID
790 * @return optional pair device ID. Might be empty if pair device is not configured
791 */
792 Optional<DeviceId> getPairDeviceId(DeviceId deviceId) {
793 SegmentRoutingDeviceConfig deviceConfig =
794 cfgService.getConfig(deviceId, SegmentRoutingDeviceConfig.class);
795 return Optional.ofNullable(deviceConfig).map(SegmentRoutingDeviceConfig::pairDeviceId);
796 }
797 /**
798 * Returns optional pair device local port of given device.
799 *
800 * @param deviceId device ID
801 * @return optional pair device ID. Might be empty if pair device is not configured
802 */
803 Optional<PortNumber> getPairLocalPorts(DeviceId deviceId) {
804 SegmentRoutingDeviceConfig deviceConfig =
805 cfgService.getConfig(deviceId, SegmentRoutingDeviceConfig.class);
806 return Optional.ofNullable(deviceConfig).map(SegmentRoutingDeviceConfig::pairLocalPort);
807 }
808
809 /**
Charles Chan910be6a2017-08-23 14:46:43 -0700810 * Determine if current instance is the master of given connect point.
811 *
812 * @param cp connect point
813 * @return true if current instance is the master of given connect point
814 */
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -0700815 public boolean isMasterOf(ConnectPoint cp) {
Charles Chan910be6a2017-08-23 14:46:43 -0700816 boolean isMaster = mastershipService.isLocalMaster(cp.deviceId());
817 if (!isMaster) {
818 log.debug(NOT_MASTER, cp);
819 }
820 return isMaster;
821 }
822
823 /**
Charles Chanf0ae41e2017-08-23 13:55:39 -0700824 * Returns locations of given resolved route.
825 *
826 * @param resolvedRoute resolved route
827 * @return locations of nexthop. Might be empty if next hop is not found
828 */
829 Set<ConnectPoint> nextHopLocations(ResolvedRoute resolvedRoute) {
830 HostId hostId = HostId.hostId(resolvedRoute.nextHopMac(), resolvedRoute.nextHopVlan());
831 return Optional.ofNullable(hostService.getHost(hostId))
832 .map(Host::locations).orElse(Sets.newHashSet())
833 .stream().map(l -> (ConnectPoint) l).collect(Collectors.toSet());
834 }
835
836 /**
Charles Chan90772a72017-02-08 15:52:08 -0800837 * Returns vlan port map of given device.
838 *
839 * @param deviceId device id
840 * @return vlan-port multimap
841 */
842 public Multimap<VlanId, PortNumber> getVlanPortMap(DeviceId deviceId) {
843 HashMultimap<VlanId, PortNumber> vlanPortMap = HashMultimap.create();
844
845 interfaceService.getInterfaces().stream()
846 .filter(intf -> intf.connectPoint().deviceId().equals(deviceId))
847 .forEach(intf -> {
848 vlanPortMap.put(intf.vlanUntagged(), intf.connectPoint().port());
Charles Chan3ed34d82017-06-22 18:03:14 -0700849 intf.vlanTagged().forEach(vlanTagged ->
850 vlanPortMap.put(vlanTagged, intf.connectPoint().port())
851 );
Charles Chan90772a72017-02-08 15:52:08 -0800852 vlanPortMap.put(intf.vlanNative(), intf.connectPoint().port());
853 });
854 vlanPortMap.removeAll(VlanId.NONE);
855
856 return vlanPortMap;
857 }
858
859 /**
Charles Chan10b0fb72017-02-02 16:20:42 -0800860 * Returns the next objective ID for the given vlan id. It is expected
Saurav Das2d94d312015-11-24 23:21:05 -0800861 * that the next-objective has been pre-created from configuration.
Charles Chan77277672015-10-20 16:24:19 -0700862 *
863 * @param deviceId Device ID
Charles Chan10b0fb72017-02-02 16:20:42 -0800864 * @param vlanId VLAN ID
Saurav Das2d94d312015-11-24 23:21:05 -0800865 * @return next objective ID or -1 if it was not found
Charles Chan77277672015-10-20 16:24:19 -0700866 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700867 int getVlanNextObjectiveId(DeviceId deviceId, VlanId vlanId) {
Charles Chan77277672015-10-20 16:24:19 -0700868 if (groupHandlerMap.get(deviceId) != null) {
Charles Chan10b0fb72017-02-02 16:20:42 -0800869 log.trace("getVlanNextObjectiveId query in device {}", deviceId);
870 return groupHandlerMap.get(deviceId).getVlanNextObjectiveId(vlanId);
Charles Chan77277672015-10-20 16:24:19 -0700871 } else {
Charles Chan10b0fb72017-02-02 16:20:42 -0800872 log.warn("getVlanNextObjectiveId query - groupHandler for "
Saurav Das2d94d312015-11-24 23:21:05 -0800873 + "device {} not found", deviceId);
874 return -1;
875 }
876 }
877
878 /**
879 * Returns the next objective ID for the given portNumber, given the treatment.
880 * There could be multiple different treatments to the same outport, which
Saurav Das2cb38292017-03-29 19:09:17 -0700881 * would result in different objectives. If the next object does not exist,
882 * and should be created, a new one is created and its id is returned.
Saurav Das2d94d312015-11-24 23:21:05 -0800883 *
884 * @param deviceId Device ID
885 * @param portNum port number on device for which NextObjective is queried
886 * @param treatment the actions to apply on the packets (should include outport)
887 * @param meta metadata passed into the creation of a Next Objective if necessary
Saurav Das2cb38292017-03-29 19:09:17 -0700888 * @param createIfMissing true if a next object should be created if not found
Saurav Das07c74602016-04-27 18:35:50 -0700889 * @return next objective ID or -1 if an error occurred during retrieval or creation
Saurav Das2d94d312015-11-24 23:21:05 -0800890 */
891 public int getPortNextObjectiveId(DeviceId deviceId, PortNumber portNum,
892 TrafficTreatment treatment,
Saurav Das2cb38292017-03-29 19:09:17 -0700893 TrafficSelector meta,
894 boolean createIfMissing) {
Saurav Das2d94d312015-11-24 23:21:05 -0800895 DefaultGroupHandler ghdlr = groupHandlerMap.get(deviceId);
896 if (ghdlr != null) {
Saurav Das2cb38292017-03-29 19:09:17 -0700897 return ghdlr.getPortNextObjectiveId(portNum, treatment, meta, createIfMissing);
Saurav Das2d94d312015-11-24 23:21:05 -0800898 } else {
Charles Chanb7f75ac2016-01-11 18:28:54 -0800899 log.warn("getPortNextObjectiveId query - groupHandler for device {}"
900 + " not found", deviceId);
901 return -1;
902 }
903 }
904
Saurav Das62ae6792017-05-15 15:34:25 -0700905 /**
906 * Returns the group handler object for the specified device id.
907 *
908 * @param devId the device identifier
909 * @return the groupHandler object for the device id, or null if not found
910 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700911 DefaultGroupHandler getGroupHandler(DeviceId devId) {
Saurav Das62ae6792017-05-15 15:34:25 -0700912 return groupHandlerMap.get(devId);
913 }
914
915 /**
Saurav Dasfbe74572017-08-03 18:30:35 -0700916 * Returns the default routing handler object.
917 *
918 * @return the default routing handler object
919 */
920 public DefaultRoutingHandler getRoutingHandler() {
921 return defaultRoutingHandler;
922 }
923
924 /**
Saurav Das62ae6792017-05-15 15:34:25 -0700925 * Returns true if this controller instance has seen this link before. The
926 * link may not be currently up, but as long as the link had been seen before
927 * this method will return true. The one exception is when the link was
928 * indeed seen before, but this controller instance was forced to forget it
929 * by a call to purgeSeenLink method.
930 *
931 * @param link the infrastructure link being queried
932 * @return true if this controller instance has seen this link before
933 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700934 boolean isSeenLink(Link link) {
Saurav Das62ae6792017-05-15 15:34:25 -0700935 return seenLinks.containsKey(link);
936 }
937
938 /**
939 * Updates the seen link store. Updates can be for links that are currently
940 * available or not.
941 *
942 * @param link the link to update in the seen-link local store
943 * @param up the status of the link, true if up, false if down
944 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700945 void updateSeenLink(Link link, boolean up) {
Saurav Das62ae6792017-05-15 15:34:25 -0700946 seenLinks.put(link, up);
947 }
948
949 /**
950 * Returns the status of a seen-link (up or down). If the link has not
951 * been seen-before, a null object is returned.
952 *
953 * @param link the infrastructure link being queried
954 * @return null if the link was not seen-before;
955 * true if the seen-link is up;
956 * false if the seen-link is down
957 */
Charles Chan873661e2017-11-30 15:37:50 -0800958 private Boolean isSeenLinkUp(Link link) {
Saurav Das62ae6792017-05-15 15:34:25 -0700959 return seenLinks.get(link);
960 }
961
962 /**
963 * Makes this controller instance forget a previously seen before link.
964 *
965 * @param link the infrastructure link to purge
966 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700967 private void purgeSeenLink(Link link) {
Saurav Das62ae6792017-05-15 15:34:25 -0700968 seenLinks.remove(link);
969 }
970
971 /**
972 * Returns the status of a link as parallel link. A parallel link
973 * is defined as a link which has common src and dst switches as another
974 * seen-link that is currently enabled. It is not necessary for the link being
975 * queried to be a seen-link.
976 *
977 * @param link the infrastructure link being queried
978 * @return true if a seen-link exists that is up, and shares the
979 * same src and dst switches as the link being queried
980 */
Charles Chan3ed34d82017-06-22 18:03:14 -0700981 private boolean isParallelLink(Link link) {
Saurav Das62ae6792017-05-15 15:34:25 -0700982 for (Entry<Link, Boolean> seen : seenLinks.entrySet()) {
983 Link seenLink = seen.getKey();
984 if (seenLink.equals(link)) {
985 continue;
986 }
987 if (seenLink.src().deviceId().equals(link.src().deviceId()) &&
988 seenLink.dst().deviceId().equals(link.dst().deviceId()) &&
989 seen.getValue()) {
990 return true;
991 }
992 }
993 return false;
994 }
995
Saurav Das261c3002017-06-13 15:35:54 -0700996 /**
997 * Returns true if the link being queried is a bidirectional link. A bidi
998 * link is defined as a link, whose reverse link - ie. the link in the reverse
999 * direction - has been seen-before and is up. It is not necessary for the link
1000 * being queried to be a seen-link.
1001 *
1002 * @param link the infrastructure link being queried
1003 * @return true if another unidirectional link exists in the reverse direction,
1004 * has been seen-before and is up
1005 */
Charles Chan873661e2017-11-30 15:37:50 -08001006 boolean isBidirectional(Link link) {
Saurav Das261c3002017-06-13 15:35:54 -07001007 Link reverseLink = linkService.getLink(link.dst(), link.src());
1008 if (reverseLink == null) {
1009 return false;
1010 }
1011 Boolean result = isSeenLinkUp(reverseLink);
1012 if (result == null) {
1013 return false;
1014 }
1015 return result.booleanValue();
1016 }
1017
1018 /**
1019 * Determines if the given link should be avoided in routing calculations
1020 * by policy or design.
1021 *
1022 * @param link the infrastructure link being queried
1023 * @return true if link should be avoided
1024 */
Charles Chan873661e2017-11-30 15:37:50 -08001025 boolean avoidLink(Link link) {
Saurav Das261c3002017-06-13 15:35:54 -07001026 // XXX currently only avoids all pair-links. In the future can be
1027 // extended to avoid any generic link
1028 DeviceId src = link.src().deviceId();
1029 PortNumber srcPort = link.src().port();
1030 if (deviceConfiguration == null || !deviceConfiguration.isConfigured(src)) {
1031 log.warn("Device {} not configured..cannot avoid link {}", src, link);
1032 return false;
1033 }
1034 DeviceId pairDev;
1035 PortNumber pairLocalPort, pairRemotePort = null;
1036 try {
1037 pairDev = deviceConfiguration.getPairDeviceId(src);
1038 pairLocalPort = deviceConfiguration.getPairLocalPort(src);
1039 if (pairDev != null) {
1040 pairRemotePort = deviceConfiguration.getPairLocalPort(pairDev);
1041 }
1042 } catch (DeviceConfigNotFoundException e) {
1043 log.warn("Pair dev for dev {} not configured..cannot avoid link {}",
1044 src, link);
1045 return false;
1046 }
1047
Charles Chan873661e2017-11-30 15:37:50 -08001048 return srcPort.equals(pairLocalPort) &&
Saurav Das261c3002017-06-13 15:35:54 -07001049 link.dst().deviceId().equals(pairDev) &&
Charles Chan873661e2017-11-30 15:37:50 -08001050 link.dst().port().equals(pairRemotePort);
Saurav Das261c3002017-06-13 15:35:54 -07001051 }
1052
sangho80f11cb2015-04-01 13:05:26 -07001053 private class InternalPacketProcessor implements PacketProcessor {
sangho80f11cb2015-04-01 13:05:26 -07001054 @Override
1055 public void process(PacketContext context) {
1056
1057 if (context.isHandled()) {
1058 return;
1059 }
1060
1061 InboundPacket pkt = context.inPacket();
1062 Ethernet ethernet = pkt.parsed();
Pier Luigi37a35432017-02-01 13:50:04 -08001063
1064 if (ethernet == null) {
1065 return;
1066 }
1067
Saurav Das261c3002017-06-13 15:35:54 -07001068 log.trace("Rcvd pktin from {}: {}", context.inPacket().receivedFrom(),
1069 ethernet);
Pier Ventreadb4ae62016-11-23 09:57:42 -08001070 if (ethernet.getEtherType() == TYPE_ARP) {
Saurav Das62ae6792017-05-15 15:34:25 -07001071 log.warn("Received unexpected ARP packet on {}",
1072 context.inPacket().receivedFrom());
Saurav Das368cf212017-03-15 15:15:14 -07001073 log.trace("{}", ethernet);
Pier Ventre6b2c1b32016-12-09 17:26:04 -08001074 return;
sangho80f11cb2015-04-01 13:05:26 -07001075 } else if (ethernet.getEtherType() == Ethernet.TYPE_IPV4) {
Pier Ventreb6b81d52016-12-02 08:16:05 -08001076 IPv4 ipv4Packet = (IPv4) ethernet.getPayload();
1077 //ipHandler.addToPacketBuffer(ipv4Packet);
1078 if (ipv4Packet.getProtocol() == IPv4.PROTOCOL_ICMP) {
1079 icmpHandler.processIcmp(ethernet, pkt.receivedFrom());
sangho80f11cb2015-04-01 13:05:26 -07001080 } else {
Charles Chand041ad82017-01-13 17:20:44 -08001081 // NOTE: We don't support IP learning at this moment so this
1082 // is not necessary. Also it causes duplication of DHCP packets.
Pier Ventre6b2c1b32016-12-09 17:26:04 -08001083 // ipHandler.processPacketIn(ipv4Packet, pkt.receivedFrom());
sangho80f11cb2015-04-01 13:05:26 -07001084 }
Pier Ventreb6a7f342016-11-26 21:05:22 -08001085 } else if (ethernet.getEtherType() == Ethernet.TYPE_IPV6) {
1086 IPv6 ipv6Packet = (IPv6) ethernet.getPayload();
Pier Ventreb6b81d52016-12-02 08:16:05 -08001087 //ipHandler.addToPacketBuffer(ipv6Packet);
Pier Luigi37a35432017-02-01 13:50:04 -08001088 // We deal with the packet only if the packet is a ICMP6 ECHO/REPLY
Pier Ventreb6b81d52016-12-02 08:16:05 -08001089 if (ipv6Packet.getNextHeader() == IPv6.PROTOCOL_ICMP6) {
1090 ICMP6 icmp6Packet = (ICMP6) ipv6Packet.getPayload();
1091 if (icmp6Packet.getIcmpType() == ICMP6.ECHO_REQUEST ||
1092 icmp6Packet.getIcmpType() == ICMP6.ECHO_REPLY) {
1093 icmpHandler.processIcmpv6(ethernet, pkt.receivedFrom());
1094 } else {
Saurav Das62ae6792017-05-15 15:34:25 -07001095 log.trace("Received ICMPv6 0x{} - not handled",
Charles Chand3727b72017-03-13 13:10:30 -07001096 Integer.toHexString(icmp6Packet.getIcmpType() & 0xff));
Pier Ventreb6b81d52016-12-02 08:16:05 -08001097 }
1098 } else {
1099 // NOTE: We don't support IP learning at this moment so this
1100 // is not necessary. Also it causes duplication of DHCPv6 packets.
1101 // ipHandler.processPacketIn(ipv6Packet, pkt.receivedFrom());
1102 }
sangho80f11cb2015-04-01 13:05:26 -07001103 }
1104 }
1105 }
1106
1107 private class InternalLinkListener implements LinkListener {
1108 @Override
1109 public void event(LinkEvent event) {
Charles Chan0cff8aa2017-03-29 16:39:05 -07001110 if (event.type() == LinkEvent.Type.LINK_ADDED ||
1111 event.type() == LinkEvent.Type.LINK_UPDATED ||
1112 event.type() == LinkEvent.Type.LINK_REMOVED) {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001113 log.debug("Event {} received from Link Service", event.type());
sangho80f11cb2015-04-01 13:05:26 -07001114 scheduleEventHandlerIfNotScheduled(event);
1115 }
1116 }
1117 }
1118
1119 private class InternalDeviceListener implements DeviceListener {
sangho80f11cb2015-04-01 13:05:26 -07001120 @Override
1121 public void event(DeviceEvent event) {
sangho80f11cb2015-04-01 13:05:26 -07001122 switch (event.type()) {
1123 case DEVICE_ADDED:
Saurav Dasf0f592d2016-11-18 15:21:57 -08001124 case PORT_UPDATED:
1125 case PORT_ADDED:
sanghofb7c7292015-04-13 15:15:58 -07001126 case DEVICE_UPDATED:
1127 case DEVICE_AVAILABILITY_CHANGED:
Saurav Das62ae6792017-05-15 15:34:25 -07001128 log.trace("Event {} received from Device Service", event.type());
sangho80f11cb2015-04-01 13:05:26 -07001129 scheduleEventHandlerIfNotScheduled(event);
1130 break;
1131 default:
1132 }
1133 }
1134 }
1135
Saurav Das2d94d312015-11-24 23:21:05 -08001136 @SuppressWarnings("rawtypes")
sangho80f11cb2015-04-01 13:05:26 -07001137 private void scheduleEventHandlerIfNotScheduled(Event event) {
Charles Chan3ed34d82017-06-22 18:03:14 -07001138 synchronized (THREAD_SCHED_LOCK) {
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001139 eventQueue.add(event);
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001140 numOfEventsQueued++;
1141
1142 if ((numOfHandlerScheduled - numOfHandlerExecution) == 0) {
1143 //No pending scheduled event handling threads. So start a new one.
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001144 eventHandlerFuture = executorService
1145 .schedule(eventHandler, 100, TimeUnit.MILLISECONDS);
1146 numOfHandlerScheduled++;
1147 }
Jonathan Hart54541d12016-04-12 15:39:44 -07001148 log.trace("numOfEventsQueued {}, numOfEventHandlerScheduled {}",
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001149 numOfEventsQueued,
1150 numOfHandlerScheduled);
sangho80f11cb2015-04-01 13:05:26 -07001151 }
sangho80f11cb2015-04-01 13:05:26 -07001152 }
1153
1154 private class InternalEventHandler implements Runnable {
Srikanth Vavilapalli37a461b2015-04-07 15:12:32 -07001155 @Override
sangho80f11cb2015-04-01 13:05:26 -07001156 public void run() {
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001157 try {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001158 while (true) {
Saurav Das2d94d312015-11-24 23:21:05 -08001159 @SuppressWarnings("rawtypes")
Charles Chan3ed34d82017-06-22 18:03:14 -07001160 Event event;
1161 synchronized (THREAD_SCHED_LOCK) {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001162 if (!eventQueue.isEmpty()) {
1163 event = eventQueue.poll();
1164 numOfEventsExecuted++;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001165 } else {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001166 numOfHandlerExecution++;
1167 log.debug("numOfHandlerExecution {} numOfEventsExecuted {}",
1168 numOfHandlerExecution, numOfEventsExecuted);
1169 break;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001170 }
sanghofb7c7292015-04-13 15:15:58 -07001171 }
Charles Chan0cff8aa2017-03-29 16:39:05 -07001172 if (event.type() == LinkEvent.Type.LINK_ADDED ||
1173 event.type() == LinkEvent.Type.LINK_UPDATED) {
Saurav Das62ae6792017-05-15 15:34:25 -07001174 // Note: do not update seenLinks here, otherwise every
1175 // link, even one seen for the first time, will be appear
1176 // to be a previously seen link
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001177 processLinkAdded((Link) event.subject());
1178 } else if (event.type() == LinkEvent.Type.LINK_REMOVED) {
Pier Ventre6d593892016-09-13 21:33:40 -07001179 Link linkRemoved = (Link) event.subject();
Saurav Das62ae6792017-05-15 15:34:25 -07001180 if (linkRemoved.type() == Link.Type.DIRECT) {
1181 updateSeenLink(linkRemoved, false);
1182 }
1183 // device availability check helps to ensure that
1184 // multiple link-removed events are actually treated as a
1185 // single switch removed event. purgeSeenLink is necessary
1186 // so we do rerouting (instead of rehashing) when switch
1187 // comes back.
Pier Ventre6d593892016-09-13 21:33:40 -07001188 if (linkRemoved.src().elementId() instanceof DeviceId &&
1189 !deviceService.isAvailable(linkRemoved.src().deviceId())) {
Saurav Das62ae6792017-05-15 15:34:25 -07001190 purgeSeenLink(linkRemoved);
Pier Ventre6d593892016-09-13 21:33:40 -07001191 continue;
1192 }
1193 if (linkRemoved.dst().elementId() instanceof DeviceId &&
1194 !deviceService.isAvailable(linkRemoved.dst().deviceId())) {
Saurav Das62ae6792017-05-15 15:34:25 -07001195 purgeSeenLink(linkRemoved);
Pier Ventre6d593892016-09-13 21:33:40 -07001196 continue;
1197 }
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001198 processLinkRemoved((Link) event.subject());
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001199 } else if (event.type() == DeviceEvent.Type.DEVICE_ADDED ||
1200 event.type() == DeviceEvent.Type.DEVICE_AVAILABILITY_CHANGED ||
1201 event.type() == DeviceEvent.Type.DEVICE_UPDATED) {
Saurav Das62af8802015-12-04 10:52:59 -08001202 DeviceId deviceId = ((Device) event.subject()).id();
1203 if (deviceService.isAvailable(deviceId)) {
Saurav Dasc28b3432015-10-30 17:45:38 -07001204 log.info("Processing device event {} for available device {}",
1205 event.type(), ((Device) event.subject()).id());
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001206 processDeviceAdded((Device) event.subject());
Saurav Dasc3604f12016-03-23 11:22:49 -07001207 } else {
1208 log.info("Processing device event {} for unavailable device {}",
1209 event.type(), ((Device) event.subject()).id());
1210 processDeviceRemoved((Device) event.subject());
1211 }
Saurav Dasf0f592d2016-11-18 15:21:57 -08001212 } else if (event.type() == DeviceEvent.Type.PORT_ADDED) {
Saurav Dasd1872b02016-12-02 15:43:47 -08001213 // typically these calls come when device is added first time
1214 // so port filtering rules are handled at the device_added event.
1215 // port added calls represent all ports on the device,
1216 // enabled or not.
Saurav Das62ae6792017-05-15 15:34:25 -07001217 log.trace("** PORT ADDED {}/{} -> {}",
Saurav Dasd1872b02016-12-02 15:43:47 -08001218 ((DeviceEvent) event).subject().id(),
1219 ((DeviceEvent) event).port().number(),
1220 event.type());
Saurav Dasf0f592d2016-11-18 15:21:57 -08001221 } else if (event.type() == DeviceEvent.Type.PORT_UPDATED) {
Saurav Dasd1872b02016-12-02 15:43:47 -08001222 // these calls happen for every subsequent event
1223 // ports enabled, disabled, switch goes away, comes back
Saurav Dasf0f592d2016-11-18 15:21:57 -08001224 log.info("** PORT UPDATED {}/{} -> {}",
1225 event.subject(),
1226 ((DeviceEvent) event).port(),
1227 event.type());
1228 processPortUpdated(((Device) event.subject()),
1229 ((DeviceEvent) event).port());
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -07001230 } else {
1231 log.warn("Unhandled event type: {}", event.type());
1232 }
sangho80f11cb2015-04-01 13:05:26 -07001233 }
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001234 } catch (Exception e) {
1235 log.error("SegmentRouting event handler "
1236 + "thread thrown an exception: {}", e);
sangho80f11cb2015-04-01 13:05:26 -07001237 }
sangho80f11cb2015-04-01 13:05:26 -07001238 }
1239 }
1240
sangho80f11cb2015-04-01 13:05:26 -07001241 private void processLinkAdded(Link link) {
Saurav Dasb149be12016-06-07 10:08:06 -07001242 log.info("** LINK ADDED {}", link.toString());
Saurav Das62ae6792017-05-15 15:34:25 -07001243 if (link.type() != Link.Type.DIRECT) {
1244 // NOTE: A DIRECT link might be transiently marked as INDIRECT
1245 // if BDDP is received before LLDP. We can safely ignore that
1246 // until the LLDP is received and the link is marked as DIRECT.
1247 log.info("Ignore link {}->{}. Link type is {} instead of DIRECT.",
1248 link.src(), link.dst(), link.type());
1249 return;
1250 }
Saurav Dasfe0b05e2017-08-14 16:44:43 -07001251 if (!deviceConfiguration.isConfigured(link.src().deviceId())) {
1252 updateSeenLink(link, true);
1253 // XXX revisit - what about devicePortMap
1254 log.warn("Source device of this link is not configured.. "
1255 + "not processing further");
1256 return;
1257 }
Saurav Das62ae6792017-05-15 15:34:25 -07001258
1259 //Irrespective of whether the local is a MASTER or not for this device,
1260 //create group handler instance and push default TTP flow rules if needed,
1261 //as in a multi-instance setup, instances can initiate groups for any device.
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001262 DefaultGroupHandler groupHandler = groupHandlerMap.get(link.src()
1263 .deviceId());
1264 if (groupHandler != null) {
Saurav Das62ae6792017-05-15 15:34:25 -07001265 groupHandler.portUpForLink(link);
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001266 } else {
Saurav Dasfe0b05e2017-08-14 16:44:43 -07001267 // XXX revisit/cleanup
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001268 Device device = deviceService.getDevice(link.src().deviceId());
1269 if (device != null) {
1270 log.warn("processLinkAdded: Link Added "
1271 + "Notification without Device Added "
1272 + "event, still handling it");
1273 processDeviceAdded(device);
1274 groupHandler = groupHandlerMap.get(link.src()
1275 .deviceId());
Saurav Das62ae6792017-05-15 15:34:25 -07001276 groupHandler.portUpForLink(link);
sangho80f11cb2015-04-01 13:05:26 -07001277 }
1278 }
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -07001279
Saurav Das261c3002017-06-13 15:35:54 -07001280 /*// process link only if it is bidirectional
1281 if (!isBidirectional(link)) {
1282 log.debug("Link not bidirectional.. waiting for other direction "
1283 + "src {} --> dst {} ", link.dst(), link.src());
1284 // note that if we are not processing for routing, it should at least
1285 // be considered a seen-link
1286 updateSeenLink(link, true);
1287 return;
1288 }
1289 TO DO this ensure that rehash is still done correctly even if link is
1290 not processed for rerouting - perhaps rehash in both directions when
1291 it ultimately becomes bidi?
1292 */
1293
1294 log.debug("Starting optimized route population process for link "
1295 + "{} --> {}", link.src(), link.dst());
Saurav Das62ae6792017-05-15 15:34:25 -07001296 boolean seenBefore = isSeenLink(link);
1297 defaultRoutingHandler.populateRoutingRulesForLinkStatusChange(null, link, null);
Saurav Das261c3002017-06-13 15:35:54 -07001298
1299 // It's possible that linkUp causes no route-path change as ECMP graph does
1300 // not change if the link is a parallel link (same src-dst as another link.
1301 // However we still need to update ECMP hash groups to include new buckets
1302 // for the link that has come up.
Saurav Das62ae6792017-05-15 15:34:25 -07001303 if (mastershipService.isLocalMaster(link.src().deviceId())) {
Saurav Das261c3002017-06-13 15:35:54 -07001304 if (!seenBefore && isParallelLink(link)) {
Saurav Das62ae6792017-05-15 15:34:25 -07001305 // if link seen first time, we need to ensure hash-groups have all ports
Saurav Das261c3002017-06-13 15:35:54 -07001306 log.debug("Attempting retryHash for paralled first-time link {}", link);
Saurav Das62ae6792017-05-15 15:34:25 -07001307 groupHandler.retryHash(link, false, true);
1308 } else {
1309 //seen before-link
1310 if (isParallelLink(link)) {
Saurav Das261c3002017-06-13 15:35:54 -07001311 log.debug("Attempting retryHash for paralled seen-before "
1312 + "link {}", link);
Saurav Das62ae6792017-05-15 15:34:25 -07001313 groupHandler.retryHash(link, false, false);
1314 }
1315 }
1316 }
Charles Chan72779502016-04-23 17:36:10 -07001317
1318 mcastHandler.init();
sangho80f11cb2015-04-01 13:05:26 -07001319 }
1320
1321 private void processLinkRemoved(Link link) {
Saurav Dasb149be12016-06-07 10:08:06 -07001322 log.info("** LINK REMOVED {}", link.toString());
Saurav Das62ae6792017-05-15 15:34:25 -07001323 defaultRoutingHandler.populateRoutingRulesForLinkStatusChange(link, null, null);
1324
1325 // update local groupHandler stores
sangho2165d222015-05-01 09:38:25 -07001326 DefaultGroupHandler groupHandler = groupHandlerMap.get(link.src().deviceId());
1327 if (groupHandler != null) {
Saurav Das62ae6792017-05-15 15:34:25 -07001328 if (mastershipService.isLocalMaster(link.src().deviceId()) &&
1329 isParallelLink(link)) {
Saurav Dasfe0b05e2017-08-14 16:44:43 -07001330 log.debug("* retrying hash for parallel link removed:{}", link);
Saurav Das62ae6792017-05-15 15:34:25 -07001331 groupHandler.retryHash(link, true, false);
Saurav Dasfe0b05e2017-08-14 16:44:43 -07001332 } else {
1333 log.debug("Not attempting retry-hash for link removed: {} .. {}", link,
1334 (mastershipService.isLocalMaster(link.src().deviceId()))
1335 ? "not parallel" : "not master");
Saurav Das62ae6792017-05-15 15:34:25 -07001336 }
1337 // ensure local stores are updated
1338 groupHandler.portDown(link.src().port());
1339 } else {
1340 log.warn("group handler not found for dev:{} when removing link: {}",
1341 link.src().deviceId(), link);
sangho2165d222015-05-01 09:38:25 -07001342 }
Charles Chan72779502016-04-23 17:36:10 -07001343
1344 mcastHandler.processLinkDown(link);
Andreas Pantelopoulos5e7be3d2017-10-23 12:18:25 -07001345 l2TunnelHandler.processLinkDown(link);
sangho80f11cb2015-04-01 13:05:26 -07001346 }
1347
1348 private void processDeviceAdded(Device device) {
Saurav Dasb149be12016-06-07 10:08:06 -07001349 log.info("** DEVICE ADDED with ID {}", device.id());
Charles Chan9bd6aea2017-06-27 18:48:32 -07001350
1351 // NOTE: Punt ARP/NDP even when the device is not configured.
1352 // Host learning without network config is required for CORD config generator.
1353 routingRulePopulator.populateIpPunts(device.id());
1354 routingRulePopulator.populateArpNdpPunts(device.id());
1355
Charles Chan319d1a22015-11-03 10:42:14 -08001356 if (deviceConfiguration == null || !deviceConfiguration.isConfigured(device.id())) {
Saurav Das261c3002017-06-13 15:35:54 -07001357 log.warn("Device configuration unavailable. Device {} will be "
1358 + "processed after configuration.", device.id());
Saurav Das8ec0ec42015-11-03 14:39:27 -08001359 return;
1360 }
Charles Chan72779502016-04-23 17:36:10 -07001361 processDeviceAddedInternal(device.id());
1362 }
1363
1364 private void processDeviceAddedInternal(DeviceId deviceId) {
Saurav Dasc28b3432015-10-30 17:45:38 -07001365 // Irrespective of whether the local is a MASTER or not for this device,
1366 // we need to create a SR-group-handler instance. This is because in a
1367 // multi-instance setup, any instance can initiate forwarding/next-objectives
1368 // for any switch (even if this instance is a SLAVE or not even connected
1369 // to the switch). To handle this, a default-group-handler instance is necessary
1370 // per switch.
Charles Chan72779502016-04-23 17:36:10 -07001371 log.debug("Current groupHandlerMap devs: {}", groupHandlerMap.keySet());
1372 if (groupHandlerMap.get(deviceId) == null) {
Charles Chan319d1a22015-11-03 10:42:14 -08001373 DefaultGroupHandler groupHandler;
1374 try {
1375 groupHandler = DefaultGroupHandler.
Charles Chan72779502016-04-23 17:36:10 -07001376 createGroupHandler(deviceId,
1377 appId,
1378 deviceConfiguration,
1379 linkService,
1380 flowObjectiveService,
1381 this);
Charles Chan319d1a22015-11-03 10:42:14 -08001382 } catch (DeviceConfigNotFoundException e) {
1383 log.warn(e.getMessage() + " Aborting processDeviceAdded.");
1384 return;
1385 }
Saurav Das2b6a00f2017-12-05 15:00:23 -08001386 log.debug("updating groupHandlerMap with new grpHdlr for device: {}",
Charles Chan72779502016-04-23 17:36:10 -07001387 deviceId);
1388 groupHandlerMap.put(deviceId, groupHandler);
Saurav Das8ec0ec42015-11-03 14:39:27 -08001389 }
Saurav Dasb149be12016-06-07 10:08:06 -07001390
Charles Chan72779502016-04-23 17:36:10 -07001391 if (mastershipService.isLocalMaster(deviceId)) {
Saurav Dasf9332192017-02-18 14:05:44 -08001392 defaultRoutingHandler.populatePortAddressingRules(deviceId);
Charles Chandebfea32016-10-24 14:52:01 -07001393 hostHandler.init(deviceId);
Charles Chan82f19972016-05-17 13:13:55 -07001394 xConnectHandler.init(deviceId);
Charles Chan72779502016-04-23 17:36:10 -07001395 DefaultGroupHandler groupHandler = groupHandlerMap.get(deviceId);
Charles Chan10b0fb72017-02-02 16:20:42 -08001396 groupHandler.createGroupsFromVlanConfig();
Charles Chan72779502016-04-23 17:36:10 -07001397 routingRulePopulator.populateSubnetBroadcastRule(deviceId);
Charles Chan77277672015-10-20 16:24:19 -07001398 }
Charles Chan82ab1932016-01-30 23:22:37 -08001399
Charles Chandebfea32016-10-24 14:52:01 -07001400 appCfgHandler.init(deviceId);
1401 routeHandler.init(deviceId);
sangho80f11cb2015-04-01 13:05:26 -07001402 }
1403
Saurav Dasc3604f12016-03-23 11:22:49 -07001404 private void processDeviceRemoved(Device device) {
Saurav Das261c3002017-06-13 15:35:54 -07001405 dsNextObjStore.entrySet().stream()
Saurav Dasc3604f12016-03-23 11:22:49 -07001406 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
Charles Chan873661e2017-11-30 15:37:50 -08001407 .forEach(entry -> dsNextObjStore.remove(entry.getKey()));
Charles Chan10b0fb72017-02-02 16:20:42 -08001408 vlanNextObjStore.entrySet().stream()
Saurav Dasc3604f12016-03-23 11:22:49 -07001409 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
Charles Chan3ed34d82017-06-22 18:03:14 -07001410 .forEach(entry -> vlanNextObjStore.remove(entry.getKey()));
Saurav Dasc3604f12016-03-23 11:22:49 -07001411 portNextObjStore.entrySet().stream()
1412 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
Charles Chan3ed34d82017-06-22 18:03:14 -07001413 .forEach(entry -> portNextObjStore.remove(entry.getKey()));
Charles Chan17d75d82017-06-15 00:44:51 -07001414
1415 seenLinks.keySet().removeIf(key -> key.src().deviceId().equals(device.id()) ||
1416 key.dst().deviceId().equals(device.id()));
1417
Saurav Dasfbe74572017-08-03 18:30:35 -07001418 DefaultGroupHandler gh = groupHandlerMap.remove(device.id());
1419 if (gh != null) {
1420 gh.shutdown();
1421 }
Saurav Dasc3604f12016-03-23 11:22:49 -07001422 defaultRoutingHandler.purgeEcmpGraph(device.id());
Saurav Das62ae6792017-05-15 15:34:25 -07001423 // Note that a switch going down is associated with all of its links
1424 // going down as well, but it is treated as a single switch down event
1425 // while the link-downs are ignored.
1426 defaultRoutingHandler
1427 .populateRoutingRulesForLinkStatusChange(null, null, device.id());
Charles Chan72779502016-04-23 17:36:10 -07001428 mcastHandler.removeDevice(device.id());
Charles Chan82f19972016-05-17 13:13:55 -07001429 xConnectHandler.removeDevice(device.id());
Saurav Dasc3604f12016-03-23 11:22:49 -07001430 }
1431
Saurav Dasf0f592d2016-11-18 15:21:57 -08001432 private void processPortUpdated(Device device, Port port) {
1433 if (deviceConfiguration == null || !deviceConfiguration.isConfigured(device.id())) {
1434 log.warn("Device configuration uploading. Not handling port event for"
1435 + "dev: {} port: {}", device.id(), port.number());
1436 return;
1437 }
Saurav Dasf9332192017-02-18 14:05:44 -08001438
1439 if (!mastershipService.isLocalMaster(device.id())) {
1440 log.debug("Not master for dev:{} .. not handling port updated event"
1441 + "for port {}", device.id(), port.number());
1442 return;
1443 }
1444
1445 // first we handle filtering rules associated with the port
1446 if (port.isEnabled()) {
1447 log.info("Switchport {}/{} enabled..programming filters",
1448 device.id(), port.number());
Charles Chan43be46b2017-02-26 22:59:35 -08001449 routingRulePopulator.processSinglePortFilters(device.id(), port.number(), true);
Saurav Dasf9332192017-02-18 14:05:44 -08001450 } else {
1451 log.info("Switchport {}/{} disabled..removing filters",
1452 device.id(), port.number());
Charles Chan43be46b2017-02-26 22:59:35 -08001453 routingRulePopulator.processSinglePortFilters(device.id(), port.number(), false);
Saurav Dasf9332192017-02-18 14:05:44 -08001454 }
Saurav Dasf0f592d2016-11-18 15:21:57 -08001455
1456 // portUpdated calls are for ports that have gone down or up. For switch
1457 // to switch ports, link-events should take care of any re-routing or
1458 // group editing necessary for port up/down. Here we only process edge ports
1459 // that are already configured.
Saurav Das3fb28272017-03-04 16:08:47 -08001460 ConnectPoint cp = new ConnectPoint(device.id(), port.number());
1461 VlanId untaggedVlan = getUntaggedVlanId(cp);
1462 VlanId nativeVlan = getNativeVlanId(cp);
1463 Set<VlanId> taggedVlans = getTaggedVlanId(cp);
Charles Chan10b0fb72017-02-02 16:20:42 -08001464
Saurav Das3fb28272017-03-04 16:08:47 -08001465 if (untaggedVlan == null && nativeVlan == null && taggedVlans.isEmpty()) {
Saurav Das62ae6792017-05-15 15:34:25 -07001466 log.debug("Not handling port updated event for non-edge port (unconfigured) "
Saurav Dasf0f592d2016-11-18 15:21:57 -08001467 + "dev/port: {}/{}", device.id(), port.number());
1468 return;
1469 }
Saurav Das3fb28272017-03-04 16:08:47 -08001470 if (untaggedVlan != null) {
1471 processEdgePort(device, port, untaggedVlan, true);
1472 }
1473 if (nativeVlan != null) {
1474 processEdgePort(device, port, nativeVlan, true);
1475 }
1476 if (!taggedVlans.isEmpty()) {
1477 taggedVlans.forEach(tag -> processEdgePort(device, port, tag, false));
1478 }
Saurav Dasf0f592d2016-11-18 15:21:57 -08001479 }
1480
Saurav Das3fb28272017-03-04 16:08:47 -08001481 private void processEdgePort(Device device, Port port, VlanId vlanId,
1482 boolean popVlan) {
Saurav Dasf0f592d2016-11-18 15:21:57 -08001483 boolean portUp = port.isEnabled();
1484 if (portUp) {
Saurav Das3fb28272017-03-04 16:08:47 -08001485 log.info("Device:EdgePort {}:{} is enabled in vlan: {}", device.id(),
Charles Chan10b0fb72017-02-02 16:20:42 -08001486 port.number(), vlanId);
Charles Chan873661e2017-11-30 15:37:50 -08001487 hostHandler.processPortUp(new ConnectPoint(device.id(), port.number()));
Saurav Dasf0f592d2016-11-18 15:21:57 -08001488 } else {
Saurav Das3fb28272017-03-04 16:08:47 -08001489 log.info("Device:EdgePort {}:{} is disabled in vlan: {}", device.id(),
Charles Chan10b0fb72017-02-02 16:20:42 -08001490 port.number(), vlanId);
Saurav Dasf0f592d2016-11-18 15:21:57 -08001491 }
1492
Srikanth Vavilapalli64505482015-04-21 13:04:13 -07001493 DefaultGroupHandler groupHandler = groupHandlerMap.get(device.id());
sangho80f11cb2015-04-01 13:05:26 -07001494 if (groupHandler != null) {
Saurav Das3fb28272017-03-04 16:08:47 -08001495 groupHandler.processEdgePort(port.number(), vlanId, popVlan, portUp);
Saurav Dasf0f592d2016-11-18 15:21:57 -08001496 } else {
1497 log.warn("Group handler not found for dev:{}. Not handling edge port"
1498 + " {} event for port:{}", device.id(),
1499 (portUp) ? "UP" : "DOWN", port.number());
sangho80f11cb2015-04-01 13:05:26 -07001500 }
1501 }
sangho27462c62015-05-14 00:39:53 -07001502
Charles Chan8ca5a122017-10-20 16:06:55 -07001503 private void createOrUpdateDeviceConfiguration() {
1504 if (deviceConfiguration == null) {
1505 deviceConfiguration = new DeviceConfiguration(this);
1506 } else {
1507 deviceConfiguration.updateConfig();
1508 }
1509 }
1510
Pier Ventreb6a7f342016-11-26 21:05:22 -08001511 /**
1512 * Registers the given connect point with the NRS, this is necessary
1513 * to receive the NDP and ARP packets from the NRS.
1514 *
1515 * @param portToRegister connect point to register
1516 */
1517 public void registerConnectPoint(ConnectPoint portToRegister) {
Charles Chan2e71ef32017-02-23 15:44:08 -08001518 neighbourResolutionService.registerNeighbourHandler(
Pier Ventreb6a7f342016-11-26 21:05:22 -08001519 portToRegister,
1520 neighbourHandler,
1521 appId
1522 );
1523 }
1524
Charles Chan72f556a2015-10-05 17:50:33 -07001525 private class InternalConfigListener implements NetworkConfigListener {
Saurav Das261c3002017-06-13 15:35:54 -07001526 private static final long PROGRAM_DELAY = 2;
Charles Chan46fdfaf2016-11-09 20:51:44 -08001527 SegmentRoutingManager srManager;
Charles Chane7c61022015-10-07 14:21:45 -07001528
Charles Chanb7f75ac2016-01-11 18:28:54 -08001529 /**
1530 * Constructs the internal network config listener.
1531 *
Charles Chan46fdfaf2016-11-09 20:51:44 -08001532 * @param srManager segment routing manager
Charles Chanb7f75ac2016-01-11 18:28:54 -08001533 */
Charles Chan3ed34d82017-06-22 18:03:14 -07001534 InternalConfigListener(SegmentRoutingManager srManager) {
Charles Chan46fdfaf2016-11-09 20:51:44 -08001535 this.srManager = srManager;
Charles Chane7c61022015-10-07 14:21:45 -07001536 }
1537
Charles Chanb7f75ac2016-01-11 18:28:54 -08001538 /**
1539 * Reads network config and initializes related data structure accordingly.
1540 */
Charles Chan873661e2017-11-30 15:37:50 -08001541 void configureNetwork() {
Charles Chan8ca5a122017-10-20 16:06:55 -07001542 createOrUpdateDeviceConfiguration();
Charles Chane7c61022015-10-07 14:21:45 -07001543
Charles Chan46fdfaf2016-11-09 20:51:44 -08001544 arpHandler = new ArpHandler(srManager);
1545 icmpHandler = new IcmpHandler(srManager);
1546 ipHandler = new IpHandler(srManager);
1547 routingRulePopulator = new RoutingRulePopulator(srManager);
1548 defaultRoutingHandler = new DefaultRoutingHandler(srManager);
Charles Chane7c61022015-10-07 14:21:45 -07001549
1550 tunnelHandler = new TunnelHandler(linkService, deviceConfiguration,
1551 groupHandlerMap, tunnelStore);
1552 policyHandler = new PolicyHandler(appId, deviceConfiguration,
1553 flowObjectiveService,
1554 tunnelHandler, policyStore);
Saurav Das261c3002017-06-13 15:35:54 -07001555 // add a small delay to absorb multiple network config added notifications
1556 if (!programmingScheduled.get()) {
1557 programmingScheduled.set(true);
1558 executorService.schedule(new ConfigChange(), PROGRAM_DELAY,
1559 TimeUnit.SECONDS);
Charles Chane7c61022015-10-07 14:21:45 -07001560 }
Charles Chan72779502016-04-23 17:36:10 -07001561 mcastHandler.init();
Charles Chane7c61022015-10-07 14:21:45 -07001562 }
1563
Charles Chan72f556a2015-10-05 17:50:33 -07001564 @Override
1565 public void event(NetworkConfigEvent event) {
Charles Chan82ab1932016-01-30 23:22:37 -08001566 // TODO move this part to NetworkConfigEventHandler
1567 if (event.configClass().equals(SegmentRoutingDeviceConfig.class)) {
1568 switch (event.type()) {
1569 case CONFIG_ADDED:
Charles Chan68363b12017-06-26 15:25:09 -07001570 log.info("Segment Routing Device Config added for {}", event.subject());
Charles Chan82ab1932016-01-30 23:22:37 -08001571 configureNetwork();
1572 break;
1573 case CONFIG_UPDATED:
Charles Chan68363b12017-06-26 15:25:09 -07001574 log.info("Segment Routing Config updated for {}", event.subject());
Charles Chan8ca5a122017-10-20 16:06:55 -07001575 createOrUpdateDeviceConfiguration();
Charles Chan68363b12017-06-26 15:25:09 -07001576 // TODO support dynamic configuration
1577 break;
1578 default:
1579 break;
1580 }
1581 } else if (event.configClass().equals(InterfaceConfig.class)) {
1582 switch (event.type()) {
1583 case CONFIG_ADDED:
1584 log.info("Interface Config added for {}", event.subject());
1585 configureNetwork();
1586 break;
1587 case CONFIG_UPDATED:
1588 log.info("Interface Config updated for {}", event.subject());
Charles Chan8ca5a122017-10-20 16:06:55 -07001589 createOrUpdateDeviceConfiguration();
Jonghwan Hyune5ef7622017-08-25 17:48:36 -07001590
1591 // Following code will be uncommented when [CORD-634] is fully implemented.
1592 // [CORD-634] Add dynamic config support for interfaces
1593 updateInterface((InterfaceConfig) event.config().get(),
1594 (InterfaceConfig) event.prevConfig().get());
Charles Chan82ab1932016-01-30 23:22:37 -08001595 // TODO support dynamic configuration
1596 break;
1597 default:
1598 break;
Charles Chan2b078ae2015-10-14 11:24:40 -07001599 }
Charles Chan82ab1932016-01-30 23:22:37 -08001600 } else if (event.configClass().equals(SegmentRoutingAppConfig.class)) {
Charles Chan82f19972016-05-17 13:13:55 -07001601 checkState(appCfgHandler != null, "NetworkConfigEventHandler is not initialized");
Charles Chan82ab1932016-01-30 23:22:37 -08001602 switch (event.type()) {
1603 case CONFIG_ADDED:
Charles Chan82f19972016-05-17 13:13:55 -07001604 appCfgHandler.processAppConfigAdded(event);
Charles Chan82ab1932016-01-30 23:22:37 -08001605 break;
1606 case CONFIG_UPDATED:
Charles Chan82f19972016-05-17 13:13:55 -07001607 appCfgHandler.processAppConfigUpdated(event);
Charles Chan82ab1932016-01-30 23:22:37 -08001608 break;
1609 case CONFIG_REMOVED:
Charles Chan82f19972016-05-17 13:13:55 -07001610 appCfgHandler.processAppConfigRemoved(event);
1611 break;
1612 default:
1613 break;
1614 }
Charles Chandebfea32016-10-24 14:52:01 -07001615 configureNetwork();
Charles Chan82f19972016-05-17 13:13:55 -07001616 } else if (event.configClass().equals(XConnectConfig.class)) {
1617 checkState(xConnectHandler != null, "XConnectHandler is not initialized");
1618 switch (event.type()) {
1619 case CONFIG_ADDED:
1620 xConnectHandler.processXConnectConfigAdded(event);
1621 break;
1622 case CONFIG_UPDATED:
1623 xConnectHandler.processXConnectConfigUpdated(event);
1624 break;
1625 case CONFIG_REMOVED:
1626 xConnectHandler.processXConnectConfigRemoved(event);
Charles Chan82ab1932016-01-30 23:22:37 -08001627 break;
1628 default:
1629 break;
Charles Chan2b078ae2015-10-14 11:24:40 -07001630 }
Pier Ventre6b19e482016-11-07 16:21:04 -08001631 } else if (event.configClass().equals(PwaasConfig.class)) {
1632 checkState(l2TunnelHandler != null, "L2TunnelHandler is not initialized");
1633 switch (event.type()) {
1634 case CONFIG_ADDED:
1635 l2TunnelHandler.processPwaasConfigAdded(event);
1636 break;
1637 case CONFIG_UPDATED:
1638 l2TunnelHandler.processPwaasConfigUpdated(event);
1639 break;
1640 case CONFIG_REMOVED:
1641 l2TunnelHandler.processPwaasConfigRemoved(event);
1642 break;
1643 default:
1644 break;
1645 }
Charles Chan72f556a2015-10-05 17:50:33 -07001646 }
1647 }
Saurav Das261c3002017-06-13 15:35:54 -07001648
1649 private final class ConfigChange implements Runnable {
1650 @Override
1651 public void run() {
1652 programmingScheduled.set(false);
1653 for (Device device : deviceService.getDevices()) {
1654 processDeviceAdded(device);
1655 }
1656 defaultRoutingHandler.startPopulationProcess();
1657 }
1658 }
Charles Chan72f556a2015-10-05 17:50:33 -07001659 }
Charles Chanf4586112015-11-09 16:37:23 -08001660
1661 private class InternalHostListener implements HostListener {
Charles Chanf4586112015-11-09 16:37:23 -08001662 @Override
1663 public void event(HostEvent event) {
Charles Chanf4586112015-11-09 16:37:23 -08001664 switch (event.type()) {
1665 case HOST_ADDED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001666 hostHandler.processHostAddedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001667 break;
1668 case HOST_MOVED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001669 hostHandler.processHostMovedEvent(event);
Charles Chan910be6a2017-08-23 14:46:43 -07001670 routeHandler.processHostMovedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001671 break;
1672 case HOST_REMOVED:
Charles Chand9265a32017-06-16 15:19:24 -07001673 hostHandler.processHostRemovedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001674 break;
1675 case HOST_UPDATED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001676 hostHandler.processHostUpdatedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001677 break;
1678 default:
1679 log.warn("Unsupported host event type: {}", event.type());
1680 break;
1681 }
1682 }
1683 }
1684
Charles Chanc91c8782016-03-30 17:54:24 -07001685 private class InternalMcastListener implements McastListener {
1686 @Override
1687 public void event(McastEvent event) {
1688 switch (event.type()) {
1689 case SOURCE_ADDED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001690 mcastHandler.processSourceAdded(event);
Charles Chanc91c8782016-03-30 17:54:24 -07001691 break;
1692 case SINK_ADDED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001693 mcastHandler.processSinkAdded(event);
Charles Chanc91c8782016-03-30 17:54:24 -07001694 break;
1695 case SINK_REMOVED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001696 mcastHandler.processSinkRemoved(event);
Charles Chanc91c8782016-03-30 17:54:24 -07001697 break;
1698 case ROUTE_ADDED:
1699 case ROUTE_REMOVED:
1700 default:
1701 break;
1702 }
1703 }
1704 }
Charles Chan41f5ec02016-06-13 18:54:31 -07001705
Charles Chandebfea32016-10-24 14:52:01 -07001706 private class InternalRouteEventListener implements RouteListener {
1707 @Override
1708 public void event(RouteEvent event) {
1709 switch (event.type()) {
1710 case ROUTE_ADDED:
1711 routeHandler.processRouteAdded(event);
1712 break;
1713 case ROUTE_UPDATED:
1714 routeHandler.processRouteUpdated(event);
1715 break;
1716 case ROUTE_REMOVED:
1717 routeHandler.processRouteRemoved(event);
1718 break;
Charles Chan910be6a2017-08-23 14:46:43 -07001719 case ALTERNATIVE_ROUTES_CHANGED:
1720 routeHandler.processAlternativeRoutesChanged(event);
1721 break;
Charles Chandebfea32016-10-24 14:52:01 -07001722 default:
1723 break;
1724 }
1725 }
1726 }
Saurav Das62ae6792017-05-15 15:34:25 -07001727
Jonghwan Hyune5ef7622017-08-25 17:48:36 -07001728 private void updateInterface(InterfaceConfig conf, InterfaceConfig prevConf) {
1729 try {
1730 Set<Interface> intfs = conf.getInterfaces();
1731 Set<Interface> prevIntfs = prevConf.getInterfaces();
1732
1733 // Now we only handle one interface config at each port.
1734 if (intfs.size() != 1 || prevIntfs.size() != 1) {
1735 log.warn("Interface update aborted - one at a time is allowed, " +
1736 "but {} / {}(prev) received.", intfs.size(), prevIntfs.size());
1737 return;
1738 }
1739
1740 Interface intf = intfs.stream().findFirst().get();
1741 Interface prevIntf = prevIntfs.stream().findFirst().get();
1742
1743 DeviceId deviceId = intf.connectPoint().deviceId();
1744 PortNumber portNum = intf.connectPoint().port();
1745
1746 if (!mastershipService.isLocalMaster(deviceId)) {
1747 log.debug("CONFIG_UPDATED event for interfaces should be " +
1748 "handled by master node for device {}", deviceId);
1749 return;
1750 }
1751
1752 removeSubnetConfig(prevIntf.connectPoint(),
1753 Sets.difference(new HashSet<>(prevIntf.ipAddressesList()),
1754 new HashSet<>(intf.ipAddressesList())));
1755
1756 if (prevIntf.vlanNative() != VlanId.NONE && !intf.vlanNative().equals(prevIntf.vlanNative())) {
1757 // RemoveVlanNative
1758 updateVlanConfigInternal(deviceId, portNum, prevIntf.vlanNative(), true, false);
1759 }
1760
1761 if (!prevIntf.vlanTagged().isEmpty() && !intf.vlanTagged().equals(prevIntf.vlanTagged())) {
1762 // RemoveVlanTagged
1763 prevIntf.vlanTagged().stream().filter(i -> !intf.vlanTagged().contains(i)).forEach(
1764 vlanId -> updateVlanConfigInternal(deviceId, portNum, vlanId, false, false)
1765 );
1766 }
1767
1768 if (prevIntf.vlanUntagged() != VlanId.NONE && !intf.vlanUntagged().equals(prevIntf.vlanUntagged())) {
1769 // RemoveVlanUntagged
1770 updateVlanConfigInternal(deviceId, portNum, prevIntf.vlanUntagged(), true, false);
1771 }
1772
1773 if (intf.vlanNative() != VlanId.NONE && !prevIntf.vlanNative().equals(intf.vlanNative())) {
1774 // AddVlanNative
1775 updateVlanConfigInternal(deviceId, portNum, intf.vlanNative(), true, true);
1776 }
1777
1778 if (!intf.vlanTagged().isEmpty() && !intf.vlanTagged().equals(prevIntf.vlanTagged())) {
1779 // AddVlanTagged
1780 intf.vlanTagged().stream().filter(i -> !prevIntf.vlanTagged().contains(i)).forEach(
1781 vlanId -> updateVlanConfigInternal(deviceId, portNum, vlanId, false, true)
1782 );
1783 }
1784
1785 if (intf.vlanUntagged() != VlanId.NONE && !prevIntf.vlanUntagged().equals(intf.vlanUntagged())) {
1786 // AddVlanUntagged
1787 updateVlanConfigInternal(deviceId, portNum, intf.vlanUntagged(), true, true);
1788 }
1789 addSubnetConfig(prevIntf.connectPoint(),
1790 Sets.difference(new HashSet<>(intf.ipAddressesList()),
1791 new HashSet<>(prevIntf.ipAddressesList())));
1792 } catch (ConfigException e) {
1793 log.error("Error in configuration");
1794 }
1795 }
1796
1797 private void updateVlanConfigInternal(DeviceId deviceId, PortNumber portNum,
1798 VlanId vlanId, boolean pushVlan, boolean install) {
1799 DefaultGroupHandler grpHandler = getGroupHandler(deviceId);
1800 if (grpHandler == null) {
1801 log.warn("Failed to retrieve group handler for device {}", deviceId);
1802 return;
1803 }
1804
1805 // Update filtering objective for a single port
1806 routingRulePopulator.updateSinglePortFilters(deviceId, portNum, pushVlan, vlanId, install);
1807
1808 // Update filtering objective for multicast ingress port
1809 mcastHandler.updateFilterToDevice(deviceId, portNum, vlanId, install);
1810
1811 int nextId = getVlanNextObjectiveId(deviceId, vlanId);
1812
1813 if (nextId != -1 && !install) {
1814 // Update next objective for a single port as an output port
1815 // Remove a single port from L2FG
1816 grpHandler.updateGroupFromVlanConfiguration(portNum, Collections.singleton(vlanId), nextId, install);
1817 // Remove L2 Bridging rule and L3 Unicast rule to the host
1818 hostHandler.processIntfVlanUpdatedEvent(deviceId, portNum, vlanId, pushVlan, install);
1819 // Remove broadcast forwarding rule and corresponding L2FG for VLAN
1820 // only if there is no port configured on that VLAN ID
1821 if (!getVlanPortMap(deviceId).containsKey(vlanId)) {
1822 // Remove broadcast forwarding rule for the VLAN
1823 routingRulePopulator.updateSubnetBroadcastRule(deviceId, vlanId, install);
1824 // Remove L2FG for VLAN
1825 grpHandler.removeBcastGroupFromVlan(deviceId, portNum, vlanId, pushVlan);
1826 } else {
1827 // Remove L2IG of the port
1828 grpHandler.removePortNextObjective(deviceId, portNum, vlanId, pushVlan);
1829 }
1830 } else if (install) {
1831 if (nextId != -1) {
1832 // Add a single port to L2FG
1833 grpHandler.updateGroupFromVlanConfiguration(portNum, Collections.singleton(vlanId), nextId, install);
1834 } else {
1835 // Create L2FG for VLAN
1836 grpHandler.createBcastGroupFromVlan(vlanId, Collections.singleton(portNum));
1837 routingRulePopulator.updateSubnetBroadcastRule(deviceId, vlanId, install);
1838 }
1839 hostHandler.processIntfVlanUpdatedEvent(deviceId, portNum, vlanId, pushVlan, install);
1840 } else {
1841 log.warn("Failed to retrieve next objective for vlan {} in device {}:{}", vlanId, deviceId, portNum);
1842 }
1843 }
1844
1845 private void removeSubnetConfig(ConnectPoint cp, Set<InterfaceIpAddress> ipAddressSet) {
1846 Set<IpPrefix> ipPrefixSet = ipAddressSet.stream().
1847 map(InterfaceIpAddress::subnetAddress).collect(Collectors.toSet());
1848
1849 Set<InterfaceIpAddress> deviceIntfIpAddrs = interfaceService.getInterfaces().stream()
1850 .filter(intf -> intf.connectPoint().deviceId().equals(cp.deviceId()))
1851 .filter(intf -> !intf.connectPoint().equals(cp))
1852 .flatMap(intf -> intf.ipAddressesList().stream())
1853 .collect(Collectors.toSet());
1854 // 1. Partial subnet population
1855 // Remove routing rules for removed subnet from previous configuration,
1856 // which does not also exist in other interfaces in the same device
1857 Set<IpPrefix> deviceIpPrefixSet = deviceIntfIpAddrs.stream()
1858 .map(InterfaceIpAddress::subnetAddress)
1859 .collect(Collectors.toSet());
1860
1861 defaultRoutingHandler.revokeSubnet(
1862 ipPrefixSet.stream()
1863 .filter(ipPrefix -> !deviceIpPrefixSet.contains(ipPrefix))
1864 .collect(Collectors.toSet()));
1865
1866 // 2. Interface IP punts
1867 // Remove IP punts for old Intf address
1868 Set<IpAddress> deviceIpAddrs = deviceIntfIpAddrs.stream()
1869 .map(InterfaceIpAddress::ipAddress)
1870 .collect(Collectors.toSet());
1871 ipAddressSet.stream()
1872 .map(InterfaceIpAddress::ipAddress)
1873 .filter(interfaceIpAddress -> !deviceIpAddrs.contains(interfaceIpAddress))
1874 .forEach(interfaceIpAddress ->
1875 routingRulePopulator.revokeSingleIpPunts(
1876 cp.deviceId(), interfaceIpAddress));
1877
1878 // 3. Host unicast routing rule
1879 // Remove unicast routing rule
1880 hostHandler.processIntfIpUpdatedEvent(cp, ipPrefixSet, false);
1881 }
1882
1883 private void addSubnetConfig(ConnectPoint cp, Set<InterfaceIpAddress> ipAddressSet) {
1884 Set<IpPrefix> ipPrefixSet = ipAddressSet.stream().
1885 map(InterfaceIpAddress::subnetAddress).collect(Collectors.toSet());
1886
1887 Set<InterfaceIpAddress> deviceIntfIpAddrs = interfaceService.getInterfaces().stream()
1888 .filter(intf -> intf.connectPoint().deviceId().equals(cp.deviceId()))
1889 .filter(intf -> !intf.connectPoint().equals(cp))
1890 .flatMap(intf -> intf.ipAddressesList().stream())
1891 .collect(Collectors.toSet());
1892 // 1. Partial subnet population
1893 // Add routing rules for newly added subnet, which does not also exist in
1894 // other interfaces in the same device
1895 Set<IpPrefix> deviceIpPrefixSet = deviceIntfIpAddrs.stream()
1896 .map(InterfaceIpAddress::subnetAddress)
1897 .collect(Collectors.toSet());
1898
1899 defaultRoutingHandler.populateSubnet(
1900 Collections.singleton(cp),
1901 ipPrefixSet.stream()
1902 .filter(ipPrefix -> !deviceIpPrefixSet.contains(ipPrefix))
1903 .collect(Collectors.toSet()));
1904
1905 // 2. Interface IP punts
1906 // Add IP punts for new Intf address
1907 Set<IpAddress> deviceIpAddrs = deviceIntfIpAddrs.stream()
1908 .map(InterfaceIpAddress::ipAddress)
1909 .collect(Collectors.toSet());
1910 ipAddressSet.stream()
1911 .map(InterfaceIpAddress::ipAddress)
1912 .filter(interfaceIpAddress -> !deviceIpAddrs.contains(interfaceIpAddress))
1913 .forEach(interfaceIpAddress ->
1914 routingRulePopulator.populateSingleIpPunts(
1915 cp.deviceId(), interfaceIpAddress));
1916
1917 // 3. Host unicast routing rule
1918 // Add unicast routing rule
1919 hostHandler.processIntfIpUpdatedEvent(cp, ipPrefixSet, true);
1920 }
sangho80f11cb2015-04-01 13:05:26 -07001921}