blob: dd2f5e8e2827bb9105a5e2b09ee4c62a5dd1ce32 [file] [log] [blame]
sangho80f11cb2015-04-01 13:05:26 -07001/*
Brian O'Connor43b53542016-04-09 01:19:45 -07002 * Copyright 2015-present Open Networking Laboratory
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 Chand7844e52016-10-20 17:02:44 -070018import com.google.common.collect.Maps;
sangho80f11cb2015-04-01 13:05:26 -070019import org.apache.felix.scr.annotations.Activate;
20import org.apache.felix.scr.annotations.Component;
21import org.apache.felix.scr.annotations.Deactivate;
22import org.apache.felix.scr.annotations.Reference;
23import org.apache.felix.scr.annotations.ReferenceCardinality;
sangho27462c62015-05-14 00:39:53 -070024import org.apache.felix.scr.annotations.Service;
sangho80f11cb2015-04-01 13:05:26 -070025import org.onlab.packet.Ethernet;
Charles Chan77277672015-10-20 16:24:19 -070026import org.onlab.packet.IPv4;
Charles Chan77277672015-10-20 16:24:19 -070027import org.onlab.packet.Ip4Prefix;
Charles Chan77277672015-10-20 16:24:19 -070028import org.onlab.packet.IpPrefix;
Jonathan Hart54541d12016-04-12 15:39:44 -070029import org.onlab.packet.VlanId;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -070030import org.onlab.util.KryoNamespace;
Saurav Dasc3604f12016-03-23 11:22:49 -070031import org.onosproject.cfg.ComponentConfigService;
sangho80f11cb2015-04-01 13:05:26 -070032import org.onosproject.core.ApplicationId;
33import org.onosproject.core.CoreService;
34import org.onosproject.event.Event;
Charles Chanc91c8782016-03-30 17:54:24 -070035import org.onosproject.incubator.net.config.basics.McastConfig;
Charles Chan46fdfaf2016-11-09 20:51:44 -080036import org.onosproject.incubator.net.intf.InterfaceService;
Jonathan Hart54541d12016-04-12 15:39:44 -070037import org.onosproject.mastership.MastershipService;
Jonathan Hart54541d12016-04-12 15:39:44 -070038import org.onosproject.net.Device;
39import org.onosproject.net.DeviceId;
40import org.onosproject.net.Link;
41import org.onosproject.net.Port;
Charles Chanf4586112015-11-09 16:37:23 -080042import org.onosproject.net.PortNumber;
Charles Chan72f556a2015-10-05 17:50:33 -070043import org.onosproject.net.config.ConfigFactory;
44import org.onosproject.net.config.NetworkConfigEvent;
Charles Chan72f556a2015-10-05 17:50:33 -070045import org.onosproject.net.config.NetworkConfigListener;
Jonathan Hart54541d12016-04-12 15:39:44 -070046import org.onosproject.net.config.NetworkConfigRegistry;
Charles Chan72f556a2015-10-05 17:50:33 -070047import org.onosproject.net.config.basics.SubjectFactories;
Jonathan Hart54541d12016-04-12 15:39:44 -070048import org.onosproject.net.device.DeviceEvent;
49import org.onosproject.net.device.DeviceListener;
50import org.onosproject.net.device.DeviceService;
Charles Chanf4586112015-11-09 16:37:23 -080051import org.onosproject.net.flow.DefaultTrafficSelector;
Charles Chanf4586112015-11-09 16:37:23 -080052import org.onosproject.net.flow.TrafficSelector;
53import org.onosproject.net.flow.TrafficTreatment;
Jonathan Hart54541d12016-04-12 15:39:44 -070054import org.onosproject.net.flowobjective.FlowObjectiveService;
Charles Chanf4586112015-11-09 16:37:23 -080055import org.onosproject.net.host.HostEvent;
56import org.onosproject.net.host.HostListener;
Charles Chanc91c8782016-03-30 17:54:24 -070057import org.onosproject.net.mcast.McastEvent;
58import org.onosproject.net.mcast.McastListener;
59import org.onosproject.net.mcast.MulticastRouteService;
60import org.onosproject.net.packet.PacketPriority;
61import org.onosproject.net.topology.TopologyService;
62import org.onosproject.segmentrouting.config.DeviceConfigNotFoundException;
63import org.onosproject.segmentrouting.config.DeviceConfiguration;
64import org.onosproject.segmentrouting.config.SegmentRoutingDeviceConfig;
65import org.onosproject.segmentrouting.config.SegmentRoutingAppConfig;
Charles Chan82f19972016-05-17 13:13:55 -070066import org.onosproject.segmentrouting.config.XConnectConfig;
Charles Chanc91c8782016-03-30 17:54:24 -070067import org.onosproject.segmentrouting.grouphandler.DefaultGroupHandler;
68import org.onosproject.segmentrouting.grouphandler.NeighborSet;
Charles Chan1eaf4802016-04-18 13:44:03 -070069import org.onosproject.segmentrouting.storekey.NeighborSetNextObjectiveStoreKey;
70import org.onosproject.segmentrouting.storekey.PortNextObjectiveStoreKey;
sangho80f11cb2015-04-01 13:05:26 -070071import org.onosproject.net.host.HostService;
sangho80f11cb2015-04-01 13:05:26 -070072import org.onosproject.net.link.LinkEvent;
73import org.onosproject.net.link.LinkListener;
74import org.onosproject.net.link.LinkService;
75import org.onosproject.net.packet.InboundPacket;
76import org.onosproject.net.packet.PacketContext;
77import org.onosproject.net.packet.PacketProcessor;
78import org.onosproject.net.packet.PacketService;
Charles Chan1eaf4802016-04-18 13:44:03 -070079import org.onosproject.segmentrouting.storekey.SubnetAssignedVidStoreKey;
80import org.onosproject.segmentrouting.storekey.SubnetNextObjectiveStoreKey;
Charles Chan82f19972016-05-17 13:13:55 -070081import org.onosproject.segmentrouting.storekey.XConnectStoreKey;
Jonathan Hart54541d12016-04-12 15:39:44 -070082import org.onosproject.store.serializers.KryoNamespaces;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -070083import org.onosproject.store.service.EventuallyConsistentMap;
84import org.onosproject.store.service.EventuallyConsistentMapBuilder;
85import org.onosproject.store.service.StorageService;
86import org.onosproject.store.service.WallClockTimestamp;
Charles Chan41f5ec02016-06-13 18:54:31 -070087import org.opencord.cordconfig.CordConfigEvent;
88import org.opencord.cordconfig.CordConfigListener;
89import org.opencord.cordconfig.CordConfigService;
sangho80f11cb2015-04-01 13:05:26 -070090import org.slf4j.Logger;
91import org.slf4j.LoggerFactory;
92
Saurav Das7c305372015-10-28 12:39:42 -070093import java.util.Collections;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -070094import java.util.HashSet;
sangho27462c62015-05-14 00:39:53 -070095import java.util.List;
sangho80f11cb2015-04-01 13:05:26 -070096import java.util.Map;
Charles Chande6655c2015-12-23 00:15:11 -080097import java.util.Optional;
Saurav Das7c305372015-10-28 12:39:42 -070098import java.util.Set;
sangho80f11cb2015-04-01 13:05:26 -070099import java.util.concurrent.ConcurrentHashMap;
100import java.util.concurrent.ConcurrentLinkedQueue;
101import java.util.concurrent.Executors;
102import java.util.concurrent.ScheduledExecutorService;
103import java.util.concurrent.ScheduledFuture;
104import java.util.concurrent.TimeUnit;
105
Charles Chand6d25332016-02-26 22:19:52 -0800106import static com.google.common.base.Preconditions.checkState;
Yuta HIGUCHIebee2f12016-07-21 16:54:33 -0700107import static org.onlab.util.Tools.groupedThreads;
Charles Chand6d25332016-02-26 22:19:52 -0800108
Jonathan Hart54541d12016-04-12 15:39:44 -0700109
Charles Chanb7f75ac2016-01-11 18:28:54 -0800110/**
111 * Segment routing manager.
112 */
Jonathan Hart54541d12016-04-12 15:39:44 -0700113@Service
114@Component(immediate = true)
sangho27462c62015-05-14 00:39:53 -0700115public class SegmentRoutingManager implements SegmentRoutingService {
sangho80f11cb2015-04-01 13:05:26 -0700116
Charles Chan46fdfaf2016-11-09 20:51:44 -0800117 private static Logger log = LoggerFactory.getLogger(SegmentRoutingManager.class);
sangho80f11cb2015-04-01 13:05:26 -0700118
119 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
120 protected CoreService coreService;
121
122 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
sangho80f11cb2015-04-01 13:05:26 -0700123 protected PacketService packetService;
124
125 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
sangho80f11cb2015-04-01 13:05:26 -0700126 protected HostService hostService;
127
128 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
129 protected DeviceService deviceService;
130
131 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Srikanth Vavilapalli64505482015-04-21 13:04:13 -0700132 protected FlowObjectiveService flowObjectiveService;
sangho80f11cb2015-04-01 13:05:26 -0700133
134 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
135 protected LinkService linkService;
136
137 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
sangho80f11cb2015-04-01 13:05:26 -0700138 protected MastershipService mastershipService;
sangho27462c62015-05-14 00:39:53 -0700139
Charles Chan82ab1932016-01-30 23:22:37 -0800140 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
141 protected StorageService storageService;
142
143 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
Charles Chan46fdfaf2016-11-09 20:51:44 -0800144 public NetworkConfigRegistry cfgService;
Charles Chan82ab1932016-01-30 23:22:37 -0800145
Saurav Dasc3604f12016-03-23 11:22:49 -0700146 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
147 protected ComponentConfigService compCfgService;
148
Charles Chanc91c8782016-03-30 17:54:24 -0700149 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
150 protected MulticastRouteService multicastRouteService;
151
152 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
153 protected TopologyService topologyService;
154
Charles Chan41f5ec02016-06-13 18:54:31 -0700155 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
156 protected CordConfigService cordConfigService;
157
Charles Chan46fdfaf2016-11-09 20:51:44 -0800158 @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
159 public InterfaceService interfaceService;
160
Srikanth Vavilapalli37a461b2015-04-07 15:12:32 -0700161 protected ArpHandler arpHandler = null;
162 protected IcmpHandler icmpHandler = null;
163 protected IpHandler ipHandler = null;
164 protected RoutingRulePopulator routingRulePopulator = null;
Charles Chan46fdfaf2016-11-09 20:51:44 -0800165 public ApplicationId appId;
sangho9b169e32015-04-14 16:27:13 -0700166 protected DeviceConfiguration deviceConfiguration = null;
sangho80f11cb2015-04-01 13:05:26 -0700167
Charles Chanc22cef32016-04-29 14:38:22 -0700168 protected DefaultRoutingHandler defaultRoutingHandler = null;
sangho27462c62015-05-14 00:39:53 -0700169 private TunnelHandler tunnelHandler = null;
170 private PolicyHandler policyHandler = null;
Charles Chan2b078ae2015-10-14 11:24:40 -0700171 private InternalPacketProcessor processor = null;
172 private InternalLinkListener linkListener = null;
173 private InternalDeviceListener deviceListener = null;
Charles Chan82f19972016-05-17 13:13:55 -0700174 private AppConfigHandler appCfgHandler = null;
175 protected XConnectHandler xConnectHandler = null;
Charles Chan1eaf4802016-04-18 13:44:03 -0700176 private McastHandler mcastHandler = null;
Charles Chan41f5ec02016-06-13 18:54:31 -0700177 protected HostHandler hostHandler = null;
178 private CordConfigHandler cordConfigHandler = null;
sangho80f11cb2015-04-01 13:05:26 -0700179 private InternalEventHandler eventHandler = new InternalEventHandler();
Charles Chan82ab1932016-01-30 23:22:37 -0800180 private final InternalHostListener hostListener = new InternalHostListener();
Charles Chanc91c8782016-03-30 17:54:24 -0700181 private final InternalConfigListener cfgListener = new InternalConfigListener(this);
182 private final InternalMcastListener mcastListener = new InternalMcastListener();
Charles Chan41f5ec02016-06-13 18:54:31 -0700183 private final InternalCordConfigListener cordConfigListener = new InternalCordConfigListener();
sangho80f11cb2015-04-01 13:05:26 -0700184
Srikanth Vavilapalli64505482015-04-21 13:04:13 -0700185 private ScheduledExecutorService executorService = Executors
Yuta HIGUCHIebee2f12016-07-21 16:54:33 -0700186 .newScheduledThreadPool(1, groupedThreads("SegmentRoutingManager", "event-%d", log));
sangho80f11cb2015-04-01 13:05:26 -0700187
Saurav Das2d94d312015-11-24 23:21:05 -0800188 @SuppressWarnings("unused")
sangho80f11cb2015-04-01 13:05:26 -0700189 private static ScheduledFuture<?> eventHandlerFuture = null;
Saurav Das2d94d312015-11-24 23:21:05 -0800190 @SuppressWarnings("rawtypes")
Yuta HIGUCHIebee2f12016-07-21 16:54:33 -0700191 private ConcurrentLinkedQueue<Event> eventQueue = new ConcurrentLinkedQueue<>();
Charles Chanf4586112015-11-09 16:37:23 -0800192 private Map<DeviceId, DefaultGroupHandler> groupHandlerMap =
Charles Chanb7f75ac2016-01-11 18:28:54 -0800193 new ConcurrentHashMap<>();
194 /**
195 * Per device next objective ID store with (device id + neighbor set) as key.
196 */
197 public EventuallyConsistentMap<NeighborSetNextObjectiveStoreKey, Integer>
Charles Chanf4586112015-11-09 16:37:23 -0800198 nsNextObjStore = null;
Charles Chanb7f75ac2016-01-11 18:28:54 -0800199 /**
200 * Per device next objective ID store with (device id + subnet) as key.
201 */
202 public EventuallyConsistentMap<SubnetNextObjectiveStoreKey, Integer>
Charles Chanf4586112015-11-09 16:37:23 -0800203 subnetNextObjStore = null;
Charles Chanb7f75ac2016-01-11 18:28:54 -0800204 /**
205 * Per device next objective ID store with (device id + port) as key.
206 */
207 public EventuallyConsistentMap<PortNextObjectiveStoreKey, Integer>
Saurav Das2d94d312015-11-24 23:21:05 -0800208 portNextObjStore = null;
Saurav Das7c305372015-10-28 12:39:42 -0700209 // Per device, per-subnet assigned-vlans store, with (device id + subnet
210 // IPv4 prefix) as key
211 private EventuallyConsistentMap<SubnetAssignedVidStoreKey, VlanId>
Charles Chanb7f75ac2016-01-11 18:28:54 -0800212 subnetVidStore = null;
Saurav Das2d94d312015-11-24 23:21:05 -0800213 private EventuallyConsistentMap<String, Tunnel> tunnelStore = null;
214 private EventuallyConsistentMap<String, Policy> policyStore = null;
sangho4a5c42a2015-05-20 22:16:38 -0700215
Charles Chanc91c8782016-03-30 17:54:24 -0700216 private final ConfigFactory<DeviceId, SegmentRoutingDeviceConfig> deviceConfigFactory =
Charles Chan82f19972016-05-17 13:13:55 -0700217 new ConfigFactory<DeviceId, SegmentRoutingDeviceConfig>(
218 SubjectFactories.DEVICE_SUBJECT_FACTORY,
Charles Chanc91c8782016-03-30 17:54:24 -0700219 SegmentRoutingDeviceConfig.class, "segmentrouting") {
Charles Chan72f556a2015-10-05 17:50:33 -0700220 @Override
Charles Chan82ab1932016-01-30 23:22:37 -0800221 public SegmentRoutingDeviceConfig createConfig() {
222 return new SegmentRoutingDeviceConfig();
Charles Chan72f556a2015-10-05 17:50:33 -0700223 }
224 };
Charles Chanc91c8782016-03-30 17:54:24 -0700225 private final ConfigFactory<ApplicationId, SegmentRoutingAppConfig> appConfigFactory =
Charles Chan82f19972016-05-17 13:13:55 -0700226 new ConfigFactory<ApplicationId, SegmentRoutingAppConfig>(
227 SubjectFactories.APP_SUBJECT_FACTORY,
Charles Chanc91c8782016-03-30 17:54:24 -0700228 SegmentRoutingAppConfig.class, "segmentrouting") {
Charles Chan82ab1932016-01-30 23:22:37 -0800229 @Override
230 public SegmentRoutingAppConfig createConfig() {
231 return new SegmentRoutingAppConfig();
232 }
233 };
Charles Chan82f19972016-05-17 13:13:55 -0700234 private final ConfigFactory<ApplicationId, XConnectConfig> xConnectConfigFactory =
235 new ConfigFactory<ApplicationId, XConnectConfig>(
236 SubjectFactories.APP_SUBJECT_FACTORY,
237 XConnectConfig.class, "xconnect") {
238 @Override
239 public XConnectConfig createConfig() {
240 return new XConnectConfig();
241 }
242 };
Charles Chanc91c8782016-03-30 17:54:24 -0700243 private ConfigFactory<ApplicationId, McastConfig> mcastConfigFactory =
Charles Chan82f19972016-05-17 13:13:55 -0700244 new ConfigFactory<ApplicationId, McastConfig>(
245 SubjectFactories.APP_SUBJECT_FACTORY,
Charles Chanc91c8782016-03-30 17:54:24 -0700246 McastConfig.class, "multicast") {
247 @Override
248 public McastConfig createConfig() {
249 return new McastConfig();
250 }
251 };
252
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700253 private Object threadSchedulerLock = new Object();
254 private static int numOfEventsQueued = 0;
255 private static int numOfEventsExecuted = 0;
sangho80f11cb2015-04-01 13:05:26 -0700256 private static int numOfHandlerExecution = 0;
257 private static int numOfHandlerScheduled = 0;
258
Charles Chan1963f4f2016-02-18 14:22:42 -0800259 /**
260 * Segment Routing App ID.
261 */
Charles Chan46fdfaf2016-11-09 20:51:44 -0800262 public static final String APP_NAME = "org.onosproject.segmentrouting";
Charles Chanb7f75ac2016-01-11 18:28:54 -0800263 /**
264 * The starting value of per-subnet VLAN ID assignment.
265 */
Saurav Das7c305372015-10-28 12:39:42 -0700266 private static final short ASSIGNED_VLAN_START = 4093;
Charles Chanb7f75ac2016-01-11 18:28:54 -0800267 /**
268 * The default VLAN ID assigned to the interfaces without subnet config.
269 */
Saurav Das7c305372015-10-28 12:39:42 -0700270 public static final short ASSIGNED_VLAN_NO_SUBNET = 4094;
271
sangho80f11cb2015-04-01 13:05:26 -0700272 @Activate
273 protected void activate() {
Charles Chan46fdfaf2016-11-09 20:51:44 -0800274 appId = coreService.registerApplication(APP_NAME);
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700275
276 log.debug("Creating EC map nsnextobjectivestore");
277 EventuallyConsistentMapBuilder<NeighborSetNextObjectiveStoreKey, Integer>
278 nsNextObjMapBuilder = storageService.eventuallyConsistentMapBuilder();
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700279 nsNextObjStore = nsNextObjMapBuilder
280 .withName("nsnextobjectivestore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700281 .withSerializer(createSerializer())
Madan Jampani675ae202015-06-24 19:05:56 -0700282 .withTimestampProvider((k, v) -> new WallClockTimestamp())
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700283 .build();
284 log.trace("Current size {}", nsNextObjStore.size());
285
Charles Chan77277672015-10-20 16:24:19 -0700286 log.debug("Creating EC map subnetnextobjectivestore");
287 EventuallyConsistentMapBuilder<SubnetNextObjectiveStoreKey, Integer>
288 subnetNextObjMapBuilder = storageService.eventuallyConsistentMapBuilder();
Charles Chan77277672015-10-20 16:24:19 -0700289 subnetNextObjStore = subnetNextObjMapBuilder
290 .withName("subnetnextobjectivestore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700291 .withSerializer(createSerializer())
Charles Chan77277672015-10-20 16:24:19 -0700292 .withTimestampProvider((k, v) -> new WallClockTimestamp())
293 .build();
294
Saurav Das2d94d312015-11-24 23:21:05 -0800295 log.debug("Creating EC map subnetnextobjectivestore");
296 EventuallyConsistentMapBuilder<PortNextObjectiveStoreKey, Integer>
297 portNextObjMapBuilder = storageService.eventuallyConsistentMapBuilder();
298 portNextObjStore = portNextObjMapBuilder
299 .withName("portnextobjectivestore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700300 .withSerializer(createSerializer())
Saurav Das2d94d312015-11-24 23:21:05 -0800301 .withTimestampProvider((k, v) -> new WallClockTimestamp())
302 .build();
303
sangho4a5c42a2015-05-20 22:16:38 -0700304 EventuallyConsistentMapBuilder<String, Tunnel> tunnelMapBuilder =
305 storageService.eventuallyConsistentMapBuilder();
sangho4a5c42a2015-05-20 22:16:38 -0700306 tunnelStore = tunnelMapBuilder
307 .withName("tunnelstore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700308 .withSerializer(createSerializer())
Madan Jampani675ae202015-06-24 19:05:56 -0700309 .withTimestampProvider((k, v) -> new WallClockTimestamp())
sangho4a5c42a2015-05-20 22:16:38 -0700310 .build();
311
312 EventuallyConsistentMapBuilder<String, Policy> policyMapBuilder =
313 storageService.eventuallyConsistentMapBuilder();
sangho4a5c42a2015-05-20 22:16:38 -0700314 policyStore = policyMapBuilder
315 .withName("policystore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700316 .withSerializer(createSerializer())
Madan Jampani675ae202015-06-24 19:05:56 -0700317 .withTimestampProvider((k, v) -> new WallClockTimestamp())
sangho4a5c42a2015-05-20 22:16:38 -0700318 .build();
319
Saurav Das7c305372015-10-28 12:39:42 -0700320 EventuallyConsistentMapBuilder<SubnetAssignedVidStoreKey, VlanId>
321 subnetVidStoreMapBuilder = storageService.eventuallyConsistentMapBuilder();
Saurav Das7c305372015-10-28 12:39:42 -0700322 subnetVidStore = subnetVidStoreMapBuilder
323 .withName("subnetvidstore")
Jonathan Hart54541d12016-04-12 15:39:44 -0700324 .withSerializer(createSerializer())
Saurav Das7c305372015-10-28 12:39:42 -0700325 .withTimestampProvider((k, v) -> new WallClockTimestamp())
326 .build();
327
Saurav Dasc3604f12016-03-23 11:22:49 -0700328 compCfgService.preSetProperty("org.onosproject.net.group.impl.GroupManager",
329 "purgeOnDisconnection", "true");
330 compCfgService.preSetProperty("org.onosproject.net.flow.impl.FlowRuleManager",
331 "purgeOnDisconnection", "true");
332
Charles Chan2b078ae2015-10-14 11:24:40 -0700333 processor = new InternalPacketProcessor();
334 linkListener = new InternalLinkListener();
335 deviceListener = new InternalDeviceListener();
Charles Chan82f19972016-05-17 13:13:55 -0700336 appCfgHandler = new AppConfigHandler(this);
337 xConnectHandler = new XConnectHandler(this);
Charles Chan1eaf4802016-04-18 13:44:03 -0700338 mcastHandler = new McastHandler(this);
339 hostHandler = new HostHandler(this);
Charles Chan41f5ec02016-06-13 18:54:31 -0700340 cordConfigHandler = new CordConfigHandler(this);
Charles Chan2b078ae2015-10-14 11:24:40 -0700341
Charles Chand6d25332016-02-26 22:19:52 -0800342 cfgService.addListener(cfgListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700343 cfgService.registerConfigFactory(deviceConfigFactory);
344 cfgService.registerConfigFactory(appConfigFactory);
Charles Chan82f19972016-05-17 13:13:55 -0700345 cfgService.registerConfigFactory(xConnectConfigFactory);
Charles Chanc91c8782016-03-30 17:54:24 -0700346 cfgService.registerConfigFactory(mcastConfigFactory);
Charles Chan82ab1932016-01-30 23:22:37 -0800347 hostService.addListener(hostListener);
Charles Chan2b078ae2015-10-14 11:24:40 -0700348 packetService.addProcessor(processor, PacketProcessor.director(2));
349 linkService.addListener(linkListener);
350 deviceService.addListener(deviceListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700351 multicastRouteService.addListener(mcastListener);
Charles Chan41f5ec02016-06-13 18:54:31 -0700352 cordConfigService.addListener(cordConfigListener);
Charles Chan2b078ae2015-10-14 11:24:40 -0700353
Charles Chande6655c2015-12-23 00:15:11 -0800354 // Request ARP packet-in
355 TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
356 selector.matchEthType(Ethernet.TYPE_ARP);
357 packetService.requestPackets(selector.build(), PacketPriority.CONTROL, appId, Optional.empty());
358
Charles Chan2b078ae2015-10-14 11:24:40 -0700359 cfgListener.configureNetwork();
360
sangho80f11cb2015-04-01 13:05:26 -0700361 log.info("Started");
362 }
363
Jonathan Hart54541d12016-04-12 15:39:44 -0700364 private KryoNamespace.Builder createSerializer() {
365 return new KryoNamespace.Builder()
366 .register(KryoNamespaces.API)
367 .register(NeighborSetNextObjectiveStoreKey.class,
368 SubnetNextObjectiveStoreKey.class,
369 SubnetAssignedVidStoreKey.class,
370 NeighborSet.class,
371 Tunnel.class,
372 DefaultTunnel.class,
373 Policy.class,
374 TunnelPolicy.class,
375 Policy.Type.class,
376 PortNextObjectiveStoreKey.class,
Charles Chan82f19972016-05-17 13:13:55 -0700377 XConnectStoreKey.class
Jonathan Hart54541d12016-04-12 15:39:44 -0700378 );
379 }
380
sangho80f11cb2015-04-01 13:05:26 -0700381 @Deactivate
382 protected void deactivate() {
Charles Chan72f556a2015-10-05 17:50:33 -0700383 cfgService.removeListener(cfgListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700384 cfgService.unregisterConfigFactory(deviceConfigFactory);
385 cfgService.unregisterConfigFactory(appConfigFactory);
386 cfgService.unregisterConfigFactory(mcastConfigFactory);
Charles Chan72f556a2015-10-05 17:50:33 -0700387
Charles Chande6655c2015-12-23 00:15:11 -0800388 // Withdraw ARP packet-in
389 TrafficSelector.Builder selector = DefaultTrafficSelector.builder();
390 selector.matchEthType(Ethernet.TYPE_ARP);
391 packetService.cancelPackets(selector.build(), PacketPriority.CONTROL, appId, Optional.empty());
392
sangho80f11cb2015-04-01 13:05:26 -0700393 packetService.removeProcessor(processor);
Charles Chan2b078ae2015-10-14 11:24:40 -0700394 linkService.removeListener(linkListener);
395 deviceService.removeListener(deviceListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700396 multicastRouteService.removeListener(mcastListener);
Charles Chan41f5ec02016-06-13 18:54:31 -0700397 cordConfigService.removeListener(cordConfigListener);
Charles Chanc91c8782016-03-30 17:54:24 -0700398
sangho80f11cb2015-04-01 13:05:26 -0700399 processor = null;
Charles Chan2b078ae2015-10-14 11:24:40 -0700400 linkListener = null;
Charles Chanc91c8782016-03-30 17:54:24 -0700401 deviceListener = null;
Charles Chan2b078ae2015-10-14 11:24:40 -0700402 groupHandlerMap.clear();
403
Charles Chanc91c8782016-03-30 17:54:24 -0700404 nsNextObjStore.destroy();
405 subnetNextObjStore.destroy();
406 portNextObjStore.destroy();
Charles Chanc91c8782016-03-30 17:54:24 -0700407 tunnelStore.destroy();
408 policyStore.destroy();
409 subnetVidStore.destroy();
sangho80f11cb2015-04-01 13:05:26 -0700410 log.info("Stopped");
411 }
412
sangho27462c62015-05-14 00:39:53 -0700413 @Override
414 public List<Tunnel> getTunnels() {
415 return tunnelHandler.getTunnels();
416 }
417
418 @Override
sanghobd812f82015-06-29 14:58:47 -0700419 public TunnelHandler.Result createTunnel(Tunnel tunnel) {
420 return tunnelHandler.createTunnel(tunnel);
sangho27462c62015-05-14 00:39:53 -0700421 }
422
423 @Override
sanghobd812f82015-06-29 14:58:47 -0700424 public TunnelHandler.Result removeTunnel(Tunnel tunnel) {
sangho27462c62015-05-14 00:39:53 -0700425 for (Policy policy: policyHandler.getPolicies()) {
426 if (policy.type() == Policy.Type.TUNNEL_FLOW) {
427 TunnelPolicy tunnelPolicy = (TunnelPolicy) policy;
428 if (tunnelPolicy.tunnelId().equals(tunnel.id())) {
429 log.warn("Cannot remove the tunnel used by a policy");
sanghobd812f82015-06-29 14:58:47 -0700430 return TunnelHandler.Result.TUNNEL_IN_USE;
sangho27462c62015-05-14 00:39:53 -0700431 }
432 }
433 }
sanghobd812f82015-06-29 14:58:47 -0700434 return tunnelHandler.removeTunnel(tunnel);
sangho27462c62015-05-14 00:39:53 -0700435 }
436
437 @Override
sanghobd812f82015-06-29 14:58:47 -0700438 public PolicyHandler.Result removePolicy(Policy policy) {
439 return policyHandler.removePolicy(policy);
sangho27462c62015-05-14 00:39:53 -0700440 }
441
442 @Override
sanghobd812f82015-06-29 14:58:47 -0700443 public PolicyHandler.Result createPolicy(Policy policy) {
444 return policyHandler.createPolicy(policy);
sangho27462c62015-05-14 00:39:53 -0700445 }
446
447 @Override
448 public List<Policy> getPolicies() {
449 return policyHandler.getPolicies();
450 }
451
Saurav Das07c74602016-04-27 18:35:50 -0700452 @Override
453 public void rerouteNetwork() {
454 cfgListener.configureNetwork();
455 for (Device device : deviceService.getDevices()) {
456 defaultRoutingHandler.populatePortAddressingRules(device.id());
457 }
458 defaultRoutingHandler.startPopulationProcess();
459 }
460
Charles Chand7844e52016-10-20 17:02:44 -0700461 @Override
462 public Map<DeviceId, Set<Ip4Prefix>> getDeviceSubnetMap() {
463 Map<DeviceId, Set<Ip4Prefix>> deviceSubnetMap = Maps.newHashMap();
464 deviceService.getAvailableDevices().forEach(device -> {
465 deviceSubnetMap.put(device.id(), deviceConfiguration.getSubnets(device.id()));
466 });
467 return deviceSubnetMap;
468 }
469
sangho80f1f892015-05-19 11:57:42 -0700470 /**
Pier Ventre7a78de22016-10-31 15:00:01 -0700471 * Returns the MPLS-ECMP configuration.
472 *
473 * @return MPLS-ECMP value
474 */
475 public boolean getMplsEcmp() {
476 SegmentRoutingAppConfig segmentRoutingAppConfig = cfgService
477 .getConfig(this.appId, SegmentRoutingAppConfig.class);
478 return segmentRoutingAppConfig != null && segmentRoutingAppConfig.mplsEcmp();
479 }
480
481 /**
sangho80f1f892015-05-19 11:57:42 -0700482 * Returns the tunnel object with the tunnel ID.
483 *
484 * @param tunnelId Tunnel ID
485 * @return Tunnel reference
486 */
sangho27462c62015-05-14 00:39:53 -0700487 public Tunnel getTunnel(String tunnelId) {
488 return tunnelHandler.getTunnel(tunnelId);
489 }
490
sangho80f11cb2015-04-01 13:05:26 -0700491 /**
Saurav Das7c305372015-10-28 12:39:42 -0700492 * Returns the vlan-id assigned to the subnet configured for a device.
493 * If no vlan-id has been assigned, a new one is assigned out of a pool of ids,
494 * if and only if this controller instance is the master for the device.
495 * <p>
496 * USAGE: The assigned vlans are meant to be applied to untagged packets on those
497 * switches/pipelines that need this functionality. These vids are meant
498 * to be used internally within a switch, and thus need to be unique only
499 * on a switch level. Note that packets never go out on the wire with these
500 * vlans. Currently, vlan ids are assigned from value 4093 down.
501 * Vlan id 4094 expected to be used for all ports that are not assigned subnets.
502 * Vlan id 4095 is reserved and unused. Only a single vlan id is assigned
503 * per subnet.
sangho80f11cb2015-04-01 13:05:26 -0700504 *
Saurav Das7c305372015-10-28 12:39:42 -0700505 * @param deviceId switch dpid
506 * @param subnet IPv4 prefix for which assigned vlan is desired
507 * @return VlanId assigned for the subnet on the device, or
508 * null if no vlan assignment was found and this instance is not
509 * the master for the device.
sangho80f11cb2015-04-01 13:05:26 -0700510 */
Charles Chanb7f75ac2016-01-11 18:28:54 -0800511 // TODO: We should avoid assigning VLAN IDs that are used by VLAN cross-connection.
Saurav Das7c305372015-10-28 12:39:42 -0700512 public VlanId getSubnetAssignedVlanId(DeviceId deviceId, Ip4Prefix subnet) {
513 VlanId assignedVid = subnetVidStore.get(new SubnetAssignedVidStoreKey(
514 deviceId, subnet));
515 if (assignedVid != null) {
516 log.debug("Query for subnet:{} on device:{} returned assigned-vlan "
517 + "{}", subnet, deviceId, assignedVid);
518 return assignedVid;
519 }
520 //check mastership for the right to assign a vlan
521 if (!mastershipService.isLocalMaster(deviceId)) {
522 log.warn("This controller instance is not the master for device {}. "
523 + "Cannot assign vlan-id for subnet {}", deviceId, subnet);
524 return null;
525 }
526 // vlan assignment is expensive but done only once
Charles Chanc6ad7752015-10-29 14:58:10 -0700527 Set<Ip4Prefix> configuredSubnets = deviceConfiguration.getSubnets(deviceId);
Saurav Das7c305372015-10-28 12:39:42 -0700528 Set<Short> assignedVlans = new HashSet<>();
529 Set<Ip4Prefix> unassignedSubnets = new HashSet<>();
530 for (Ip4Prefix sub : configuredSubnets) {
531 VlanId v = subnetVidStore.get(new SubnetAssignedVidStoreKey(deviceId,
532 sub));
533 if (v != null) {
534 assignedVlans.add(v.toShort());
535 } else {
536 unassignedSubnets.add(sub);
537 }
538 }
539 short nextAssignedVlan = ASSIGNED_VLAN_START;
540 if (!assignedVlans.isEmpty()) {
541 nextAssignedVlan = (short) (Collections.min(assignedVlans) - 1);
542 }
543 for (Ip4Prefix unsub : unassignedSubnets) {
Charles Chan82ab1932016-01-30 23:22:37 -0800544 // Special case for default route. Assign default VLAN ID to /32 and /0 subnets
545 if (unsub.prefixLength() == IpPrefix.MAX_INET_MASK_LENGTH ||
546 unsub.prefixLength() == 0) {
547 subnetVidStore.put(new SubnetAssignedVidStoreKey(deviceId, unsub),
548 VlanId.vlanId(ASSIGNED_VLAN_NO_SUBNET));
549 } else {
550 subnetVidStore.put(new SubnetAssignedVidStoreKey(deviceId, unsub),
551 VlanId.vlanId(nextAssignedVlan--));
552 log.info("Assigned vlan: {} to subnet: {} on device: {}",
553 nextAssignedVlan + 1, unsub, deviceId);
554 }
sangho80f11cb2015-04-01 13:05:26 -0700555 }
556
Saurav Das7c305372015-10-28 12:39:42 -0700557 return subnetVidStore.get(new SubnetAssignedVidStoreKey(deviceId, subnet));
sangho80f11cb2015-04-01 13:05:26 -0700558 }
559
sangho27462c62015-05-14 00:39:53 -0700560 /**
Saurav Das7c305372015-10-28 12:39:42 -0700561 * Returns the next objective ID for the given NeighborSet.
Saurav Das4c35fc42015-11-20 15:27:53 -0800562 * If the nextObjective does not exist, a new one is created and
Saurav Das2d94d312015-11-24 23:21:05 -0800563 * its id is returned.
sangho27462c62015-05-14 00:39:53 -0700564 *
sangho80f1f892015-05-19 11:57:42 -0700565 * @param deviceId Device ID
566 * @param ns NegighborSet
Saurav Das4c35fc42015-11-20 15:27:53 -0800567 * @param meta metadata passed into the creation of a Next Objective
568 * @return next objective ID or -1 if an error was encountered during the
569 * creation of the nextObjective
sangho27462c62015-05-14 00:39:53 -0700570 */
Saurav Das4c35fc42015-11-20 15:27:53 -0800571 public int getNextObjectiveId(DeviceId deviceId, NeighborSet ns,
572 TrafficSelector meta) {
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700573 if (groupHandlerMap.get(deviceId) != null) {
574 log.trace("getNextObjectiveId query in device {}", deviceId);
575 return groupHandlerMap
Saurav Das4c35fc42015-11-20 15:27:53 -0800576 .get(deviceId).getNextObjectiveId(ns, meta);
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700577 } else {
Saurav Das2d94d312015-11-24 23:21:05 -0800578 log.warn("getNextObjectiveId query - groupHandler for device {} "
579 + "not found", deviceId);
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700580 return -1;
581 }
Srikanth Vavilapalli64505482015-04-21 13:04:13 -0700582 }
583
Charles Chan77277672015-10-20 16:24:19 -0700584 /**
Saurav Das2d94d312015-11-24 23:21:05 -0800585 * Returns the next objective ID for the given subnet prefix. It is expected
586 * that the next-objective has been pre-created from configuration.
Charles Chan77277672015-10-20 16:24:19 -0700587 *
588 * @param deviceId Device ID
589 * @param prefix Subnet
Saurav Das2d94d312015-11-24 23:21:05 -0800590 * @return next objective ID or -1 if it was not found
Charles Chan77277672015-10-20 16:24:19 -0700591 */
592 public int getSubnetNextObjectiveId(DeviceId deviceId, IpPrefix prefix) {
593 if (groupHandlerMap.get(deviceId) != null) {
594 log.trace("getSubnetNextObjectiveId query in device {}", deviceId);
595 return groupHandlerMap
596 .get(deviceId).getSubnetNextObjectiveId(prefix);
597 } else {
Saurav Das2d94d312015-11-24 23:21:05 -0800598 log.warn("getSubnetNextObjectiveId query - groupHandler for "
599 + "device {} not found", deviceId);
600 return -1;
601 }
602 }
603
604 /**
605 * Returns the next objective ID for the given portNumber, given the treatment.
606 * There could be multiple different treatments to the same outport, which
607 * would result in different objectives. If the next object
608 * does not exist, a new one is created and its id is returned.
609 *
610 * @param deviceId Device ID
611 * @param portNum port number on device for which NextObjective is queried
612 * @param treatment the actions to apply on the packets (should include outport)
613 * @param meta metadata passed into the creation of a Next Objective if necessary
Saurav Das07c74602016-04-27 18:35:50 -0700614 * @return next objective ID or -1 if an error occurred during retrieval or creation
Saurav Das2d94d312015-11-24 23:21:05 -0800615 */
616 public int getPortNextObjectiveId(DeviceId deviceId, PortNumber portNum,
617 TrafficTreatment treatment,
618 TrafficSelector meta) {
619 DefaultGroupHandler ghdlr = groupHandlerMap.get(deviceId);
620 if (ghdlr != null) {
621 return ghdlr.getPortNextObjectiveId(portNum, treatment, meta);
622 } else {
Charles Chanb7f75ac2016-01-11 18:28:54 -0800623 log.warn("getPortNextObjectiveId query - groupHandler for device {}"
624 + " not found", deviceId);
625 return -1;
626 }
627 }
628
sangho80f11cb2015-04-01 13:05:26 -0700629 private class InternalPacketProcessor implements PacketProcessor {
sangho80f11cb2015-04-01 13:05:26 -0700630 @Override
631 public void process(PacketContext context) {
632
633 if (context.isHandled()) {
634 return;
635 }
636
637 InboundPacket pkt = context.inPacket();
638 Ethernet ethernet = pkt.parsed();
Saurav Das2d94d312015-11-24 23:21:05 -0800639 log.trace("Rcvd pktin: {}", ethernet);
sangho80f11cb2015-04-01 13:05:26 -0700640 if (ethernet.getEtherType() == Ethernet.TYPE_ARP) {
641 arpHandler.processPacketIn(pkt);
642 } else if (ethernet.getEtherType() == Ethernet.TYPE_IPV4) {
643 IPv4 ipPacket = (IPv4) ethernet.getPayload();
644 ipHandler.addToPacketBuffer(ipPacket);
645 if (ipPacket.getProtocol() == IPv4.PROTOCOL_ICMP) {
646 icmpHandler.processPacketIn(pkt);
647 } else {
648 ipHandler.processPacketIn(pkt);
649 }
650 }
651 }
652 }
653
654 private class InternalLinkListener implements LinkListener {
655 @Override
656 public void event(LinkEvent event) {
Srikanth Vavilapalli64505482015-04-21 13:04:13 -0700657 if (event.type() == LinkEvent.Type.LINK_ADDED
658 || event.type() == LinkEvent.Type.LINK_REMOVED) {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700659 log.debug("Event {} received from Link Service", event.type());
sangho80f11cb2015-04-01 13:05:26 -0700660 scheduleEventHandlerIfNotScheduled(event);
661 }
662 }
663 }
664
665 private class InternalDeviceListener implements DeviceListener {
sangho80f11cb2015-04-01 13:05:26 -0700666 @Override
667 public void event(DeviceEvent event) {
sangho80f11cb2015-04-01 13:05:26 -0700668 switch (event.type()) {
669 case DEVICE_ADDED:
Saurav Dasf0f592d2016-11-18 15:21:57 -0800670 case PORT_UPDATED:
671 case PORT_ADDED:
sanghofb7c7292015-04-13 15:15:58 -0700672 case DEVICE_UPDATED:
673 case DEVICE_AVAILABILITY_CHANGED:
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700674 log.debug("Event {} received from Device Service", event.type());
sangho80f11cb2015-04-01 13:05:26 -0700675 scheduleEventHandlerIfNotScheduled(event);
676 break;
677 default:
678 }
679 }
680 }
681
Saurav Das2d94d312015-11-24 23:21:05 -0800682 @SuppressWarnings("rawtypes")
sangho80f11cb2015-04-01 13:05:26 -0700683 private void scheduleEventHandlerIfNotScheduled(Event event) {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700684 synchronized (threadSchedulerLock) {
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700685 eventQueue.add(event);
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700686 numOfEventsQueued++;
687
688 if ((numOfHandlerScheduled - numOfHandlerExecution) == 0) {
689 //No pending scheduled event handling threads. So start a new one.
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700690 eventHandlerFuture = executorService
691 .schedule(eventHandler, 100, TimeUnit.MILLISECONDS);
692 numOfHandlerScheduled++;
693 }
Jonathan Hart54541d12016-04-12 15:39:44 -0700694 log.trace("numOfEventsQueued {}, numOfEventHandlerScheduled {}",
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700695 numOfEventsQueued,
696 numOfHandlerScheduled);
sangho80f11cb2015-04-01 13:05:26 -0700697 }
sangho80f11cb2015-04-01 13:05:26 -0700698 }
699
700 private class InternalEventHandler implements Runnable {
Srikanth Vavilapalli37a461b2015-04-07 15:12:32 -0700701 @Override
sangho80f11cb2015-04-01 13:05:26 -0700702 public void run() {
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700703 try {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700704 while (true) {
Saurav Das2d94d312015-11-24 23:21:05 -0800705 @SuppressWarnings("rawtypes")
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700706 Event event = null;
707 synchronized (threadSchedulerLock) {
708 if (!eventQueue.isEmpty()) {
709 event = eventQueue.poll();
710 numOfEventsExecuted++;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700711 } else {
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700712 numOfHandlerExecution++;
713 log.debug("numOfHandlerExecution {} numOfEventsExecuted {}",
714 numOfHandlerExecution, numOfEventsExecuted);
715 break;
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700716 }
sanghofb7c7292015-04-13 15:15:58 -0700717 }
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700718 if (event.type() == LinkEvent.Type.LINK_ADDED) {
719 processLinkAdded((Link) event.subject());
720 } else if (event.type() == LinkEvent.Type.LINK_REMOVED) {
Pier Ventre6d593892016-09-13 21:33:40 -0700721 Link linkRemoved = (Link) event.subject();
722 if (linkRemoved.src().elementId() instanceof DeviceId &&
723 !deviceService.isAvailable(linkRemoved.src().deviceId())) {
724 continue;
725 }
726 if (linkRemoved.dst().elementId() instanceof DeviceId &&
727 !deviceService.isAvailable(linkRemoved.dst().deviceId())) {
728 continue;
729 }
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700730 processLinkRemoved((Link) event.subject());
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700731 } else if (event.type() == DeviceEvent.Type.DEVICE_ADDED ||
732 event.type() == DeviceEvent.Type.DEVICE_AVAILABILITY_CHANGED ||
733 event.type() == DeviceEvent.Type.DEVICE_UPDATED) {
Saurav Das62af8802015-12-04 10:52:59 -0800734 DeviceId deviceId = ((Device) event.subject()).id();
735 if (deviceService.isAvailable(deviceId)) {
Saurav Dasc28b3432015-10-30 17:45:38 -0700736 log.info("Processing device event {} for available device {}",
737 event.type(), ((Device) event.subject()).id());
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700738 processDeviceAdded((Device) event.subject());
Saurav Dasc3604f12016-03-23 11:22:49 -0700739 } else {
740 log.info("Processing device event {} for unavailable device {}",
741 event.type(), ((Device) event.subject()).id());
742 processDeviceRemoved((Device) event.subject());
743 }
Saurav Dasf0f592d2016-11-18 15:21:57 -0800744 } else if (event.type() == DeviceEvent.Type.PORT_ADDED) {
Saurav Dasd1872b02016-12-02 15:43:47 -0800745 // typically these calls come when device is added first time
746 // so port filtering rules are handled at the device_added event.
747 // port added calls represent all ports on the device,
748 // enabled or not.
Saurav Dasf0f592d2016-11-18 15:21:57 -0800749 log.debug("** PORT ADDED {}/{} -> {}",
Saurav Dasd1872b02016-12-02 15:43:47 -0800750 ((DeviceEvent) event).subject().id(),
751 ((DeviceEvent) event).port().number(),
752 event.type());
Saurav Dasf0f592d2016-11-18 15:21:57 -0800753 } else if (event.type() == DeviceEvent.Type.PORT_UPDATED) {
Saurav Dasd1872b02016-12-02 15:43:47 -0800754 // these calls happen for every subsequent event
755 // ports enabled, disabled, switch goes away, comes back
Saurav Dasf0f592d2016-11-18 15:21:57 -0800756 log.info("** PORT UPDATED {}/{} -> {}",
757 event.subject(),
758 ((DeviceEvent) event).port(),
759 event.type());
760 processPortUpdated(((Device) event.subject()),
761 ((DeviceEvent) event).port());
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700762 } else {
763 log.warn("Unhandled event type: {}", event.type());
764 }
sangho80f11cb2015-04-01 13:05:26 -0700765 }
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700766 } catch (Exception e) {
767 log.error("SegmentRouting event handler "
768 + "thread thrown an exception: {}", e);
sangho80f11cb2015-04-01 13:05:26 -0700769 }
sangho80f11cb2015-04-01 13:05:26 -0700770 }
771 }
772
sangho80f11cb2015-04-01 13:05:26 -0700773 private void processLinkAdded(Link link) {
Saurav Dasb149be12016-06-07 10:08:06 -0700774 log.info("** LINK ADDED {}", link.toString());
Charles Chan319d1a22015-11-03 10:42:14 -0800775 if (!deviceConfiguration.isConfigured(link.src().deviceId())) {
776 log.warn("Source device of this link is not configured.");
777 return;
778 }
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700779 //Irrespective whether the local is a MASTER or not for this device,
780 //create group handler instance and push default TTP flow rules.
781 //Because in a multi-instance setup, instances can initiate
782 //groups for any devices. Also the default TTP rules are needed
783 //to be pushed before inserting any IP table entries for any device
784 DefaultGroupHandler groupHandler = groupHandlerMap.get(link.src()
785 .deviceId());
786 if (groupHandler != null) {
Saurav Das4c35fc42015-11-20 15:27:53 -0800787 groupHandler.linkUp(link, mastershipService.isLocalMaster(
788 link.src().deviceId()));
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700789 } else {
790 Device device = deviceService.getDevice(link.src().deviceId());
791 if (device != null) {
792 log.warn("processLinkAdded: Link Added "
793 + "Notification without Device Added "
794 + "event, still handling it");
795 processDeviceAdded(device);
796 groupHandler = groupHandlerMap.get(link.src()
797 .deviceId());
Saurav Das4c35fc42015-11-20 15:27:53 -0800798 groupHandler.linkUp(link, mastershipService.isLocalMaster(device.id()));
sangho80f11cb2015-04-01 13:05:26 -0700799 }
800 }
Srikanth Vavilapalli7cd16712015-05-04 09:48:09 -0700801
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700802 log.trace("Starting optimized route population process");
803 defaultRoutingHandler.populateRoutingRulesForLinkStatusChange(null);
804 //log.trace("processLinkAdded: re-starting route population process");
805 //defaultRoutingHandler.startPopulationProcess();
Charles Chan72779502016-04-23 17:36:10 -0700806
807 mcastHandler.init();
sangho80f11cb2015-04-01 13:05:26 -0700808 }
809
810 private void processLinkRemoved(Link link) {
Saurav Dasb149be12016-06-07 10:08:06 -0700811 log.info("** LINK REMOVED {}", link.toString());
sangho2165d222015-05-01 09:38:25 -0700812 DefaultGroupHandler groupHandler = groupHandlerMap.get(link.src().deviceId());
813 if (groupHandler != null) {
Saurav Das62af8802015-12-04 10:52:59 -0800814 groupHandler.portDown(link.src().port(),
815 mastershipService.isLocalMaster(link.src().deviceId()));
sangho2165d222015-05-01 09:38:25 -0700816 }
Srikanth Vavilapalli64d96c12015-05-14 20:22:47 -0700817 log.trace("Starting optimized route population process");
818 defaultRoutingHandler.populateRoutingRulesForLinkStatusChange(link);
819 //log.trace("processLinkRemoved: re-starting route population process");
820 //defaultRoutingHandler.startPopulationProcess();
Charles Chan72779502016-04-23 17:36:10 -0700821
822 mcastHandler.processLinkDown(link);
sangho80f11cb2015-04-01 13:05:26 -0700823 }
824
825 private void processDeviceAdded(Device device) {
Saurav Dasb149be12016-06-07 10:08:06 -0700826 log.info("** DEVICE ADDED with ID {}", device.id());
Charles Chan319d1a22015-11-03 10:42:14 -0800827 if (deviceConfiguration == null || !deviceConfiguration.isConfigured(device.id())) {
Saurav Das8ec0ec42015-11-03 14:39:27 -0800828 log.warn("Device configuration uploading. Device {} will be "
829 + "processed after config completes.", device.id());
830 return;
831 }
Charles Chan72779502016-04-23 17:36:10 -0700832 processDeviceAddedInternal(device.id());
833 }
834
835 private void processDeviceAddedInternal(DeviceId deviceId) {
Saurav Dasc28b3432015-10-30 17:45:38 -0700836 // Irrespective of whether the local is a MASTER or not for this device,
837 // we need to create a SR-group-handler instance. This is because in a
838 // multi-instance setup, any instance can initiate forwarding/next-objectives
839 // for any switch (even if this instance is a SLAVE or not even connected
840 // to the switch). To handle this, a default-group-handler instance is necessary
841 // per switch.
Charles Chan72779502016-04-23 17:36:10 -0700842 log.debug("Current groupHandlerMap devs: {}", groupHandlerMap.keySet());
843 if (groupHandlerMap.get(deviceId) == null) {
Charles Chan319d1a22015-11-03 10:42:14 -0800844 DefaultGroupHandler groupHandler;
845 try {
846 groupHandler = DefaultGroupHandler.
Charles Chan72779502016-04-23 17:36:10 -0700847 createGroupHandler(deviceId,
848 appId,
849 deviceConfiguration,
850 linkService,
851 flowObjectiveService,
852 this);
Charles Chan319d1a22015-11-03 10:42:14 -0800853 } catch (DeviceConfigNotFoundException e) {
854 log.warn(e.getMessage() + " Aborting processDeviceAdded.");
855 return;
856 }
Charles Chan72779502016-04-23 17:36:10 -0700857 log.debug("updating groupHandlerMap with new config for device: {}",
858 deviceId);
859 groupHandlerMap.put(deviceId, groupHandler);
Saurav Das8ec0ec42015-11-03 14:39:27 -0800860 }
Saurav Dasb149be12016-06-07 10:08:06 -0700861 // Also, in some cases, drivers may need extra
862 // information to process rules (eg. Router IP/MAC); and so, we send
863 // port addressing rules to the driver as well irrespective of whether
864 // this instance is the master or not.
865 defaultRoutingHandler.populatePortAddressingRules(deviceId);
866
Charles Chan72779502016-04-23 17:36:10 -0700867 if (mastershipService.isLocalMaster(deviceId)) {
868 hostHandler.readInitialHosts(deviceId);
Charles Chan82f19972016-05-17 13:13:55 -0700869 xConnectHandler.init(deviceId);
Charles Chan41f5ec02016-06-13 18:54:31 -0700870 cordConfigHandler.init(deviceId);
Charles Chan72779502016-04-23 17:36:10 -0700871 DefaultGroupHandler groupHandler = groupHandlerMap.get(deviceId);
Charles Chan77277672015-10-20 16:24:19 -0700872 groupHandler.createGroupsFromSubnetConfig();
Charles Chan72779502016-04-23 17:36:10 -0700873 routingRulePopulator.populateSubnetBroadcastRule(deviceId);
Charles Chan77277672015-10-20 16:24:19 -0700874 }
Charles Chan82ab1932016-01-30 23:22:37 -0800875
Charles Chan82f19972016-05-17 13:13:55 -0700876 appCfgHandler.initVRouters(deviceId);
sangho80f11cb2015-04-01 13:05:26 -0700877 }
878
Saurav Dasc3604f12016-03-23 11:22:49 -0700879 private void processDeviceRemoved(Device device) {
880 nsNextObjStore.entrySet().stream()
881 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
882 .forEach(entry -> {
883 nsNextObjStore.remove(entry.getKey());
884 });
Saurav Dasc3604f12016-03-23 11:22:49 -0700885 subnetNextObjStore.entrySet().stream()
886 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
887 .forEach(entry -> {
888 subnetNextObjStore.remove(entry.getKey());
889 });
Saurav Dasc3604f12016-03-23 11:22:49 -0700890 portNextObjStore.entrySet().stream()
891 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
892 .forEach(entry -> {
893 portNextObjStore.remove(entry.getKey());
894 });
Saurav Dasc3604f12016-03-23 11:22:49 -0700895 subnetVidStore.entrySet().stream()
896 .filter(entry -> entry.getKey().deviceId().equals(device.id()))
897 .forEach(entry -> {
898 subnetVidStore.remove(entry.getKey());
899 });
Saurav Dasc3604f12016-03-23 11:22:49 -0700900 groupHandlerMap.remove(device.id());
Saurav Dasc3604f12016-03-23 11:22:49 -0700901 defaultRoutingHandler.purgeEcmpGraph(device.id());
Charles Chan72779502016-04-23 17:36:10 -0700902 mcastHandler.removeDevice(device.id());
Charles Chan82f19972016-05-17 13:13:55 -0700903 xConnectHandler.removeDevice(device.id());
Saurav Dasc3604f12016-03-23 11:22:49 -0700904 }
905
Saurav Dasf0f592d2016-11-18 15:21:57 -0800906 private void processPortUpdated(Device device, Port port) {
907 if (deviceConfiguration == null || !deviceConfiguration.isConfigured(device.id())) {
908 log.warn("Device configuration uploading. Not handling port event for"
909 + "dev: {} port: {}", device.id(), port.number());
910 return;
911 }
912 /* XXX create method for single port filtering rules which are needed
913 for both switch-to-switch ports and edge ports
914 if (defaultRoutingHandler != null) {
915 defaultRoutingHandler.populatePortAddressingRules(
916 ((Device) event.subject()).id());
917 }*/
918
919 // portUpdated calls are for ports that have gone down or up. For switch
920 // to switch ports, link-events should take care of any re-routing or
921 // group editing necessary for port up/down. Here we only process edge ports
922 // that are already configured.
923 Ip4Prefix configuredSubnet = deviceConfiguration.getPortSubnet(device.id(),
924 port.number());
925 if (configuredSubnet == null) {
926 log.debug("Not handling port updated event for unconfigured port "
927 + "dev/port: {}/{}", device.id(), port.number());
928 return;
929 }
930 processEdgePort(device, port, configuredSubnet);
931 }
932
933 private void processEdgePort(Device device, Port port, Ip4Prefix subnet) {
934 boolean portUp = port.isEnabled();
935 if (portUp) {
936 log.info("Device:EdgePort {}:{} is enabled in subnet: {}", device.id(),
937 port.number(), subnet);
938 } else {
939 log.info("Device:EdgePort {}:{} is disabled in subnet: {}", device.id(),
940 port.number(), subnet);
941 }
942
Srikanth Vavilapalli64505482015-04-21 13:04:13 -0700943 DefaultGroupHandler groupHandler = groupHandlerMap.get(device.id());
sangho80f11cb2015-04-01 13:05:26 -0700944 if (groupHandler != null) {
Saurav Dasf0f592d2016-11-18 15:21:57 -0800945 groupHandler.processEdgePort(port.number(), subnet, portUp,
Saurav Das62af8802015-12-04 10:52:59 -0800946 mastershipService.isLocalMaster(device.id()));
Saurav Dasf0f592d2016-11-18 15:21:57 -0800947 } else {
948 log.warn("Group handler not found for dev:{}. Not handling edge port"
949 + " {} event for port:{}", device.id(),
950 (portUp) ? "UP" : "DOWN", port.number());
sangho80f11cb2015-04-01 13:05:26 -0700951 }
952 }
sangho27462c62015-05-14 00:39:53 -0700953
Charles Chan72f556a2015-10-05 17:50:33 -0700954 private class InternalConfigListener implements NetworkConfigListener {
Charles Chan46fdfaf2016-11-09 20:51:44 -0800955 SegmentRoutingManager srManager;
Charles Chane7c61022015-10-07 14:21:45 -0700956
Charles Chanb7f75ac2016-01-11 18:28:54 -0800957 /**
958 * Constructs the internal network config listener.
959 *
Charles Chan46fdfaf2016-11-09 20:51:44 -0800960 * @param srManager segment routing manager
Charles Chanb7f75ac2016-01-11 18:28:54 -0800961 */
Charles Chan46fdfaf2016-11-09 20:51:44 -0800962 public InternalConfigListener(SegmentRoutingManager srManager) {
963 this.srManager = srManager;
Charles Chane7c61022015-10-07 14:21:45 -0700964 }
965
Charles Chanb7f75ac2016-01-11 18:28:54 -0800966 /**
967 * Reads network config and initializes related data structure accordingly.
968 */
Charles Chane7c61022015-10-07 14:21:45 -0700969 public void configureNetwork() {
Charles Chan46fdfaf2016-11-09 20:51:44 -0800970 deviceConfiguration = new DeviceConfiguration(srManager);
Charles Chane7c61022015-10-07 14:21:45 -0700971
Charles Chan46fdfaf2016-11-09 20:51:44 -0800972 arpHandler = new ArpHandler(srManager);
973 icmpHandler = new IcmpHandler(srManager);
974 ipHandler = new IpHandler(srManager);
975 routingRulePopulator = new RoutingRulePopulator(srManager);
976 defaultRoutingHandler = new DefaultRoutingHandler(srManager);
Charles Chane7c61022015-10-07 14:21:45 -0700977
978 tunnelHandler = new TunnelHandler(linkService, deviceConfiguration,
979 groupHandlerMap, tunnelStore);
980 policyHandler = new PolicyHandler(appId, deviceConfiguration,
981 flowObjectiveService,
982 tunnelHandler, policyStore);
983
Charles Chane7c61022015-10-07 14:21:45 -0700984 for (Device device : deviceService.getDevices()) {
Charles Chan72779502016-04-23 17:36:10 -0700985 processDeviceAddedInternal(device.id());
Charles Chane7c61022015-10-07 14:21:45 -0700986 }
987
988 defaultRoutingHandler.startPopulationProcess();
Charles Chan72779502016-04-23 17:36:10 -0700989 mcastHandler.init();
Charles Chane7c61022015-10-07 14:21:45 -0700990 }
991
Charles Chan72f556a2015-10-05 17:50:33 -0700992 @Override
993 public void event(NetworkConfigEvent event) {
Charles Chan82ab1932016-01-30 23:22:37 -0800994 // TODO move this part to NetworkConfigEventHandler
995 if (event.configClass().equals(SegmentRoutingDeviceConfig.class)) {
996 switch (event.type()) {
997 case CONFIG_ADDED:
998 log.info("Segment Routing Config added.");
999 configureNetwork();
1000 break;
1001 case CONFIG_UPDATED:
1002 log.info("Segment Routing Config updated.");
1003 // TODO support dynamic configuration
1004 break;
1005 default:
1006 break;
Charles Chan2b078ae2015-10-14 11:24:40 -07001007 }
Charles Chan82ab1932016-01-30 23:22:37 -08001008 } else if (event.configClass().equals(SegmentRoutingAppConfig.class)) {
Charles Chan82f19972016-05-17 13:13:55 -07001009 checkState(appCfgHandler != null, "NetworkConfigEventHandler is not initialized");
Charles Chan82ab1932016-01-30 23:22:37 -08001010 switch (event.type()) {
1011 case CONFIG_ADDED:
Charles Chan82f19972016-05-17 13:13:55 -07001012 appCfgHandler.processAppConfigAdded(event);
Charles Chan82ab1932016-01-30 23:22:37 -08001013 break;
1014 case CONFIG_UPDATED:
Charles Chan82f19972016-05-17 13:13:55 -07001015 appCfgHandler.processAppConfigUpdated(event);
Charles Chan82ab1932016-01-30 23:22:37 -08001016 break;
1017 case CONFIG_REMOVED:
Charles Chan82f19972016-05-17 13:13:55 -07001018 appCfgHandler.processAppConfigRemoved(event);
1019 break;
1020 default:
1021 break;
1022 }
1023 } else if (event.configClass().equals(XConnectConfig.class)) {
1024 checkState(xConnectHandler != null, "XConnectHandler is not initialized");
1025 switch (event.type()) {
1026 case CONFIG_ADDED:
1027 xConnectHandler.processXConnectConfigAdded(event);
1028 break;
1029 case CONFIG_UPDATED:
1030 xConnectHandler.processXConnectConfigUpdated(event);
1031 break;
1032 case CONFIG_REMOVED:
1033 xConnectHandler.processXConnectConfigRemoved(event);
Charles Chan82ab1932016-01-30 23:22:37 -08001034 break;
1035 default:
1036 break;
Charles Chan2b078ae2015-10-14 11:24:40 -07001037 }
Charles Chan72f556a2015-10-05 17:50:33 -07001038 }
1039 }
1040 }
Charles Chanf4586112015-11-09 16:37:23 -08001041
1042 private class InternalHostListener implements HostListener {
Charles Chanf4586112015-11-09 16:37:23 -08001043 @Override
1044 public void event(HostEvent event) {
1045 // Do not proceed without mastership
1046 DeviceId deviceId = event.subject().location().deviceId();
1047 if (!mastershipService.isLocalMaster(deviceId)) {
1048 return;
1049 }
1050
1051 switch (event.type()) {
1052 case HOST_ADDED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001053 hostHandler.processHostAddedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001054 break;
1055 case HOST_MOVED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001056 hostHandler.processHostMovedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001057 break;
1058 case HOST_REMOVED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001059 hostHandler.processHostRemoveEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001060 break;
1061 case HOST_UPDATED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001062 hostHandler.processHostUpdatedEvent(event);
Charles Chanf4586112015-11-09 16:37:23 -08001063 break;
1064 default:
1065 log.warn("Unsupported host event type: {}", event.type());
1066 break;
1067 }
1068 }
1069 }
1070
Charles Chanc91c8782016-03-30 17:54:24 -07001071 private class InternalMcastListener implements McastListener {
1072 @Override
1073 public void event(McastEvent event) {
1074 switch (event.type()) {
1075 case SOURCE_ADDED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001076 mcastHandler.processSourceAdded(event);
Charles Chanc91c8782016-03-30 17:54:24 -07001077 break;
1078 case SINK_ADDED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001079 mcastHandler.processSinkAdded(event);
Charles Chanc91c8782016-03-30 17:54:24 -07001080 break;
1081 case SINK_REMOVED:
Charles Chan1eaf4802016-04-18 13:44:03 -07001082 mcastHandler.processSinkRemoved(event);
Charles Chanc91c8782016-03-30 17:54:24 -07001083 break;
1084 case ROUTE_ADDED:
1085 case ROUTE_REMOVED:
1086 default:
1087 break;
1088 }
1089 }
1090 }
Charles Chan41f5ec02016-06-13 18:54:31 -07001091
1092 private class InternalCordConfigListener implements CordConfigListener {
1093 @Override
1094 public void event(CordConfigEvent event) {
1095 switch (event.type()) {
1096 case ACCESS_AGENT_ADDED:
1097 cordConfigHandler.processAccessAgentAddedEvent(event);
1098 break;
1099 case ACCESS_AGENT_UPDATED:
1100 cordConfigHandler.processAccessAgentUpdatedEvent(event);
1101 break;
1102 case ACCESS_AGENT_REMOVED:
1103 cordConfigHandler.processAccessAgentRemovedEvent(event);
1104 break;
1105 case ACCESS_DEVICE_ADDED:
1106 case ACCESS_DEVICE_UPDATED:
1107 case ACCESS_DEVICE_REMOVED:
1108 default:
1109 break;
1110 }
1111 }
1112 }
sangho80f11cb2015-04-01 13:05:26 -07001113}