2 * Validate all instance data received from the config datastore via the onDataChange() notification.
4 * N.B. that yang typedefs are not validated when a PUT operation places them into the config datastore.
5 * This means that they can arrive at onDataChange() with invalid values.
7 * In particular integer range values and string patterns (such as IP prefix/len) are not checked
8 * and accessing these values via any object.getValue() method call will cause an exception (as yang
9 * finally gets around to actually enforcing the typedef).
11 package org.opendaylight.controller.packetcable.provider;
13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
14 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.*;
15 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ServiceClassName;
16 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ServiceFlowDirection;
17 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.TosByte;
18 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.TpProtocol;
19 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ccap.Ccaps;
20 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ccap.CcapsBuilder;
21 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ccap.attributes.AmId;
22 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ccap.attributes.AmIdBuilder;
23 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ccap.attributes.Connection;
24 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.ccap.attributes.ConnectionBuilder;
25 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.classifier.Classifier;
26 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.classifier.ClassifierBuilder;
27 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.ext.classifier.ExtClassifier;
28 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.ext.classifier.ExtClassifierBuilder;
29 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.gate.spec.GateSpec;
30 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.gate.spec.GateSpecBuilder;
31 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.gates.apps.subs.Gates;
32 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.gates.apps.subs.GatesBuilder;
33 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.ipv6.classifier.Ipv6Classifier;
34 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.ipv6.classifier.Ipv6ClassifierBuilder;
35 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.traffic.profile.TrafficProfile;
36 import org.opendaylight.yang.gen.v1.urn.packetcable.rev150327.pcmm.qos.traffic.profile.TrafficProfileBuilder;
37 import org.opendaylight.yangtools.yang.binding.DataObject;
38 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
39 import org.slf4j.Logger;
40 import org.slf4j.LoggerFactory;
42 import java.lang.reflect.Method;
43 import java.util.List;
45 import java.util.concurrent.ConcurrentHashMap;
46 import java.util.concurrent.ExecutorService;
47 import java.util.concurrent.Executors;
49 public class ValidateInstanceData {
51 private final static Logger logger = LoggerFactory.getLogger(ValidateInstanceData.class);
54 private final DataBroker dataBroker;
55 private final ExecutorService executor;
58 private final Map<InstanceIdentifier<Gates>, Gates> gateIidMap;
61 private transient Ccaps ccap;
62 private transient InstanceIdentifier<Ccaps> ccapIID;
64 public ValidateInstanceData(final DataBroker dataBroker, final Map<InstanceIdentifier<?>, DataObject> thisData) {
65 executor = Executors.newCachedThreadPool();
66 this.dataBroker = dataBroker;
69 // Must be instantiated prior to retreiving the gates below
70 gateIidMap = new ConcurrentHashMap<>();
72 // TODO FIXME - this value is always null???
77 public boolean isResponseEcho() {
78 // see if there is a response object in the updated data
79 // if so this is an echo of the response message insertion so our caller can exit right away
80 if (ccap != null && ccap.getResponse() != null) {
82 } else if (! gateIidMap.isEmpty() && gateIidMap.values().iterator().next().getResponse() != null) {
87 public boolean validateYang() {
88 final String badText = "400 Bad Request - Invalid Element Values in json object - ";
89 if (isResponseEcho()) {
90 // don't validiate the echo again
94 Response response = new Response(dataBroker, ccapIID, ccap, badText);
95 if (! validateCcap(ccap, response)) {
96 logger.error("Validate CCAP {} failed - {}", ccap.getCcapId(), response.getMessage());
97 executor.execute(response);
100 } else if (! gateIidMap.isEmpty()) {
101 for (Map.Entry<InstanceIdentifier<Gates>, Gates> entry : gateIidMap.entrySet()) {
102 InstanceIdentifier<Gates> gateIID = entry.getKey();
103 Gates gate = entry.getValue();
104 Response response = new Response(dataBroker, gateIID, gate, badText);
105 if (! validateGate(gate, response)) {
106 logger.error("Validate Gate {} failed - {}", gate.getGateId(), response.getMessage());
107 executor.execute(response);
115 private void getCcap(final Map<InstanceIdentifier<?>, DataObject> thisData) {
116 for (final Map.Entry<InstanceIdentifier<?>, DataObject> entry : thisData.entrySet()) {
117 if (entry.getValue() instanceof Ccaps) {
118 ccap = (Ccaps)entry.getValue();
119 // TODO FIXME - ClassCastException waiting to occur here!!!
120 ccapIID = (InstanceIdentifier<Ccaps>) entry.getKey();
125 private void getGates(final Map<InstanceIdentifier<?>, DataObject> thisData) {
126 for (final Map.Entry<InstanceIdentifier<?>, DataObject> entry : thisData.entrySet()) {
127 if (entry.getValue() instanceof Gates) {
128 final Gates gate = (Gates)entry.getValue();
129 // TODO FIXME - ClassCastException waiting to occur here!!!
130 final InstanceIdentifier<Gates> gateIID = (InstanceIdentifier<Gates>)entry.getKey();
131 gateIidMap.put(gateIID, gate);
135 private String validateMethod(final Class<?> thisClass, final Object thisObj, final String methodName) {
137 final Method method = thisClass.getMethod(methodName);
138 method.invoke(thisObj);
139 } catch (IllegalArgumentException e) {
140 return e.getMessage();
141 } catch (Exception e) {
143 // error = String.format("%s.%s(): Method failed: %s ", thisClass.getSimpleName(), methodName, e.getMessage());
148 private boolean validateGateSpec(final Gates gate, final GatesBuilder gateBuilder, final Response response) {
152 boolean valid = true;
153 GateSpec gateSpec = gate.getGateSpec();
154 if (gateSpec != null) {
155 final ServiceFlowDirection dir;
156 error = validateMethod(GateSpec.class, gateSpec, "getDirection");
158 dir = gateSpec.getDirection();
160 if (gate.getTrafficProfile().getServiceClassName() != null) {
161 message += " gate-spec.direction not allowed for traffic-profile.SCN;";
166 message += " gate-spec.direction invalid: must be 'us' or 'ds' -" + error;
170 final TosByte tosByte;
171 error = validateMethod(GateSpec.class, gateSpec, "getDscpTosOverwrite");
173 tosByte = gateSpec.getDscpTosOverwrite();
175 message += " gate-spec.dscp-tos-overwrite invalid: " + error;
179 final TosByte tosMask;
180 error = validateMethod(GateSpec.class, gateSpec, "getDscpTosMask");
182 tosMask = gateSpec.getDscpTosMask();
183 if (tosByte != null && tosMask == null) {
184 message += " gate-spec.dscp-tos-mask missing;";
188 message += " gate-spec.dscp-tos-mask invalid: " + error;
193 // rebuild the gateSpec with nulls replacing bad values
194 final GateSpecBuilder gateSpecBuilder = new GateSpecBuilder();
195 gateSpecBuilder.setDirection(dir);
196 gateSpecBuilder.setDscpTosOverwrite(tosByte);
197 gateSpecBuilder.setDscpTosMask(tosMask);
198 gateSpec = gateSpecBuilder.build();
200 gateBuilder.setGateSpec(gateSpec);
204 response.addMessage(message);
209 private boolean validateTrafficProfile(final Gates gate, final GatesBuilder gateBuilder, final Response response) {
212 boolean valid = true;
213 TrafficProfile profile = gate.getTrafficProfile();
214 if (profile == null) {
215 message += " traffic-profile is required;";
218 final ServiceClassName scn;
219 final String error = validateMethod(TrafficProfile.class, profile, "getServiceClassName");
221 scn = profile.getServiceClassName();
223 message += " traffic-profile.service-class-name missing;";
227 message += " traffic-profile.service-class-name invalid: must be 2-16 characters " + error;
232 final TrafficProfileBuilder profileBuilder = new TrafficProfileBuilder();
233 // TODO FIXME - scn is always null???
234 profileBuilder.setServiceClassName(scn);
235 profile = profileBuilder.build();
237 gateBuilder.setTrafficProfile(profile);
241 response.addMessage(message);
246 // TODO FIXME - Break this method apart
247 private boolean validateClassifier(final Gates gate, final GatesBuilder gateBuilder, final Response response) {
248 // validate classifier
250 boolean valid = true;
252 Classifier classifier = gate.getClassifier();
254 final Ipv4Address sip;
255 String error = validateMethod(Classifier.class, classifier, "getSrcIp");
257 sip = classifier.getSrcIp();
260 message += " classifier.srcIp invalid: - " + error;
265 final Ipv4Address dip;
266 error = validateMethod(Classifier.class, classifier, "getDstIp");
268 dip = classifier.getDstIp();
271 message += " classifier.dstIp invalid: - " + error;
276 final TpProtocol proto;
277 error = validateMethod(Classifier.class, classifier, "getProtocol");
279 proto = classifier.getProtocol();
282 message += " classifier.protocol invalid: - " + error;
287 final PortNumber sport;
288 error = validateMethod(Classifier.class, classifier, "getSrcPort");
290 sport = classifier.getSrcPort();
293 message += " classifier.srcPort invalid: - " + error;
298 final PortNumber dport;
299 error = validateMethod(Classifier.class, classifier, "getDstPort");
301 dport = classifier.getDstPort();
304 message += " classifier.dstPort invalid: - " + error;
309 final TosByte tosByte;
310 error = validateMethod(Classifier.class, classifier, "getTosByte");
312 tosByte = classifier.getTosByte();
315 message += " classifier.tosByte invalid: " + error;
319 final TosByte tosMask;
320 error = validateMethod(Classifier.class, classifier, "getTosMask");
322 tosMask = classifier.getTosMask();
323 if (tosByte != null && tosMask == null) {
324 message += " classifier.tosMask missing;";
328 message += " classifier.tosMask invalid: " + error;
333 message += " classifer must have at least one match field";
337 final ClassifierBuilder cBuilder = new ClassifierBuilder();
338 cBuilder.setSrcIp(sip);
339 cBuilder.setDstIp(dip);
340 cBuilder.setProtocol(proto);
341 cBuilder.setSrcPort(sport);
342 cBuilder.setDstPort(dport);
343 cBuilder.setTosByte(tosByte);
344 cBuilder.setTosMask(tosMask);
345 classifier = cBuilder.build();
346 gateBuilder.setClassifier(classifier);
347 response.addMessage(message);
352 // TODO FIXME - breakup this method
353 private boolean validateExtClassifier(final Gates gate, final GatesBuilder gateBuilder, final Response response) {
354 // validate ext-classifier
357 boolean valid = true;
359 ExtClassifier extClassifier = gate.getExtClassifier();
361 final Ipv4Address sip;
362 error = validateMethod(ExtClassifier.class, extClassifier, "getSrcIp");
364 sip = extClassifier.getSrcIp();
367 message += " ext-classifier.srcIp invalid: - " + error;
371 final Ipv4Address sipMask;
372 error = validateMethod(ExtClassifier.class, extClassifier, "getSrcIpMask");
374 sipMask = extClassifier.getSrcIpMask();
377 message += " ext-classifier.srcIpMask invalid: - " + error;
381 if (sip != null && sipMask == null) {
382 message += " ext-classifier.srcIpMask missing";
386 final Ipv4Address dip;
387 error = validateMethod(ExtClassifier.class, extClassifier, "getDstIp");
389 dip = extClassifier.getDstIp();
392 message += " ext-classifier.dstIp invalid: - " + error;
396 final Ipv4Address dipMask;
397 error = validateMethod(ExtClassifier.class, extClassifier, "getDstIpMask");
399 dipMask = extClassifier.getDstIpMask();
402 message += " ext-classifier.srcIpMask invalid: - " + error;
406 if (dip != null && dipMask == null) {
407 message += " ext-classifier.dstIpMask missing;";
411 final TpProtocol proto;
412 error = validateMethod(ExtClassifier.class, extClassifier, "getProtocol");
414 proto = extClassifier.getProtocol();
417 message += " ext-classifier.protocol invalid: - " + error;
422 final PortNumber sportStart;
423 error = validateMethod(ExtClassifier.class, extClassifier, "getSrcPortStart");
425 sportStart = extClassifier.getSrcPortStart();
428 message += " ext-classifier.srcPortStart invalid: - " + error;
432 final PortNumber sportEnd;
433 error = validateMethod(ExtClassifier.class, extClassifier, "getSrcPortEnd");
435 sportEnd = extClassifier.getSrcPortEnd();
438 message += " ext-classifier.srcPortEnd invalid: - " + error;
442 if (sportStart != null && sportEnd != null) {
443 if (sportStart.getValue() > sportEnd.getValue()) {
444 message += " ext-classifier.srcPortStart greater than srcPortEnd";
448 // Destination port range
449 final PortNumber dportStart;
450 error = validateMethod(ExtClassifier.class, extClassifier, "getDstPortStart");
452 dportStart = extClassifier.getDstPortStart();
455 message += " ext-classifier.dstPortStart invalid: - " + error;
459 final PortNumber dportEnd;
460 error = validateMethod(ExtClassifier.class, extClassifier, "getDstPortEnd");
462 dportEnd = extClassifier.getDstPortEnd();
465 message += " ext-classifier.dstPortEnd invalid: - " + error;
469 if (dportStart != null && dportEnd != null) {
470 if (dportStart.getValue() > dportEnd.getValue()) {
471 message += " ext-classifier.dstPortStart greater than dstPortEnd";
476 final TosByte tosByte;
477 error = validateMethod(ExtClassifier.class, extClassifier, "getTosByte");
479 tosByte = extClassifier.getTosByte();
482 message += " ext-classifier.tosByte invalid: " + error;
486 final TosByte tosMask;
487 error = validateMethod(ExtClassifier.class, extClassifier, "getTosMask");
489 tosMask = extClassifier.getTosMask();
490 if (tosByte != null && tosMask == null) {
491 message += " ext-classifier.tosMask missing;";
495 message += " ext-classifier.tosMask invalid: " + error;
500 message += " ext-classifer must have at least one match field";
504 final ExtClassifierBuilder cBuilder = new ExtClassifierBuilder();
505 cBuilder.setSrcIp(sip);
506 cBuilder.setSrcIpMask(sipMask);
507 cBuilder.setDstIp(dip);
508 cBuilder.setDstIpMask(dipMask);
509 cBuilder.setProtocol(proto);
510 cBuilder.setSrcPortStart(sportStart);
511 cBuilder.setSrcPortEnd(sportEnd);
512 cBuilder.setDstPortStart(dportStart);
513 cBuilder.setDstPortEnd(dportEnd);
514 cBuilder.setTosByte(tosByte);
515 cBuilder.setTosMask(tosMask);
516 extClassifier = cBuilder.build();
517 gateBuilder.setExtClassifier(extClassifier);
518 response.addMessage(message);
523 // TODO FIXME - break apart this method.
524 private boolean validateIpv6Classifier(final Gates gate, final GatesBuilder gateBuilder, final Response response) {
525 // validate ipv6-classifier
528 boolean valid = true;
530 Ipv6Classifier ipv6Classifier = gate.getIpv6Classifier();
531 // Source IPv6 prefix
532 final Ipv6Prefix sip6;
533 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getSrcIp6");
535 sip6 = ipv6Classifier.getSrcIp6();
538 message += " ipv6-classifier.srcIp invalid: - " + error;
542 // Destination IPv6 prefix
543 final Ipv6Prefix dip6;
544 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getDstIp6");
546 dip6 = ipv6Classifier.getDstIp6();
549 message += " ipv6-classifier.dstIp invalid: - " + error;
555 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getFlowLabel");
557 flowLabel = ipv6Classifier.getFlowLabel();
558 if (flowLabel > 1048575) {
559 message += " ipv6-classifier.flowLabel invalid: - must be 0..1048575";
566 message += " ipv6-classifier.flowLabel invalid: - " + error;
571 final TpProtocol nxtHdr;
572 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getNextHdr");
574 nxtHdr = ipv6Classifier.getNextHdr();
577 message += " ipv6-classifier.nextHdr invalid: - " + error;
582 final PortNumber sportStart;
583 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getSrcPortStart");
585 sportStart = ipv6Classifier.getSrcPortStart();
588 message += " ipv6-classifier.srcPortStart invalid: - " + error;
592 final PortNumber sportEnd;
593 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getSrcPortEnd");
595 sportEnd = ipv6Classifier.getSrcPortEnd();
598 message += " ipv6-classifier.srcPortEnd invalid: - " + error;
602 if (sportStart != null && sportEnd != null) {
603 if (sportStart.getValue() > sportEnd.getValue()) {
604 message += " ipv6-classifier.srcPortStart greater than srcPortEnd";
608 // Destination port range
609 final PortNumber dportStart;
610 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getDstPortStart");
612 dportStart = ipv6Classifier.getDstPortStart();
615 message += " ipv6-classifier.dstPortStart invalid: - " + error;
619 final PortNumber dportEnd;
620 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getDstPortEnd");
622 dportEnd = ipv6Classifier.getDstPortEnd();
625 message += " ipv6-classifier.dstPortEnd invalid: - " + error;
629 if (dportStart != null && dportEnd != null) {
630 if (dportStart.getValue() > dportEnd.getValue()) {
631 message += " ipv6-classifier.dstPortStart greater than dstPortEnd";
637 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getTcLow");
639 tcLow = ipv6Classifier.getTcLow();
642 message += " ipv6-classifier.tc-low invalid: " + error;
646 final TosByte tcHigh;
647 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getTcHigh");
649 tcHigh = ipv6Classifier.getTcHigh();
652 message += " ipv6-classifier.tc-high invalid: " + error;
656 if (tcLow != null && tcHigh != null) {
657 if (tcLow.getValue() > tcHigh.getValue()) {
658 message += " ipv6-classifier.tc-low is greater than tc-high";
662 final TosByte tcMask;
663 error = validateMethod(Ipv6Classifier.class, ipv6Classifier, "getTcMask");
665 tcMask = ipv6Classifier.getTcMask();
667 message += " ipv6-classifier.tc-mask invalid: " + error;
671 if (tcLow != null && tcHigh != null && tcMask == null) {
672 message += " ipv6-classifier.tc-mask missing;";
676 message += " ipv6-classifer must have at least one match field";
681 final Ipv6ClassifierBuilder cBuilder = new Ipv6ClassifierBuilder();
682 cBuilder.setSrcIp6(sip6);
683 cBuilder.setDstIp6(dip6);
684 cBuilder.setFlowLabel(flowLabel);
685 cBuilder.setNextHdr(nxtHdr);
686 cBuilder.setSrcPortStart(sportStart);
687 cBuilder.setSrcPortEnd(sportEnd);
688 cBuilder.setDstPortStart(dportStart);
689 cBuilder.setDstPortEnd(dportEnd);
690 cBuilder.setTcLow(tcLow);
691 cBuilder.setTcHigh(tcHigh);
692 cBuilder.setTcMask(tcMask);
693 ipv6Classifier = cBuilder.build();
694 gateBuilder.setIpv6Classifier(ipv6Classifier);
695 response.addMessage(message);
700 // TODO FIXME - Do we really want the gate parameter object to be muted by this method?
701 private boolean validateGate(Gates gate, final Response response) {
702 // validate gate elements and null out invalid elements as we go
703 final GatesBuilder gateBuilder = new GatesBuilder();
705 boolean rebuild = false;
707 if (! validateGateSpec(gate, gateBuilder, response)) {
711 if (! validateTrafficProfile(gate, gateBuilder, response)) {
714 // classifiers (one of legacy classifier, ext-classifier, or ipv6 classifier
715 final Classifier classifier = gate.getClassifier();
716 final ExtClassifier extClassifier = gate.getExtClassifier();
717 final Ipv6Classifier ipv6Classifier = gate.getIpv6Classifier();
719 if (classifier != null) { count++; }
720 if (extClassifier != null) { count++; }
721 if (ipv6Classifier != null) { count++; }
723 response.addMessage(" Missing classifer: must have only 1 of classifier, ext-classifier, or ipv6-classifier");
725 } else if (count > 1) {
726 response.addMessage(" Multiple classifiers: must have only 1 of classifier, ext-classifier, or ipv6-classifier");
728 } else if (count == 1) {
729 if (classifier != null) {
730 // validate classifier
731 if (! validateClassifier(gate, gateBuilder, response)) {
734 } else if (extClassifier != null) {
735 //validate ext-classifier
736 if (! validateExtClassifier(gate, gateBuilder, response)) {
739 } else if (ipv6Classifier != null) {
740 // TODO FIXME - ipv6Classifier is always null???
741 // validate ipv6-classifier
742 if (! validateIpv6Classifier(gate, gateBuilder, response)) {
747 // rebuild the gate object with valid data and set the response
749 gateBuilder.setGateId(gate.getGateId());
750 gateBuilder.setKey(gate.getKey());
751 // TODO FIXME - the input parameter "gate" is being muted here???
752 gate = gateBuilder.build();
753 response.setGateBase(gate);
754 response.addMessage(message);
759 private boolean validateAmId(final Ccaps ccap, final CcapsBuilder ccapBuilder, final Response response) {
763 boolean valid = true;
764 AmId amId = ccap.getAmId();
766 message += " amId is required;";
770 error = validateMethod(AmId.class, amId, "getAmTag");
772 amTag = amId.getAmTag();
774 message += " amId.amTag missing;";
778 message += " amId.amTag invalid: " + error;
782 final Integer amType;
783 error = validateMethod(AmId.class, amId, "getAmType");
785 amType = amId.getAmType();
786 if (amType == null) {
787 message += " amId.amType missing;";
791 message += " amId.amType invalid: " + error;
796 final AmIdBuilder amIdBuilder = new AmIdBuilder();
797 amIdBuilder.setAmTag(amTag);
798 amIdBuilder.setAmType(amType);
799 amId = amIdBuilder.build();
800 ccapBuilder.setAmId(amId);
804 response.addMessage(message);
809 private boolean validateConnection(final Ccaps ccap, final CcapsBuilder ccapBuilder, final Response response) {
813 boolean valid = true;
814 Connection conn = ccap.getConnection();
816 message += " connection is required;";
820 final IpAddress ipAddress;
821 error = validateMethod(Connection.class, conn, "getIpAddress");
823 ipAddress = conn.getIpAddress();
824 if (ipAddress == null) {
825 message += " connection.ipAddress missing;";
829 message += " connection.ipAddress invalid: " + error;
834 final PortNumber portNum;
835 error = validateMethod(Connection.class, conn, "getPort");
837 portNum = conn.getPort();
839 message += " connection.port invalid: " + error;
844 final ConnectionBuilder connBuilder = new ConnectionBuilder();
845 connBuilder.setIpAddress(ipAddress);
846 connBuilder.setPort(portNum);
847 conn = connBuilder.build();
848 ccapBuilder.setConnection(conn);
852 response.addMessage(message);
857 private boolean validateSubscriberSubnets(final Ccaps ccap, final CcapsBuilder ccapBuilder,
858 final Response response) {
859 // subscriber-subnets
862 boolean valid = true;
863 List<IpPrefix> subnets = null;
864 error = validateMethod(Ccaps.class, ccap, "getSubscriberSubnets");
866 subnets = ccap.getSubscriberSubnets();
867 if (subnets == null) {
868 message += " subscriber-subnets is required;";
872 message += " subscriber-subnets contains invalid IpPrefix - must be <ipaddress>/<prefixlen> format;" + error;
876 // TODO FIXME - subnets is always null???
877 ccapBuilder.setSubscriberSubnets(subnets);
878 response.addMessage(message);
883 private boolean validateUpstreamScns(final Ccaps ccap, final CcapsBuilder ccapBuilder, final Response response) {
887 boolean valid = true;
888 List<ServiceClassName> usScns = null;
889 error = validateMethod(Ccaps.class, ccap, "getUpstreamScns");
891 usScns = ccap.getUpstreamScns();
892 if (usScns == null) {
893 message += " upstream-scns is required;";
897 message += " upstream-scns contains invalid SCN - must be 2-16 characters;" + error;
901 // TODO FIXME - usScns is always null???
902 ccapBuilder.setUpstreamScns(usScns);
903 response.addMessage(message);
908 private boolean validateDownstreamScns(final Ccaps ccap, final CcapsBuilder ccapBuilder, final Response response) {
911 boolean valid = true;
912 List<ServiceClassName> dsScns = null;
913 final String error = validateMethod(Ccaps.class, ccap, "getDownstreamScns");
915 dsScns = ccap.getDownstreamScns();
916 if (dsScns == null) {
917 message += " downstream-scns is required;";
921 message += " downstream-scns contains invalid SCN - must be 2-16 characters;" + error;
925 // TODO FIXME - dsScns is always null???
926 ccapBuilder.setDownstreamScns(dsScns);
927 response.addMessage(message);
933 // TODO FIXME - Do we really want the ccap parameter object to be muted by this method?
934 private boolean validateCcap(Ccaps ccap, final Response response) {
935 // validate ccap and null out invalid elements as we go
936 final CcapsBuilder ccapBuilder = new CcapsBuilder();
938 boolean rebuild = false;
940 if ( ! validateAmId(ccap, ccapBuilder, response)) {
944 if ( ! validateConnection(ccap, ccapBuilder, response)) {
947 // subscriber-subnets
948 if ( ! validateSubscriberSubnets(ccap, ccapBuilder, response)) {
952 if ( ! validateUpstreamScns(ccap, ccapBuilder, response)) {
956 if ( ! validateDownstreamScns(ccap, ccapBuilder, response)) {
959 // rebuild the ccap object with valid data and set the response
961 ccapBuilder.setCcapId(ccap.getCcapId());
962 ccapBuilder.setKey(ccap.getKey());
963 // TODO FIXME - the input parameter "ccap" is being muted here???
964 ccap = ccapBuilder.build();
965 response.setCcapBase(ccap);
966 response.addMessage(message);