8819be39885d950e9f6aafc7ed4ad737247a2037
[controller.git] / opendaylight / forwarding / staticrouting / src / main / java / org / opendaylight / controller / forwarding / staticrouting / internal / StaticRoutingImplementation.java
1
2 /*
3  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
4  *
5  * This program and the accompanying materials are made available under the
6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
7  * and is available at http://www.eclipse.org/legal/epl-v10.html
8  */
9
10 package org.opendaylight.controller.forwarding.staticrouting.internal;
11
12 import java.io.FileNotFoundException;
13 import java.io.IOException;
14 import java.io.ObjectInputStream;
15 import java.net.Inet4Address;
16 import java.net.InetAddress;
17 import java.nio.ByteBuffer;
18 import java.util.Collections;
19 import java.util.Date;
20 import java.util.Dictionary;
21 import java.util.EnumSet;
22 import java.util.HashSet;
23 import java.util.Map;
24 import java.util.Set;
25 import java.util.Timer;
26 import java.util.TimerTask;
27 import java.util.concurrent.ConcurrentHashMap;
28 import java.util.concurrent.ConcurrentMap;
29 import java.util.concurrent.Future;
30 import java.util.regex.Matcher;
31 import java.util.regex.Pattern;
32
33 import org.apache.felix.dm.Component;
34 import org.opendaylight.controller.clustering.services.CacheConfigException;
35 import org.opendaylight.controller.clustering.services.CacheExistException;
36 import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
37 import org.opendaylight.controller.clustering.services.IClusterContainerServices;
38 import org.opendaylight.controller.clustering.services.IClusterServices;
39 import org.opendaylight.controller.configuration.IConfigurationContainerAware;
40 import org.opendaylight.controller.forwarding.staticrouting.IForwardingStaticRouting;
41 import org.opendaylight.controller.forwarding.staticrouting.IStaticRoutingAware;
42 import org.opendaylight.controller.forwarding.staticrouting.StaticRoute;
43 import org.opendaylight.controller.forwarding.staticrouting.StaticRouteConfig;
44 import org.opendaylight.controller.hosttracker.IfIptoHost;
45 import org.opendaylight.controller.hosttracker.IfNewHostNotify;
46 import org.opendaylight.controller.hosttracker.hostAware.HostNodeConnector;
47 import org.opendaylight.controller.sal.utils.StatusCode;
48 import org.opendaylight.controller.sal.utils.GlobalConstants;
49 import org.opendaylight.controller.sal.utils.IObjectReader;
50 import org.opendaylight.controller.sal.utils.ObjectReader;
51 import org.opendaylight.controller.sal.utils.ObjectWriter;
52 import org.opendaylight.controller.sal.utils.Status;
53 import org.slf4j.Logger;
54 import org.slf4j.LoggerFactory;
55
56 /**
57  * Static Routing feature provides the bridge between SDN and Non-SDN networks.
58  *
59  *
60  *
61  */
62 public class StaticRoutingImplementation implements IfNewHostNotify,
63         IForwardingStaticRouting, IObjectReader, IConfigurationContainerAware,
64         ICacheUpdateAware<Long, String> {
65     private static Logger log = LoggerFactory
66             .getLogger(StaticRoutingImplementation.class);
67     private static String ROOT = GlobalConstants.STARTUPHOME.toString();
68     private static final String SAVE = "Save";
69     ConcurrentMap<String, StaticRoute> staticRoutes;
70     ConcurrentMap<String, StaticRouteConfig> staticRouteConfigs;
71     private IfIptoHost hostTracker;
72     private Timer gatewayProbeTimer;
73     private String staticRoutesFileName = null;
74     private Map<Long, String> configSaveEvent;
75     private IClusterContainerServices clusterContainerService = null;
76     private Set<IStaticRoutingAware> staticRoutingAware = Collections
77             .synchronizedSet(new HashSet<IStaticRoutingAware>());
78
79     void setStaticRoutingAware(IStaticRoutingAware s) {
80         if (this.staticRoutingAware != null) {
81             this.staticRoutingAware.add(s);
82         }
83     }
84
85     void unsetStaticRoutingAware(IStaticRoutingAware s) {
86         if (this.staticRoutingAware != null) {
87             this.staticRoutingAware.remove(s);
88         }
89     }
90
91     public void setHostTracker(IfIptoHost hostTracker) {
92         log.debug("Setting HostTracker");
93         this.hostTracker = hostTracker;
94     }
95
96     public void unsetHostTracker(IfIptoHost hostTracker) {
97         if (this.hostTracker == hostTracker) {
98             this.hostTracker = null;
99         }
100     }
101
102     public ConcurrentMap<String, StaticRouteConfig> getStaticRouteConfigs() {
103         return staticRouteConfigs;
104     }
105
106     public void setStaticRouteConfigs(
107             ConcurrentMap<String, StaticRouteConfig> staticRouteConfigs) {
108         this.staticRouteConfigs = staticRouteConfigs;
109     }
110
111     @Override
112     public Object readObject(ObjectInputStream ois)
113             throws FileNotFoundException, IOException, ClassNotFoundException {
114         // Perform the class deserialization locally, from inside the package
115         // where the class is defined
116         return ois.readObject();
117     }
118
119     @SuppressWarnings("unchecked")
120     private void loadConfiguration() {
121         ObjectReader objReader = new ObjectReader();
122         ConcurrentMap<String, StaticRouteConfig> confList = (ConcurrentMap<String, StaticRouteConfig>) objReader
123                 .read(this, staticRoutesFileName);
124
125         if (confList == null) {
126             return;
127         }
128
129         for (StaticRouteConfig conf : confList.values()) {
130             addStaticRoute(conf);
131         }
132     }
133
134
135     private Status saveConfig() {
136         // Publish the save config event to the cluster nodes
137         configSaveEvent.put(new Date().getTime(), SAVE);
138         return saveConfigInternal();
139     }
140
141     public Status saveConfigInternal() {
142         Status status;
143         ObjectWriter objWriter = new ObjectWriter();
144
145         status = objWriter.write(
146                 new ConcurrentHashMap<String, StaticRouteConfig>(
147                         staticRouteConfigs), staticRoutesFileName);
148
149         if (status.isSuccess()) {
150             return status;
151         } else {
152             return new Status(StatusCode.INTERNALERROR, "Save failed");
153         }
154     }
155
156     @SuppressWarnings("deprecation")
157         private void allocateCaches() {
158         if (this.clusterContainerService == null) {
159             log
160                     .info("un-initialized clusterContainerService, can't create cache");
161             return;
162         }
163
164         try {
165             clusterContainerService.createCache(
166                     "forwarding.staticrouting.routes", EnumSet
167                             .of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
168             clusterContainerService.createCache(
169                     "forwarding.staticrouting.configs", EnumSet
170                             .of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
171             clusterContainerService.createCache(
172                     "forwarding.staticrouting.configSaveEvent", EnumSet
173                             .of(IClusterServices.cacheMode.NON_TRANSACTIONAL));
174
175         } catch (CacheExistException cee) {
176             log
177                     .error("\nCache already exists - destroy and recreate if needed");
178         } catch (CacheConfigException cce) {
179             log.error("\nCache configuration invalid - check cache mode");
180         }
181     }
182
183     @SuppressWarnings({ "unchecked", "deprecation" })
184     private void retrieveCaches() {
185         if (this.clusterContainerService == null) {
186             log
187                     .info("un-initialized clusterContainerService, can't retrieve cache");
188             return;
189         }
190
191         staticRoutes = (ConcurrentMap<String, StaticRoute>) clusterContainerService
192                 .getCache("forwarding.staticrouting.routes");
193         if (staticRoutes == null) {
194             log.error("\nFailed to get rulesDB handle");
195         }
196
197         staticRouteConfigs = (ConcurrentMap<String, StaticRouteConfig>) clusterContainerService
198                 .getCache("forwarding.staticrouting.configs");
199         if (staticRouteConfigs == null) {
200             log.error("\nFailed to get rulesDB handle");
201         }
202         configSaveEvent = (ConcurrentMap<Long, String>) clusterContainerService
203                 .getCache("forwarding.staticrouting.configSaveEvent");
204         if (configSaveEvent == null) {
205             log.error("\nFailed to get cache for configSaveEvent");
206         }
207     }
208
209     @SuppressWarnings("deprecation")
210         private void destroyCaches() {
211         if (this.clusterContainerService == null) {
212             log
213                     .info("un-initialized clusterContainerService, can't destroy cache");
214             return;
215         }
216
217         clusterContainerService.destroyCache("forwarding.staticrouting.routes");
218         clusterContainerService
219                 .destroyCache("forwarding.staticrouting.configs");
220         clusterContainerService
221                 .destroyCache("forwarding.staticrouting.configSaveEvent");
222
223     }
224
225     @Override
226     public void entryCreated(Long key, String cacheName, boolean local) {
227     }
228
229     @Override
230     public void entryUpdated(Long key, String new_value, String cacheName,
231             boolean originLocal) {
232         saveConfigInternal();
233     }
234
235     @Override
236     public void entryDeleted(Long key, String cacheName, boolean originLocal) {
237     }
238
239     private void notifyStaticRouteUpdate(StaticRoute s, boolean update) {
240         if (this.staticRoutingAware != null) {
241             log.info("Invoking StaticRoutingAware listeners");
242             synchronized (this.staticRoutingAware) {
243                 for (IStaticRoutingAware ra : this.staticRoutingAware) {
244                     try {
245                         ra.staticRouteUpdate(s, update);
246                     } catch (Exception e) {
247                         log.error("",e);
248                     }
249                 }
250             }
251         }
252     }
253
254     private class NotifyStaticRouteThread extends Thread {
255         private StaticRoute staticRoute;
256         private boolean added;
257
258         public NotifyStaticRouteThread(StaticRoute s, boolean update) {
259             this.staticRoute = s;
260             this.added = update;
261         }
262
263         public void run() {
264             if (!added
265                     || (staticRoute.getType() == StaticRoute.NextHopType.SWITCHPORT)) {
266                 notifyStaticRouteUpdate(staticRoute, added);
267             } else {
268                 HostNodeConnector host = hostTracker.hostQuery(staticRoute
269                         .getNextHopAddress());
270                 if (host == null) {
271                     Future<HostNodeConnector> future = hostTracker
272                             .discoverHost(staticRoute.getNextHopAddress());
273                     if (future != null) {
274                         try {
275                             host = future.get();
276                         } catch (Exception e) {
277                             log.error("",e);
278                         }
279                     }
280                 }
281                 if (host != null) {
282                     staticRoute.setHost(host);
283                     notifyStaticRouteUpdate(staticRoute, added);
284                 }
285             }
286         }
287     }
288
289     private void checkAndUpdateListeners(StaticRoute staticRoute, boolean added) {
290         new NotifyStaticRouteThread(staticRoute, added).start();
291     }
292
293     private void notifyHostUpdate(HostNodeConnector host, boolean added) {
294         if (host == null)
295             return;
296         for (StaticRoute s : staticRoutes.values()) {
297             if (s.getType() == StaticRoute.NextHopType.SWITCHPORT)
298                 continue;
299             if (s.getNextHopAddress().equals(host.getNetworkAddress())) {
300                 if (added) {
301                     s.setHost(host);
302                 } else {
303                     s.setHost(null);
304                 }
305                 notifyStaticRouteUpdate(s, added);
306             }
307         }
308     }
309
310     @Override
311     public void notifyHTClient(HostNodeConnector host) {
312         notifyHostUpdate(host, true);
313     }
314
315     @Override
316     public void notifyHTClientHostRemoved(HostNodeConnector host) {
317         notifyHostUpdate(host, false);
318     }
319
320     public boolean isIPv4AddressValid(String cidr) {
321         if (cidr == null)
322             return false;
323
324         String values[] = cidr.split("/");
325         Pattern ipv4Pattern = Pattern
326                 .compile("(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])");
327         Matcher mm = ipv4Pattern.matcher(values[0]);
328         if (!mm.matches()) {
329             log.debug("IPv4 source address {} is not valid", cidr);
330             return false;
331         }
332         if (values.length >= 2) {
333             int prefix = Integer.valueOf(values[1]);
334             if ((prefix < 0) || (prefix > 32)) {
335                 log.debug("prefix {} is not valid", prefix);
336                 return false;
337             }
338         }
339         return true;
340     }
341
342     public static short getUnsignedByte(ByteBuffer bb, int position) {
343         return ((short) (bb.get(position) & (short) 0xff));
344     }
345
346     public static int compareByteBuffers(ByteBuffer buf1, ByteBuffer buf2) {
347         for (int i = 0; i < buf1.array().length; i++) {
348             if (getUnsignedByte(buf1, i) > getUnsignedByte(buf2, i)) {
349                 return 1;
350             } else if (getUnsignedByte(buf1, i) < getUnsignedByte(buf2, i)) {
351                 return -1;
352             }
353         }
354
355         return 0;
356     }
357
358     public StaticRoute getBestMatchStaticRoute(InetAddress ipAddress) {
359         ByteBuffer bblongestPrefix = null;
360         try {
361             bblongestPrefix = ByteBuffer.wrap(InetAddress.getByName("0.0.0.0")
362                     .getAddress());
363         } catch (Exception e) {
364             return null;
365         }
366
367         if (staticRoutes == null) {
368             return null;
369         }
370
371         StaticRoute longestPrefixRoute = null;
372         for (StaticRoute s : staticRoutes.values()) {
373             InetAddress prefix = s.longestPrefixMatch(ipAddress);
374             if ((prefix != null) && (prefix instanceof Inet4Address)) {
375                 ByteBuffer bbtmp = ByteBuffer.wrap(prefix.getAddress());
376                 if (compareByteBuffers(bbtmp, bblongestPrefix) > 0) {
377                     bblongestPrefix = bbtmp;
378                     longestPrefixRoute = s;
379                 }
380             }
381         }
382         return longestPrefixRoute;
383     }
384
385     public Status addStaticRoute(StaticRouteConfig config) {
386         Status status;
387
388         status = config.isValid();
389         if (!status.isSuccess()) {
390             return status;
391         }
392         if (staticRouteConfigs.get(config.getName()) != null) {
393                 return new Status(StatusCode.CONFLICT,
394                                 "A valid Static Route configuration with this name " +
395                                                 "already exists. Please use a different name");
396         }
397         for (StaticRouteConfig s : staticRouteConfigs.values()) {
398             if (s.equals(config)) {
399                 return new Status(StatusCode.CONFLICT,
400                                 "This conflicts with an existing Static Route " +
401                                         "Configuration. Please check the configuration " +
402                                                 "and try again");
403             }
404         }
405
406         staticRouteConfigs.put(config.getName(), config);
407         StaticRoute sRoute = new StaticRoute(config);
408         staticRoutes.put(config.getName(), sRoute);
409         checkAndUpdateListeners(sRoute, true);
410         return status;
411     }
412
413     public Status removeStaticRoute(String name) {
414         staticRouteConfigs.remove(name);
415         StaticRoute sRoute = staticRoutes.remove(name);
416         if (sRoute != null) {
417             checkAndUpdateListeners(sRoute, false);
418             return new Status(StatusCode.SUCCESS, null);
419         }
420         return new Status(StatusCode.NOTFOUND,
421                         "Static Route with name " + name + " is not found");
422     }
423
424     void setClusterContainerService(IClusterContainerServices s) {
425         log.debug("Cluster Service set");
426         this.clusterContainerService = s;
427     }
428
429     void unsetClusterContainerService(IClusterContainerServices s) {
430         if (this.clusterContainerService == s) {
431             log.debug("Cluster Service removed!");
432             this.clusterContainerService = null;
433         }
434     }
435
436     /**
437      * Function called by the dependency manager when all the required
438      * dependencies are satisfied
439      *
440      */
441     void init(Component c) {
442         String containerName = null;
443         Dictionary props = c.getServiceProperties();
444         if (props != null) {
445             containerName = (String) props.get("containerName");
446         } else {
447             // In the Global instance case the containerName is empty
448             containerName = "";
449         }
450
451         staticRoutesFileName = ROOT + "staticRouting_" + containerName
452                 + ".conf";
453
454         log.debug("forwarding.staticrouting starting on container {}",
455                   containerName);
456         //staticRoutes = new ConcurrentHashMap<String, StaticRoute>();
457         allocateCaches();
458         retrieveCaches();
459
460         if (staticRouteConfigs.isEmpty())
461             loadConfiguration();
462
463         /*
464          *  Slow probe to identify any gateway that might have silently appeared
465          *  after the Static Routing Configuration.
466          */
467         gatewayProbeTimer = new Timer();
468         gatewayProbeTimer.schedule(new TimerTask() {
469             @Override
470             public void run() {
471                 for (StaticRoute s : staticRoutes.values()) {
472                     if ((s.getType() == StaticRoute.NextHopType.IPADDRESS)
473                             && s.getHost() == null) {
474                         checkAndUpdateListeners(s, true);
475                     }
476                 }
477             }
478         }, 60 * 1000, 60 * 1000);
479     }
480
481     /**
482      * Function called by the dependency manager when at least one
483      * dependency become unsatisfied or when the component is shutting
484      * down because for example bundle is being stopped.
485      *
486      */
487     void destroy() {
488         log.debug("Destroy all the Static Routing Rules given we are "
489                 + "shutting down");
490
491         destroyCaches();
492         gatewayProbeTimer.cancel();
493
494         // Clear the listener so to be ready in next life
495         this.staticRoutingAware.clear();
496     }
497
498     /**
499      * Function called by dependency manager after "init ()" is called
500      * and after the services provided by the class are registered in
501      * the service registry
502      *
503      */
504     void start() {
505     }
506
507     /**
508      * Function called by the dependency manager before the services
509      * exported by the component are unregistered, this will be
510      * followed by a "destroy ()" calls
511      *
512      */
513     void stop() {
514     }
515
516     @Override
517     public Status saveConfiguration() {
518         return this.saveConfig();
519     }
520 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.