Do not use protobuf serialization for FindPrimary and it's responses
[controller.git] / opendaylight / sal / implementation / src / main / java / org / opendaylight / controller / sal / implementation / internal / FlowProgrammerService.java
1 /*
2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8
9 package org.opendaylight.controller.sal.implementation.internal;
10
11 import java.util.Map;
12 import java.util.concurrent.ConcurrentHashMap;
13 import java.util.concurrent.atomic.AtomicLong;
14 import java.net.InetAddress;
15 import java.net.UnknownHostException;
16 import java.util.ArrayList;
17 import java.util.HashSet;
18 import java.util.List;
19 import java.util.Set;
20
21 import org.eclipse.osgi.framework.console.CommandInterpreter;
22 import org.eclipse.osgi.framework.console.CommandProvider;
23 import org.opendaylight.controller.sal.action.Action;
24 import org.opendaylight.controller.sal.action.Controller;
25 import org.opendaylight.controller.sal.action.Flood;
26 import org.opendaylight.controller.sal.action.Output;
27 import org.opendaylight.controller.sal.action.PopVlan;
28 import org.opendaylight.controller.sal.action.SetNwDst;
29 import org.opendaylight.controller.sal.core.ConstructionException;
30 import org.opendaylight.controller.sal.core.Node;
31 import org.opendaylight.controller.sal.core.Node.NodeIDType;
32 import org.opendaylight.controller.sal.core.NodeConnector;
33 import org.opendaylight.controller.sal.flowprogrammer.Flow;
34 import org.opendaylight.controller.sal.flowprogrammer.IFlowProgrammerListener;
35 import org.opendaylight.controller.sal.flowprogrammer.IFlowProgrammerService;
36 import org.opendaylight.controller.sal.flowprogrammer.IPluginInFlowProgrammerService;
37 import org.opendaylight.controller.sal.flowprogrammer.IPluginOutFlowProgrammerService;
38 import org.opendaylight.controller.sal.match.Match;
39 import org.opendaylight.controller.sal.match.MatchType;
40 import org.opendaylight.controller.sal.utils.EtherTypes;
41 import org.opendaylight.controller.sal.utils.GlobalConstants;
42 import org.opendaylight.controller.sal.utils.IPProtocols;
43 import org.opendaylight.controller.sal.utils.NodeConnectorCreator;
44 import org.opendaylight.controller.sal.utils.Status;
45 import org.opendaylight.controller.sal.utils.StatusCode;
46 import org.osgi.framework.BundleContext;
47 import org.osgi.framework.FrameworkUtil;
48 import org.slf4j.Logger;
49 import org.slf4j.LoggerFactory;
50
51 /**
52  * The SAL Flow Programmer Service. It dispatches the flow programming requests
53  * to the proper SDN protocol plugin and it notifies about asynchronous messages
54  * received from the network node related to flow programming.
55  */
56 public class FlowProgrammerService implements IFlowProgrammerService,
57         IPluginOutFlowProgrammerService, CommandProvider {
58
59     protected static final Logger logger = LoggerFactory
60             .getLogger(FlowProgrammerService.class);
61     private ConcurrentHashMap<String, IPluginInFlowProgrammerService> pluginFlowProgrammer;
62     private Set<IFlowProgrammerListener> listener;
63     private AtomicLong seq;
64
65     public FlowProgrammerService() {
66         pluginFlowProgrammer = new ConcurrentHashMap<String, IPluginInFlowProgrammerService>();
67         listener = new HashSet<IFlowProgrammerListener>();
68         seq = new AtomicLong();
69         /*
70          * This Request ID generator starts with 1. Each aysnc message is
71          * associated with an unique Request ID (!= 0).
72          */
73         seq.lazySet(1);
74     }
75
76     /**
77      * Function called by the dependency manager when all the required
78      * dependencies are satisfied
79      *
80      */
81     void init() {
82         logger.debug("INIT called!");
83     }
84
85     /**
86      * Function called by the dependency manager when at least one dependency
87      * become unsatisfied or when the component is shutting down because for
88      * example bundle is being stopped.
89      *
90      */
91     void destroy() {
92         // Clear previous registration to avoid they are left hanging
93         this.pluginFlowProgrammer.clear();
94         logger.debug("DESTROY called!");
95     }
96
97     /**
98      * Function called by dependency manager after "init ()" is called and after
99      * the services provided by the class are registered in the service registry
100      *
101      */
102     void start() {
103         logger.debug("START called!");
104         // OSGI console
105         registerWithOSGIConsole();
106     }
107
108     /**
109      * Function called by the dependency manager before the services exported by
110      * the component are unregistered, this will be followed by a "destroy ()"
111      * calls
112      *
113      */
114     void stop() {
115         logger.debug("STOP called!");
116     }
117
118     // Set the reference to the plugin flow programmer
119     public void setService(Map<String, Object> props, IPluginInFlowProgrammerService s) {
120         if (this.pluginFlowProgrammer == null) {
121             logger.error("pluginFlowProgrammer store null");
122             return;
123         }
124
125         if (logger.isTraceEnabled()) {
126             logger.trace("Got a service set request {}", s);
127             for (Map.Entry<String, Object> entry : props.entrySet()) {
128                 logger.trace("Prop key:({}) value:({})", entry.getKey(), entry.getValue());
129             }
130         }
131
132         String type = null;
133         Object value = props.get(GlobalConstants.PROTOCOLPLUGINTYPE.toString());
134         if (value instanceof String) {
135             type = (String) value;
136         }
137         if (type == null) {
138             logger.error("Received a pluginFlowProgrammer without any "
139                     + "protocolPluginType provided");
140         } else {
141             this.pluginFlowProgrammer.put(type, s);
142             logger.debug("Stored the pluginFlowProgrammer for type: {}", type);
143         }
144     }
145
146     public void unsetService(Map<String, Object> props, IPluginInFlowProgrammerService s) {
147         if (this.pluginFlowProgrammer == null) {
148             logger.error("pluginFlowProgrammer store null");
149             return;
150         }
151
152         logger.debug("Received unsetpluginFlowProgrammer request");
153         if (logger.isTraceEnabled()) {
154             logger.trace("Got a service set request {}", s);
155             for (Map.Entry<String, Object> entry : props.entrySet()) {
156                 logger.trace("Prop key:({}) value:({})", entry.getKey(), entry.getValue());
157             }
158         }
159
160         String type = null;
161         Object value = props.get(GlobalConstants.PROTOCOLPLUGINTYPE.toString());
162         if (value instanceof String) {
163             type = (String) value;
164         }
165         if (type == null) {
166             logger.error("Received a pluginFlowProgrammer without any "
167                     + "protocolPluginType provided");
168         } else if (this.pluginFlowProgrammer.get(type).equals(s)) {
169             this.pluginFlowProgrammer.remove(type);
170             logger.debug("Removed the pluginFlowProgrammer for type: {}", type);
171         }
172     }
173
174     public void setListener(IFlowProgrammerListener s) {
175         this.listener.add(s);
176     }
177
178     public void unsetListener(IFlowProgrammerListener s) {
179         this.listener.remove(s);
180     }
181
182     @Override
183     public Status addFlow(Node node, Flow flow) {
184         if (pluginFlowProgrammer != null) {
185             if (this.pluginFlowProgrammer.get(node.getType()) != null) {
186                 return this.pluginFlowProgrammer.get(node.getType()).addFlow(
187                         node, flow);
188             }
189         }
190         return new Status(StatusCode.NOSERVICE, "Plugin unuvailable");
191     }
192
193     @Override
194     public Status removeFlow(Node node, Flow flow) {
195         if (pluginFlowProgrammer != null) {
196             if (this.pluginFlowProgrammer.get(node.getType()) != null) {
197                 return this.pluginFlowProgrammer.get(node.getType())
198                         .removeFlow(node, flow);
199             }
200         }
201         return new Status(StatusCode.NOSERVICE, "Plugin unuvailable");
202     }
203
204     @Override
205     public Status removeAllFlows(Node node) {
206         if (pluginFlowProgrammer != null) {
207             if (this.pluginFlowProgrammer.get(node.getType()) != null) {
208                 return this.pluginFlowProgrammer.get(node.getType())
209                         .removeAllFlows(node);
210             }
211         }
212         return new Status(StatusCode.NOSERVICE, "Plugin unuvailable");
213     }
214
215     @Override
216     public Status modifyFlow(Node node, Flow oldFlow, Flow newFlow) {
217         if (pluginFlowProgrammer != null) {
218             if (this.pluginFlowProgrammer.get(node.getType()) != null) {
219                 return this.pluginFlowProgrammer.get(node.getType())
220                         .modifyFlow(node, oldFlow, newFlow);
221             }
222         }
223         return new Status(StatusCode.NOSERVICE, "Plugin unuvailable");
224     }
225
226     @Override
227     public Status addFlowAsync(Node node, Flow flow) {
228         if (pluginFlowProgrammer != null) {
229             if (this.pluginFlowProgrammer.get(node.getType()) != null) {
230                 return this.pluginFlowProgrammer.get(node.getType()).addFlowAsync(
231                         node, flow, getNextRid());
232             }
233         }
234         return new Status(StatusCode.NOSERVICE, "Plugin unuvailable");
235     }
236
237     @Override
238     public Status removeFlowAsync(Node node, Flow flow) {
239         if (pluginFlowProgrammer != null) {
240             if (this.pluginFlowProgrammer.get(node.getType()) != null) {
241                 return this.pluginFlowProgrammer.get(node.getType())
242                         .removeFlowAsync(node, flow, getNextRid());
243             }
244         }
245         return new Status(StatusCode.NOSERVICE, "Plugin unuvailable");
246     }
247
248     @Override
249     public Status modifyFlowAsync(Node node, Flow oldFlow, Flow newFlow) {
250         if (pluginFlowProgrammer != null) {
251             if (this.pluginFlowProgrammer.get(node.getType()) != null) {
252                 return this.pluginFlowProgrammer.get(node.getType())
253                         .modifyFlowAsync(node, oldFlow, newFlow, getNextRid());
254             }
255         }
256         return new Status(StatusCode.NOSERVICE, "Plugin unuvailable");
257     }
258
259     @Override
260     public void flowRemoved(Node node, Flow flow) {
261         for (IFlowProgrammerListener l : listener) {
262             l.flowRemoved(node, flow);
263         }
264     }
265
266     @Override
267     public void flowErrorReported(Node node, long rid, Object err) {
268         logger.error("Got error {} for message rid {} from node {}",
269                 new Object[] { err, rid, node });
270
271         for (IFlowProgrammerListener l : listener) {
272             l.flowErrorReported(node, rid, err);
273         }
274     }
275
276     // ---------------- OSGI TEST CODE ------------------------------//
277
278     private void registerWithOSGIConsole() {
279         BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass())
280                 .getBundleContext();
281         bundleContext.registerService(CommandProvider.class.getName(), this,
282                 null);
283     }
284
285     @Override
286     public String getHelp() {
287         StringBuffer help = new StringBuffer();
288         help.append("---SAL Flow Programmer testing commands---\n");
289         help.append("\t addflow <sid> - Add a sample flow to the openflow switch <sid>\n");
290         help.append("\t removeflow <sid> - Remove the sample flow from the openflow switch <sid>\n");
291         return help.toString();
292     }
293
294     public void _addflow(CommandInterpreter ci) throws UnknownHostException {
295         Node node = null;
296         String nodeId = ci.nextArgument();
297         if (nodeId == null) {
298             ci.print("Node id not specified");
299             return;
300         }
301         try {
302             node = new Node(NodeIDType.OPENFLOW, Long.valueOf(nodeId));
303         } catch (NumberFormatException e) {
304             logger.error("",e);
305         } catch (ConstructionException e) {
306             logger.error("",e);
307         }
308         ci.println(this.addFlow(node, getSampleFlow(node)));
309     }
310
311     public void _modifyflow(CommandInterpreter ci) throws UnknownHostException {
312         Node node = null;
313         String nodeId = ci.nextArgument();
314         if (nodeId == null) {
315             ci.print("Node id not specified");
316             return;
317         }
318         try {
319             node = new Node(NodeIDType.OPENFLOW, Long.valueOf(nodeId));
320         } catch (NumberFormatException e) {
321             logger.error("",e);
322         } catch (ConstructionException e) {
323             logger.error("",e);
324         }
325         Flow flowA = getSampleFlow(node);
326         Flow flowB = getSampleFlow(node);
327         Match matchB = flowB.getMatch();
328         matchB.setField(MatchType.NW_DST,
329                 InetAddress.getByName("190.190.190.190"));
330         flowB.setMatch(matchB);
331         ci.println(this.modifyFlow(node, flowA, flowB));
332     }
333
334     public void _removeflow(CommandInterpreter ci) throws UnknownHostException {
335         Node node = null;
336         String nodeId = ci.nextArgument();
337         if (nodeId == null) {
338             ci.print("Node id not specified");
339             return;
340         }
341         try {
342             node = new Node(NodeIDType.OPENFLOW, Long.valueOf(nodeId));
343         } catch (NumberFormatException e) {
344             logger.error("",e);
345         } catch (ConstructionException e) {
346             logger.error("",e);
347         }
348         ci.println(this.removeFlow(node, getSampleFlow(node)));
349     }
350
351     public void _addflowv6(CommandInterpreter ci) throws UnknownHostException {
352         Node node = null;
353         String nodeId = ci.nextArgument();
354         if (nodeId == null) {
355             ci.print("Node id not specified");
356             return;
357         }
358         try {
359             node = new Node(NodeIDType.OPENFLOW, Long.valueOf(nodeId));
360         } catch (NumberFormatException e) {
361             logger.error("",e);
362         } catch (ConstructionException e) {
363             logger.error("",e);
364         }
365         ci.println(this.addFlow(node, getSampleFlowV6(node)));
366     }
367
368     public void _removeflowv6(CommandInterpreter ci)
369             throws UnknownHostException {
370         Node node = null;
371         String nodeId = ci.nextArgument();
372         if (nodeId == null) {
373             ci.print("Node id not specified");
374             return;
375         }
376         try {
377             node = new Node(NodeIDType.OPENFLOW, Long.valueOf(nodeId));
378         } catch (NumberFormatException e) {
379             logger.error("",e);
380         } catch (ConstructionException e) {
381             logger.error("",e);
382         }
383         ci.println(this.removeFlow(node, getSampleFlowV6(node)));
384     }
385
386     private Flow getSampleFlow(Node node) throws UnknownHostException {
387         NodeConnector port = NodeConnectorCreator.createOFNodeConnector(
388                 (short) 24, node);
389         NodeConnector oport = NodeConnectorCreator.createOFNodeConnector(
390                 (short) 30, node);
391         byte srcMac[] = { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78,
392                 (byte) 0x9a, (byte) 0xbc };
393         byte dstMac[] = { (byte) 0x1a, (byte) 0x2b, (byte) 0x3c, (byte) 0x4d,
394                 (byte) 0x5e, (byte) 0x6f };
395         InetAddress srcIP = InetAddress.getByName("172.28.30.50");
396         InetAddress dstIP = InetAddress.getByName("171.71.9.52");
397         InetAddress newIP = InetAddress.getByName("200.200.100.1");
398         InetAddress ipMask = InetAddress.getByName("255.255.255.0");
399         InetAddress ipMask2 = InetAddress.getByName("255.240.0.0");
400         short ethertype = EtherTypes.IPv4.shortValue();
401         short vlan = (short) 27;
402         byte vlanPr = 3;
403         Byte tos = 4;
404         byte proto = IPProtocols.TCP.byteValue();
405         short src = (short) 55000;
406         short dst = 80;
407
408         /*
409          * Create a SAL Flow aFlow
410          */
411         Match match = new Match();
412         match.setField(MatchType.IN_PORT, port);
413         match.setField(MatchType.DL_SRC, srcMac);
414         match.setField(MatchType.DL_DST, dstMac);
415         match.setField(MatchType.DL_TYPE, ethertype);
416         match.setField(MatchType.DL_VLAN, vlan);
417         match.setField(MatchType.DL_VLAN_PR, vlanPr);
418         match.setField(MatchType.NW_SRC, srcIP, ipMask);
419         match.setField(MatchType.NW_DST, dstIP, ipMask2);
420         match.setField(MatchType.NW_TOS, tos);
421         match.setField(MatchType.NW_PROTO, proto);
422         match.setField(MatchType.TP_SRC, src);
423         match.setField(MatchType.TP_DST, dst);
424
425         List<Action> actions = new ArrayList<Action>();
426         actions.add(new SetNwDst(newIP));
427         actions.add(new Output(oport));
428         actions.add(new PopVlan());
429         actions.add(new Flood());
430         actions.add(new Controller());
431
432         Flow flow = new Flow(match, actions);
433         flow.setPriority((short) 100);
434         flow.setHardTimeout((short) 360);
435         flow.setId(1234L);
436
437         return flow;
438     }
439
440     private Flow getSampleFlowV6(Node node) throws UnknownHostException {
441         NodeConnector port = NodeConnectorCreator.createOFNodeConnector(
442                 (short) 24, node);
443         NodeConnector oport = NodeConnectorCreator.createOFNodeConnector(
444                 (short) 30, node);
445         byte srcMac[] = { (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78,
446                 (byte) 0x9a, (byte) 0xbc };
447         byte dstMac[] = { (byte) 0x1a, (byte) 0x2b, (byte) 0x3c, (byte) 0x4d,
448                 (byte) 0x5e, (byte) 0x6f };
449         InetAddress srcIP = InetAddress
450                 .getByName("2001:420:281:1004:407a:57f4:4d15:c355");
451         InetAddress dstIP = InetAddress
452                 .getByName("2001:420:281:1004:e123:e688:d655:a1b0");
453         InetAddress ipMask = null; // InetAddress.getByName("ffff:ffff:ffff:ffff:0:0:0:0");
454                                    // V6Match implementation assumes no mask is
455                                    // specified
456         InetAddress ipMask2 = null; // InetAddress.getByName("ffff:ffff:ffff:ffff:ffff:ffff:ffff:0");
457         short ethertype = EtherTypes.IPv6.shortValue();
458         short vlan = (short) 27;
459         byte vlanPr = (byte) 3;
460         Byte tos = 4;
461         byte proto = IPProtocols.UDP.byteValue();
462         short src = (short) 5500;
463         // short dst = 80;
464
465         /*
466          * Create a SAL Flow aFlow
467          */
468         Match match = new Match();
469         match.setField(MatchType.IN_PORT, port);
470         match.setField(MatchType.DL_SRC, srcMac);
471         match.setField(MatchType.DL_DST, dstMac);
472         match.setField(MatchType.DL_TYPE, ethertype);
473         match.setField(MatchType.DL_VLAN, vlan);
474         match.setField(MatchType.DL_VLAN_PR, vlanPr); // V6Match does not handle
475                                                       // this properly...
476         match.setField(MatchType.NW_SRC, srcIP, ipMask);
477         match.setField(MatchType.NW_DST, dstIP, ipMask2);
478         match.setField(MatchType.NW_TOS, tos);
479         match.setField(MatchType.NW_PROTO, proto);
480         match.setField(MatchType.TP_SRC, src); // V6Match does not handle this
481                                                // properly...
482         // match.setField(MatchType.TP_DST, dst); V6Match does not handle this
483         // properly...
484
485         List<Action> actions = new ArrayList<Action>();
486         actions.add(new Output(oport));
487         actions.add(new PopVlan());
488         actions.add(new Flood());
489
490         Flow flow = new Flow(match, actions);
491         flow.setPriority((short) 300);
492         flow.setHardTimeout((short) 240);
493         flow.setId(65536L);
494
495         return flow;
496     }
497
498     /**
499      * This Request ID generator starts with 1. Each aysnc message is
500      * associated with an unique Request ID (!= 0).
501      *
502      * @return Request ID
503      */
504     private long getNextRid() {
505         return seq.getAndIncrement();
506     }
507
508     @Override
509     public Status syncSendBarrierMessage(Node node) {
510         if (this.pluginFlowProgrammer != null) {
511             if (this.pluginFlowProgrammer.get(node.getType()) != null) {
512                 return this.pluginFlowProgrammer.get(node.getType())
513                         .syncSendBarrierMessage(node);
514             }
515         }
516         return new Status(StatusCode.NOSERVICE, "Plugin unuvailable");
517     }
518
519     @Override
520     public Status asyncSendBarrierMessage(Node node) {
521         if (this.pluginFlowProgrammer != null) {
522             if (this.pluginFlowProgrammer.get(node.getType()) != null) {
523                 return this.pluginFlowProgrammer.get(node.getType())
524                         .asyncSendBarrierMessage(node);
525             }
526         }
527         return new Status(StatusCode.NOSERVICE, "Plugin unuvailable");
528     }
529 }

©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.