Add test for generated code checking list of dependencies.
[controller.git] / opendaylight / containermanager / api / src / main / java / org / opendaylight / controller / containermanager / ContainerFlowConfig.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.containermanager;
11
12 import java.io.Serializable;
13 import java.net.Inet4Address;
14 import java.net.Inet6Address;
15 import java.net.InetAddress;
16 import java.net.UnknownHostException;
17 import java.util.ArrayList;
18 import java.util.List;
19
20 import javax.xml.bind.annotation.XmlAccessType;
21 import javax.xml.bind.annotation.XmlAccessorType;
22 import javax.xml.bind.annotation.XmlElement;
23 import javax.xml.bind.annotation.XmlRootElement;
24
25 import org.opendaylight.controller.sal.match.Match;
26 import org.opendaylight.controller.sal.match.MatchType;
27 import org.opendaylight.controller.sal.packet.BitBufferHelper;
28 import org.opendaylight.controller.sal.utils.IPProtocols;
29 import org.opendaylight.controller.sal.utils.NetUtils;
30 import org.opendaylight.controller.sal.utils.Status;
31 import org.opendaylight.controller.sal.utils.StatusCode;
32 import org.slf4j.Logger;
33 import org.slf4j.LoggerFactory;
34
35 /**
36  * Flow Specification Java Object for Container Manager
37  * Represents a container flow configuration information for Container Manager.
38  *
39  * Objects of this class are serialized to and de-serialized from binary files through
40  * java serialization API when saving to/reading from Container manager startup
41  * configuration file.
42  */
43 @XmlRootElement (name = "flow-spec-config")
44 @XmlAccessorType(XmlAccessType.NONE)
45 public class ContainerFlowConfig implements Serializable {
46     private static Logger log = LoggerFactory.getLogger(ContainerFlowConfig.class);
47
48     /** The Constant serialVersionUID. */
49     private static final long serialVersionUID = 1L;
50
51     /** The Constant regexName. */
52     private static final String regexName = "^[\\w-+.@]+$";
53
54     /** Flow Spec name. */
55     @XmlElement
56     private String name;
57
58     /** The vlan. */
59     @XmlElement
60     private String dlVlan;
61
62     /** The network Source. */
63     @XmlElement
64     private String nwSrc;
65
66     /** The network Destination */
67     @XmlElement
68     private String nwDst;
69
70     /** The protocol. */
71     @XmlElement
72     private String protocol;
73
74     /** The transport source */
75     @XmlElement
76     private String tpSrc;
77
78     /** The transport destination */
79     @XmlElement
80     private String tpDst;
81
82     /* unidirectional flag
83     do not include this flag in equality check
84     @XmlElement */
85     private static boolean unidirectional = false;
86
87
88     /**
89      * Instantiates a new container flow config.
90      */
91     public ContainerFlowConfig() {
92     }
93
94     /**
95      * Instantiates a new container flow config.
96      *
97      * @param name Flow Spec configuration name
98      * @param container Container Name
99      * @param srcIP Source IP Address
100      * @param dstIP Destination IP Address
101      * @param proto Protocol
102      * @param srcPort Source Layer4 Port
103      * @param dstPort Destination Layer4 Port
104      */
105     public ContainerFlowConfig(String name, String srcIP, String dstIP, String proto, String srcPort,
106             String dstPort) {
107         this.name = name;
108         this.dlVlan = null;
109         this.nwSrc = srcIP;
110         this.nwDst = dstIP;
111         this.protocol = proto;
112         this.tpSrc = srcPort;
113         this.tpDst = dstPort;
114         //this.unidirectional = false;
115     }
116
117     public ContainerFlowConfig(String name, String dlVlan, String srcIP, String dstIP, String proto, String srcPort,
118             String dstPort) {
119         this.name = name;
120         this.dlVlan = dlVlan;
121         this.nwSrc = srcIP;
122         this.nwDst = dstIP;
123         this.protocol = proto;
124         this.tpSrc = srcPort;
125         this.tpDst = dstPort;
126     }
127
128
129     public ContainerFlowConfig(ContainerFlowConfig containerFlowConfig) {
130         this.name = containerFlowConfig.name;
131         this.dlVlan = containerFlowConfig.dlVlan;
132         this.nwSrc = containerFlowConfig.nwSrc;
133         this.nwDst = containerFlowConfig.nwDst;
134         this.protocol = containerFlowConfig.protocol;
135         this.tpSrc = containerFlowConfig.tpSrc;
136         this.tpDst = containerFlowConfig.tpDst;
137         //this.unidirectional = containerFlowConfig.unidirectional;
138     }
139
140     /**
141      * Returns the name of this Flow Specification
142      *
143      * @return the name of the Flow Specification
144      */
145     public String getName() {
146         // mandatory field
147         return name;
148     }
149
150     /**
151      * Returns the vlan id.
152      *
153      * @return the Vlan Id
154      */
155     public String getVlan() {
156         return (dlVlan == null || dlVlan.isEmpty()) ? null : dlVlan;
157     }
158
159     /**
160      * Returns the Source IP Address.
161      *
162      * @return the Source IP Address
163      */
164     public String getSrcIP() {
165         return (nwSrc == null || nwSrc.isEmpty()) ? null : nwSrc;
166     }
167
168     /**
169      * Returns the Destination IP Address.
170      *
171      * @return the Destination IP Address
172      */
173     public String getDstIP() {
174         return (nwDst == null || nwDst.isEmpty()) ? null : nwDst;
175     }
176
177     /**
178      * Returns the protocol.
179      *
180      * @return the protocol
181      */
182     public String getProtocol() {
183         return protocol;
184     }
185
186     /**
187      * Returns Source Layer4 Port.
188      *
189      * @return Source Layer4 Port
190      */
191     public String getSrcPort() {
192         return (tpSrc == null || tpSrc.isEmpty()) ? null : tpSrc;
193     }
194
195     /**
196      * Returns Destination Layer4 Port.
197      *
198      * @return Destination Layer4 Port
199      */
200     public String getDstPort() {
201         return (tpDst == null || tpDst.isEmpty()) ? null : tpDst;
202     }
203
204     /*
205      * @return the unidirectional flag
206      */
207     public boolean isUnidirectional() {
208         return unidirectional;
209     }
210
211     /* (non-Javadoc)
212      * @see java.lang.Object#hashCode()
213      */
214     @Override
215     public int hashCode() {
216         final int prime = 31;
217         int result = 1;
218         result = prime * result
219                 + ((protocol == null) ? 0 : protocol.hashCode());
220         result = prime * result + ((name == null) ? 0 : name.hashCode());
221         result = prime * result + ((dlVlan == null) ? 0 : dlVlan.hashCode());
222         result = prime * result + ((nwDst == null) ? 0 : nwDst.hashCode());
223         result = prime * result + ((tpDst == null) ? 0 : tpDst.hashCode());
224         result = prime * result + ((nwSrc == null) ? 0 : nwSrc.hashCode());
225         result = prime * result + ((tpSrc == null) ? 0 : tpSrc.hashCode());
226         return result;
227     }
228
229     /*
230      * For comparison, consider that container flow can have empty fields
231      */
232     /* (non-Javadoc)
233      * @see java.lang.Object#equals(java.lang.Object)
234      */
235     @Override
236     public boolean equals(Object obj) {
237         /*
238          * Configuration will be stored in collection only if it is valid
239          * Hence we don't check here for uninitialized fields
240          */
241         if (this == obj) {
242             return true;
243         }
244         if (obj == null) {
245             return false;
246         }
247         if (getClass() != obj.getClass()) {
248             return false;
249         }
250         ContainerFlowConfig other = (ContainerFlowConfig) obj;
251         if (matchName(other) && matchDlVlan(other) && matchSrcIP(other)
252                 && matchDstIP(other) && matchProtocol(other)
253                 && matchSrcPort(other) && matchDstPort(other)) {
254             return true;
255         }
256         return false;
257     }
258
259     /**
260      * Equals by Flow Spec name.
261      *
262      * @param name flow spec name for comparison
263      * @return true, if successful
264      */
265     public boolean equalsByName(String name) {
266         return this.name.equals(name);
267     }
268
269     /**
270      * equalsByMatch
271      *
272      * @param that ContainerFlowConfig for comparison
273      * @return true, if any match is equal
274      */
275     public boolean equalsByMatch(ContainerFlowConfig that) {
276         // get both matches
277         // the match is equal if any of the match is equal
278         List<Match> thisMatch = this.getMatches();
279         List<Match> otherMatch = that.getMatches();
280         // both the lists cannot be null
281         for(Match m1 : thisMatch) {
282             for(Match m2 : otherMatch) {
283                   if(m1.equals(m2)) {
284                     return true;
285                 }
286             }
287         }
288         // if you have reached here without a match
289         // being found
290         // return false
291         return false;
292     }
293
294     /**
295      * Matches the name of this flow spec with that of ContainerFlowConfig parameter's flow spec.
296      *
297      * @param o the ContainerFlowConfig parameter
298      * @return true, if successful
299      */
300     private boolean matchName(ContainerFlowConfig flowSpec) {
301         if (name == flowSpec.name) {
302             return true;
303         }
304         if (name == null || flowSpec.name == null) {
305             return false;
306         }
307         return name.equals(flowSpec.name);
308     }
309
310     /**
311      * Match Source IP Address.
312      *
313      * @param flowSpec Flow Specification
314      * @return true, if successful
315      */
316     private boolean matchDlVlan(ContainerFlowConfig flowSpec) {
317         if (dlVlan == flowSpec.dlVlan) {
318             return true;
319         }
320         if (dlVlan == null || flowSpec.dlVlan == null) {
321             return false;
322         }
323         return dlVlan.equals(flowSpec.dlVlan);
324     }
325
326     /**
327      * Match Source IP Address.
328      *
329      * @param flowSpec Flow Specification
330      * @return true, if successful
331      */
332     private boolean matchSrcIP(ContainerFlowConfig flowSpec) {
333         if (nwSrc == flowSpec.nwSrc) {
334             return true;
335         }
336         if (nwSrc == null || flowSpec.nwSrc == null) {
337             return false;
338         }
339         return nwSrc.equals(flowSpec.nwSrc);
340     }
341
342     /**
343      * Match Destination IP Address.
344      *
345      * @param flowSpec Flow Specification
346      * @return true, if successful
347      */
348     private boolean matchDstIP(ContainerFlowConfig flowSpec) {
349         if (nwDst == flowSpec.nwDst) {
350             return true;
351         }
352         if (nwDst == null || flowSpec.nwDst == null) {
353             return false;
354         }
355         return this.nwDst.equals(flowSpec.nwDst);
356     }
357
358     /**
359      * Match protocol.
360      *
361      * @param flowSpec Flow Specification
362      * @return true, if successful
363      */
364     private boolean matchProtocol(ContainerFlowConfig flowSpec) {
365         if (protocol == flowSpec.protocol) {
366             return true;
367         }
368         if (protocol == null || flowSpec.protocol == null) {
369             return false;
370         }
371         return this.protocol.equals(flowSpec.protocol);
372     }
373
374     /**
375      * Match Source Layer4 Port.
376      *
377      * @param flowSpec Flow Specification
378      * @return true, if successful
379      */
380     private boolean matchSrcPort(ContainerFlowConfig flowSpec) {
381         if (tpSrc == flowSpec.tpSrc) {
382             return true;
383         }
384         if (tpSrc == null || flowSpec.tpSrc == null) {
385             return false;
386         }
387         return tpSrc.equals(flowSpec.tpSrc);
388     }
389
390     /**
391      * Match Destination Layer4 Port.
392      *
393      * @param flowSpec Flow Specification
394      * @return true, if successful
395      */
396     private boolean matchDstPort(ContainerFlowConfig flowSpec) {
397         if (tpDst == flowSpec.tpDst) {
398             return true;
399         }
400         if (tpDst == null || flowSpec.tpDst == null) {
401             return false;
402         }
403         return this.tpDst.equals(flowSpec.tpDst);
404     }
405
406     /**
407      * Returns the vlan id number
408      *
409      * @return the vlan id number
410      */
411     public Short getVlanId() {
412         Short vlan = 0;
413         try {
414             vlan = Short.parseShort(dlVlan);
415         } catch (NumberFormatException e) {
416
417         }
418         return vlan;
419     }
420
421     /**
422      * Returns the Source IP Address mask length.
423      *
424      * @return the Source IP Address mask length
425      */
426     public Short getSrcIPMaskLen() {
427         Short maskLen = 0;
428
429         if (nwSrc != null && !nwSrc.isEmpty()) {
430             String[] s = nwSrc.split("/");
431             if (s.length == 2) {
432                 try {
433                     maskLen = Short.valueOf(s[1]);
434                 } catch (Exception e) {
435                     // no mask or bad mask
436                 }
437             } else {
438                 InetAddress ip = this.getSrcIPNum();
439                 maskLen = (short) ((ip instanceof Inet4Address) ? 32 : 128);
440             }
441         }
442         return maskLen;
443     }
444
445     /**
446      * Returns the Destination IP Address mask length.
447      *
448      * @return the Destination IP Address mask length
449      */
450     public Short getDstIPMaskLen() {
451         Short maskLen = 0;
452         if (nwDst != null && !nwDst.isEmpty()) {
453             String[] s = nwDst.split("/");
454             if (s.length == 2) {
455                 try {
456                     maskLen = Short.valueOf(s[1]);
457                 } catch (Exception e) {
458                     // no mask or bad mask
459                 }
460             } else {
461                 InetAddress ip = this.getDstIPNum();
462                 maskLen = (short) ((ip instanceof Inet4Address) ? 32 : 128);
463             }
464         }
465         return maskLen;
466     }
467
468     /**
469      * Returns the Source IP Address.
470      *
471      * @return the Source IP Address
472      */
473     public InetAddress getSrcIPNum() {
474         InetAddress ip = null;
475         if (nwSrc == null || nwSrc.isEmpty()) {
476             try {
477                 ip = InetAddress.getByAddress(new byte[16]);
478                 return ip;
479             } catch (UnknownHostException e) {
480                 log.error("", e);
481                 return null;
482             }
483         }
484         try {
485             ip = InetAddress.getByName(nwSrc.split("/")[0]);
486         } catch (UnknownHostException e1) {
487             log.error("", e1);
488             return null;
489         }
490         return ip;
491     }
492
493     /**
494      * Returns the Destination IP Address.
495      *
496      * @return the Destination IP Address
497      */
498     public InetAddress getDstIPNum() {
499         InetAddress ip = null;
500         if (nwDst == null || nwDst.isEmpty()) {
501             try {
502                 ip = InetAddress.getByAddress(new byte[16]);
503                 return ip;
504             } catch (UnknownHostException e) {
505                 log.error("",e);
506                 return null;
507             }
508         }
509         try {
510             ip = InetAddress.getByName(nwDst.split("/")[0]);
511         } catch (UnknownHostException e1) {
512             log.error("", e1);
513             return null;
514         }
515         return ip;
516     }
517
518     /**
519      * Returns Source Layer4 Port number.
520      *
521      * @return Source Layer4 Port number
522      */
523     public Short getSrcPortNum() {
524         return (tpSrc == null || tpSrc.isEmpty()) ? Short.valueOf((short) 0)
525                 : Short.valueOf(tpSrc);
526     }
527
528     /**
529      * Returns Destination Layer4 Port number.
530      *
531      * @return Destination Layer4 Port number
532      */
533     public Short getDstPortNum() {
534         return (tpDst == null || tpDst.isEmpty()) ? Short.valueOf((short) 0)
535                 : Short.valueOf(tpDst);
536     }
537
538     /**
539      * Get the IP protocol value
540      *
541      * @return the protocol
542      */
543     public Short getProtoNum() {
544         return protocol == null ? null : IPProtocols.getProtocolNumberShort(protocol);
545     }
546
547     /**
548      * Returns whether this container flow overlap with the passed one This is
549      * true when any two of the resulting matches for the two container flow
550      * configurations intersect.
551      *
552      * @param other
553      *            the other container flow config with which checking the
554      *            overlap
555      * @return true if the two configurations overlap, false otherwise
556      */
557     public boolean overlap(ContainerFlowConfig other) {
558         if (other == null) {
559             return false;
560         }
561         List<Match> myMathes = this.getMatches();
562         List<Match> hisMatches = other.getMatches();
563         for (Match mine : myMathes) {
564             for (Match his : hisMatches) {
565                 if (mine.intersetcs(his)) {
566                     return true;
567                 }
568             }
569         }
570         return false;
571     }
572
573     /**
574      * Checks if this flow specification configuration is valid.
575      *
576      * @return true, if is valid
577      */
578     public Status validate() {
579         if (!hasValidName()) {
580             return new Status(StatusCode.BADREQUEST, "Invalid name");
581         }
582         Status status = validateVlan();
583         if (!status.isSuccess()) {
584             return status;
585         }
586         status = validateIPs();
587         if (!status.isSuccess()) {
588             return status;
589         }
590         if(!hasValidProtocol()) {
591             return new Status(StatusCode.BADREQUEST, "Invalid IP protocol");
592         }
593         if (!hasValidPorts()) {
594             return new Status(StatusCode.BADREQUEST, "Invalid Source or Destination Port");
595         }
596         if (this.getMatches().get(0).getMatches() == 0) {
597             return new Status(StatusCode.BADREQUEST, "Flow Spec is empty");
598         }
599         return new Status(StatusCode.SUCCESS);
600     }
601
602     /**
603      * Checks if this flow specification configuration has a valid name.
604      *
605      * @return true, if successful
606      */
607     private boolean hasValidName() {
608         return (name != null && !name.isEmpty() && name.matches(regexName));
609     }
610
611     /**
612      * Validates the vlan number
613      *
614      * @return the result of the check as Status object
615      */
616     private Status validateVlan() {
617         if (dlVlan != null) {
618             short vlanId = 0;
619             try {
620                 vlanId = Short.parseShort(dlVlan);
621             } catch (NumberFormatException e) {
622                 return new Status(StatusCode.BADREQUEST, "Invalid vlan id");
623             }
624             if (vlanId < 0 || vlanId > 0xfff) {
625                 return new Status(StatusCode.BADREQUEST, "Invalid vlan id");
626             }
627         }
628         return new Status(StatusCode.SUCCESS);
629     }
630
631     /**
632      * Validates the network addresses, checks syntax and semantic
633      *
634      * @return the result of the check as Status object, if successful
635      */
636     private Status validateIPs() {
637         if (nwSrc != null) {
638             if (!NetUtils.isIPAddressValid(nwSrc)) {
639                 return new Status(StatusCode.BADREQUEST, "Invalid network source address");
640             }
641             byte[] bytePrefix = NetUtils.getSubnetPrefix(this.getSrcIPNum(), this.getSrcIPMaskLen()).getAddress();
642             long prefix = BitBufferHelper.getLong(bytePrefix);
643             if (prefix == 0) {
644                 return new Status(StatusCode.BADREQUEST, "Invalid network source address: subnet zero");
645             }
646         }
647         if (nwDst != null) {
648             if (!NetUtils.isIPAddressValid(nwDst)) {
649                 return new Status(StatusCode.BADREQUEST, "Invalid network destination address");
650             }
651             byte[] bytePrefix = NetUtils.getSubnetPrefix(this.getDstIPNum(), this.getDstIPMaskLen()).getAddress();
652             long prefix = BitBufferHelper.getLong(bytePrefix);
653             if (prefix == 0) {
654                 return new Status(StatusCode.BADREQUEST, "Invalid network destination address: subnet zero");
655             }
656         }
657         return new Status(StatusCode.SUCCESS);
658     }
659
660     /**
661      * Validate the protocol field. Either it can be a enum defined in IPProtocols.java
662      * or a valid IP proto value between 0 and 255, see:
663      * http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml
664      * for more details.
665      *
666      * @return true if a valid protocol value
667      */
668     private boolean hasValidProtocol() {
669         IPProtocols p = IPProtocols.fromString(protocol);
670         return p != null;
671     }
672
673     /**
674      *
675      * @param tpPort
676      *               String representing the transport protocol port number
677      * @return true if tpPort contains a decimal value between 0 and 65535
678      */
679     private boolean hasValidPort(String tpPort) {
680         try {
681             int port = Integer.decode(tpPort);
682             return ((port >= 0) && (port <= 0xffff));
683         } catch (NumberFormatException e) {
684             return false;
685         }
686     }
687
688     /**
689      * Validate the transport protocol source and destination ports as
690      * entered by users.
691      *
692      * @return true if ports are defined and are in valid range
693      */
694     private boolean hasValidPorts() {
695         if (tpSrc !=null && !tpSrc.isEmpty()) {
696             if (!hasValidPort(tpSrc)) {
697                 return false;
698             }
699         }
700
701         if (tpDst !=null && !tpDst.isEmpty()) {
702             return hasValidPort(tpDst);
703         }
704         return true;
705     }
706
707     /**
708      * Returns the matches.
709      * If unidirectional flag is set, there will be only one match in the list
710      * If unidirectional flag is unset there will be two matches in the list,
711      * only if the specified flow has an intrinsic direction.
712      * For Ex. if the cFlow only has the protocol field configured, no matter
713      * if unidirectional flag is set or not, only one match will be returned
714      * The client just has to iterate over the returned list
715      * @return the matches
716      */
717     public List<Match> getMatches() {
718         List<Match> matches = new ArrayList<Match>();
719         Match match = new Match();
720
721         if (this.dlVlan != null && !this.dlVlan.isEmpty()) {
722             match.setField(MatchType.DL_VLAN, this.getVlanId());
723         }
724         if (this.nwSrc != null && !this.nwSrc.trim().isEmpty()) {
725             String parts[] = this.nwSrc.split("/");
726             InetAddress ip = NetUtils.parseInetAddress(parts[0]);
727             InetAddress mask = null;
728             int maskLen = 0;
729             if (parts.length > 1) {
730                 maskLen = Integer.parseInt(parts[1]);
731             } else {
732                 maskLen = (ip instanceof Inet6Address) ? 128 : 32;
733             }
734             mask = NetUtils.getInetNetworkMask(maskLen, ip instanceof Inet6Address);
735             match.setField(MatchType.NW_SRC, ip, mask);
736         }
737         if (this.nwDst != null && !this.nwDst.trim().isEmpty()) {
738             String parts[] = this.nwDst.split("/");
739             InetAddress ip = NetUtils.parseInetAddress(parts[0]);
740             InetAddress mask = null;
741             int maskLen = 0;
742             if (parts.length > 1) {
743                 maskLen = Integer.parseInt(parts[1]);
744             } else {
745                 maskLen = (ip instanceof Inet6Address) ? 128 : 32;
746             }
747             mask = NetUtils.getInetNetworkMask(maskLen, ip instanceof Inet6Address);
748             match.setField(MatchType.NW_DST, ip, mask);
749         }
750         if (IPProtocols.fromString(this.protocol) != IPProtocols.ANY) {
751             match.setField(MatchType.NW_PROTO, IPProtocols.getProtocolNumberByte(this.protocol));
752         }
753         if (this.tpSrc != null && !this.tpSrc.trim().isEmpty()) {
754             match.setField(MatchType.TP_SRC, Integer.valueOf(tpSrc).shortValue());
755         }
756         if (this.tpDst != null && !this.tpDst.trim().isEmpty()) {
757             match.setField(MatchType.TP_DST, Integer.valueOf(tpDst).shortValue());
758         }
759
760         matches.add(match);
761         if(!ContainerFlowConfig.unidirectional) {
762             Match reverse = match.reverse();
763             if (!match.equals(reverse)) {
764                 matches.add(reverse);
765             }
766         }
767         return matches;
768     }
769
770     /*
771      * (non-Javadoc)
772      *
773      * @see java.lang.Object#toString()
774      */
775     @Override
776     public String toString() {
777         return "Container Flow={name:" + name + " dlVlan:" + dlVlan + " nwSrc:" + nwSrc + " nwDst:" + nwDst + " " + "protocol:" + protocol
778                 + " tpSrc:" + tpSrc + " tpDst:" + tpDst + "}";
779     }
780 }

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