pcep/base-parser/src/main/java/org/opendaylight/protocol/pcep/parser/message/PCEPRequestMessageParser.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 package org.opendaylight.protocol.pcep.parser.message;
   9
  10 import com.google.common.base.Preconditions;
  11 import io.netty.buffer.ByteBuf;
  12 import io.netty.buffer.Unpooled;
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import java.util.Optional;
  16 import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
  17 import org.opendaylight.protocol.pcep.spi.MessageUtil;
  18 import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
  19 import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
  20 import org.opendaylight.protocol.pcep.spi.PCEPErrors;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.Pcreq;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.PcreqBuilder;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.Message;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.Object;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bandwidth.object.Bandwidth;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bnc.object.BranchNodeType;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bnc.object.branch.node.type.BranchNodeCase;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bnc.object.branch.node.type.BranchNodeCaseBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bnc.object.branch.node.type.NonBranchNodeCase;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bnc.object.branch.node.type.NonBranchNodeCaseBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.branch.node.object.BranchNodeList;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.classtype.object.ClassType;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.endpoints.object.EndpointsObj;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.exclude.route.object.Xro;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.gc.object.Gc;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.include.route.object.Iro;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.load.balancing.object.LoadBalancing;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.lsp.attributes.Metrics;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.lsp.attributes.MetricsBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.lspa.object.Lspa;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.metric.object.Metric;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.monitoring.object.Monitoring;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.non.branch.node.object.NonBranchNodeList;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.of.object.Of;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.path.key.object.PathKey;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcc.id.req.object.PccIdReq;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pce.id.object.PceId;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.PcreqMessage;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.PcreqMessageBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.MonitoringRequest;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.MonitoringRequestBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.Requests;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.RequestsBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.Svec;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.SvecBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.monitoring.request.PceIdList;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.monitoring.request.PceIdListBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.PathKeyExpansionBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.SegmentComputation;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.SegmentComputationBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.P2mp;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.P2mpBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.P2p;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.P2pBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.EndpointRroPair;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.EndpointRroPairBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.MetricBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.endpoint.rro.pair.Rros;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.endpoint.rro.pair.RrosBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.endpoint.rro.pair.rros.route.object.ReportedRouteObjectCase;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.endpoint.rro.pair.rros.route.object.ReportedRouteObjectCaseBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.endpoint.rro.pair.rros.route.object.SecondaryReportedRouteObjectCase;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.endpoint.rro.pair.rros.route.object.SecondaryReportedRouteObjectCaseBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.iro.bnc.choice.BncCase;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.iro.bnc.choice.BncCaseBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.iro.bnc.choice.IroCase;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.iro.bnc.choice.IroCaseBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2p.ReportedRoute;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.reoptimization.bandwidth.object.ReoptimizationBandwidth;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.reported.route.object.Rro;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.rp.object.Rp;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.secondary.reported.route.object.Srro;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.vendor.information.objects.VendorInformationObject;
  84
  85 /**
  86  * Parser for {@link Pcreq}
  87  */
  88 public class PCEPRequestMessageParser extends AbstractMessageParser {
  89
  90     public static final int TYPE = 3;
  91
  92     public PCEPRequestMessageParser(final ObjectRegistry registry) {
  93         super(registry);
  94     }
  95
  96     @Override
  97     public void serializeMessage(final Message message, final ByteBuf out) {
  98         Preconditions.checkArgument(message instanceof Pcreq, "Wrong instance of Message. Passed instance of %s. Need Pcreq.", message.getClass());
  99         final PcreqMessage msg = ((Pcreq) message).getPcreqMessage();
 100         Preconditions.checkArgument(msg.getRequests() != null && !msg.getRequests().isEmpty(), "Requests cannot be null or empty.");
 101         final ByteBuf buffer = Unpooled.buffer();
 102         if (msg.getMonitoringRequest() != null) {
 103             serializeMonitoringRequest(msg.getMonitoringRequest(), buffer);
 104         }
 105         if (msg.getSvec() != null) {
 106             serializeSvec(msg, buffer);
 107         }
 108         serializeRequest(msg, buffer);
 109         MessageUtil.formatMessage(TYPE, buffer, out);
 110     }
 111
 112     protected void serializeRequest(final PcreqMessage msg, final ByteBuf buffer) {
 113         for (final Requests req : msg.getRequests()) {
 114             serializeObject(req.getRp(), buffer);
 115             serializeVendorInformationObjects(req.getVendorInformationObject(), buffer);
 116             if (req.getPathKeyExpansion() != null) {
 117                 serializeObject(req.getPathKeyExpansion().getPathKey(), buffer);
 118             }
 119             if (req.getSegmentComputation() != null) {
 120                 final SegmentComputation sc = req.getSegmentComputation();
 121                 if (sc.getP2p() != null) {
 122                     serializeP2P(buffer, sc.getP2p());
 123                 }
 124                 if (sc.getP2mp() != null) {
 125                     serializeP2MP(buffer, sc.getP2mp());
 126                 }
 127             }
 128         }
 129     }
 130
 131     protected void serializeSvec(final PcreqMessage msg, final ByteBuf buffer) {
 132         for (final Svec s : msg.getSvec()) {
 133             serializeObject(s.getSvec(), buffer);
 134             serializeObject(s.getOf(), buffer);
 135             serializeObject(s.getGc(), buffer);
 136             serializeObject(s.getXro(), buffer);
 137             if (s.getMetric() != null) {
 138                 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.svec.Metric m : s.getMetric()) {
 139                     serializeObject(m.getMetric(), buffer);
 140                 }
 141             }
 142             serializeVendorInformationObjects(s.getVendorInformationObject(), buffer);
 143         }
 144     }
 145
 146     protected void serializeP2P(final ByteBuf buffer, final P2p p2p) {
 147         serializeObject(p2p.getEndpointsObj(), buffer);
 148         serializeVendorInformationObjects(p2p.getVendorInformationObject(), buffer);
 149         if (p2p.getReportedRoute() != null) {
 150             final ReportedRoute rr = p2p.getReportedRoute();
 151             if (rr != null) {
 152                 serializeObject(rr.getRro(), buffer);
 153                 serializeObject(rr.getReoptimizationBandwidth(), buffer);
 154             }
 155         }
 156         serializeObject(p2p.getLoadBalancing(), buffer);
 157         serializeObject(p2p.getLspa(), buffer);
 158         serializeObject(p2p.getBandwidth(), buffer);
 159         if (p2p.getMetrics() != null) {
 160             for (final Metrics m : p2p.getMetrics()) {
 161                 serializeObject(m.getMetric(), buffer);
 162             }
 163         }
 164         serializeObject(p2p.getIro(), buffer);
 165         serializeObject(p2p.getRro(), buffer);
 166         serializeObject(p2p.getXro(), buffer);
 167         serializeObject(p2p.getOf(), buffer);
 168         serializeObject(p2p.getClassType(), buffer);
 169     }
 170
 171     protected void serializeP2MP(final ByteBuf buffer, final P2mp p2mp) {
 172         final List<EndpointRroPair> endpointRroPairList = p2mp.getEndpointRroPair();
 173         if (endpointRroPairList == null || endpointRroPairList.isEmpty()) {
 174             throw new IllegalStateException("At least one instance of Endpoint must be present in P2MP Request!");
 175         }
 176         endpointRroPairList.forEach(pair -> {
 177             serializeObject(pair.getEndpointsObj(), buffer);
 178             pair.getRros().forEach(rro -> {
 179                 if (rro.getRouteObject() instanceof ReportedRouteObjectCase) {
 180                     serializeObject(((ReportedRouteObjectCase) rro.getRouteObject()).getRro(), buffer);
 181                 } else if (rro.getRouteObject() instanceof SecondaryReportedRouteObjectCase) {
 182                     serializeObject(((SecondaryReportedRouteObjectCase) rro.getRouteObject()).getSrro(), buffer);
 183                 }
 184             });
 185             serializeObject(pair.getReoptimizationBandwidth(), buffer);
 186         });
 187         serializeObject(p2mp.getOf(), buffer);
 188         serializeObject(p2mp.getLspa(), buffer);
 189         serializeObject(p2mp.getBandwidth(), buffer);
 190         if (p2mp.getMetric() != null) {
 191             for (final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq
 192                     .message.pcreq.message.requests.segment.computation.p2mp.Metric m : p2mp.getMetric()) {
 193                 serializeObject(m.getMetric(), buffer);
 194             }
 195         }
 196         if (p2mp.getIroBncChoice() instanceof IroCase) {
 197             serializeObject(((IroCase) p2mp.getIroBncChoice()).getIro(), buffer);
 198         } else if (p2mp.getIroBncChoice() instanceof BncCase) {
 199             final BranchNodeType branchNodeType = ((BncCase) p2mp.getIroBncChoice()).getBranchNodeType();
 200             if (branchNodeType instanceof BranchNodeCase) {
 201                 serializeObject(((BranchNodeCase) branchNodeType).getBranchNodeList(), buffer);
 202             } else if (branchNodeType instanceof NonBranchNodeCase) {
 203                 serializeObject(((NonBranchNodeCase) branchNodeType).getNonBranchNodeList(), buffer);
 204             }
 205         }
 206         serializeObject(p2mp.getLoadBalancing(), buffer);
 207     }
 208
 209     protected void serializeMonitoringRequest(final MonitoringRequest monReq, final ByteBuf out) {
 210         serializeObject(monReq.getMonitoring(), out);
 211         serializeObject(monReq.getPccIdReq(), out);
 212         if (monReq.getPceIdList() != null) {
 213             for (final PceIdList pceId : monReq.getPceIdList()) {
 214                 serializeObject(pceId.getPceId(), out);
 215             }
 216         }
 217     }
 218
 219     @Override
 220     protected Message validate(final List<Object> objects, final List<Message> errors) throws PCEPDeserializerException {
 221         Preconditions.checkArgument(objects != null, "Passed list can't be null.");
 222         if (objects.isEmpty()) {
 223             throw new PCEPDeserializerException("Pcrep message cannot be empty.");
 224         }
 225         final PcreqMessageBuilder mBuilder = new PcreqMessageBuilder();
 226         mBuilder.setMonitoringRequest(getMonitoring(objects));
 227         final List<Svec> svecs = getSvecs(objects);
 228         if (!svecs.isEmpty()) {
 229             mBuilder.setSvec(svecs);
 230         }
 231         final List<Requests> requests = getRequests(objects, errors);
 232         if (requests != null) {
 233             mBuilder.setRequests(requests);
 234         } else {
 235             errors.add(createErrorMsg(PCEPErrors.RP_MISSING, Optional.empty()));
 236         }
 237         if (!objects.isEmpty()) {
 238             throw new PCEPDeserializerException("Unprocessed Objects: " + objects);
 239         }
 240         return new PcreqBuilder().setPcreqMessage(mBuilder.build()).build();
 241     }
 242
 243     protected List<Svec> getSvecs(final List<Object> objects) {
 244         final List<Svec> svecList = new ArrayList<>();
 245         while (!objects.isEmpty()) {
 246             final SvecBuilder sBuilder = new SvecBuilder();
 247             final Svec svecComp = getValidSvec(sBuilder, objects);
 248             if (svecComp == null) {
 249                 break;
 250             }
 251             svecList.add(svecComp);
 252         }
 253         return svecList;
 254     }
 255
 256     protected List<Requests> getRequests(final List<Object> objects, final List<Message> errors) {
 257         final List<Requests> requests = new ArrayList<>();
 258         while (!objects.isEmpty()) {
 259             final RequestsBuilder rBuilder = new RequestsBuilder();
 260             Rp rpObj = null;
 261             if (!(objects.get(0) instanceof Rp)) {
 262                 // if RP obj is missing return error only
 263                 errors.add(createErrorMsg(PCEPErrors.RP_MISSING, Optional.empty()));
 264                 return null;
 265             }
 266             rpObj = (Rp) objects.get(0);
 267             objects.remove(0);
 268             if (!rpObj.isProcessingRule()) {
 269                 errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET, Optional.empty()));
 270             } else {
 271                 rBuilder.setRp(rpObj);
 272             }
 273             final List<VendorInformationObject> vendorInfo = addVendorInformationObjects(objects);
 274             if (!vendorInfo.isEmpty()) {
 275                 rBuilder.setVendorInformationObject(vendorInfo);
 276             }
 277             // expansion
 278             if (rpObj.isPathKey() && objects.get(0) instanceof PathKey) {
 279                 rBuilder.setPathKeyExpansion(new PathKeyExpansionBuilder().setPathKey((PathKey) objects.get(0)).build());
 280             }
 281
 282             if (objects.isEmpty() || !(objects.get(0) instanceof EndpointsObj)) {
 283                 errors.add(createErrorMsg(PCEPErrors.END_POINTS_MISSING, Optional.of(rpObj)));
 284                 return null;
 285             }
 286
 287             if (!rpObj.isP2mp()) {
 288                 // p2p
 289                 final P2pBuilder p2pBuilder = new P2pBuilder();
 290                 final EndpointsObj ep = (EndpointsObj) objects.get(0);
 291                 objects.remove(0);
 292                 if (!ep.isProcessingRule()) {
 293                     errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET, Optional.of(rpObj)));
 294                 } else {
 295                     p2pBuilder.setEndpointsObj(ep);
 296                 }
 297
 298                 final SegmentComputation segm = getP2PSegmentComputation(p2pBuilder, objects, errors, rpObj);
 299                 if (segm != null) {
 300                     rBuilder.setSegmentComputation(segm);
 301                 }
 302             } else {
 303                 // p2mp
 304                 final SegmentComputation segm = getP2MPSegmentComputation(objects, errors, rpObj);
 305                 if (segm != null) {
 306                     rBuilder.setSegmentComputation(segm);
 307                 }
 308             }
 309             requests.add(rBuilder.build());
 310         }
 311         return requests;
 312     }
 313
 314     protected SegmentComputation getP2PSegmentComputation(final P2pBuilder builder,
 315                                                           final List<Object> objects,
 316                                                           final List<Message> errors,
 317                                                           final Rp rp) {
 318         final List<Metrics> metrics = new ArrayList<>();
 319         final List<VendorInformationObject> viObjects = new ArrayList<>();
 320
 321         P2PState p2PState = P2PState.INIT;
 322         while (!objects.isEmpty() && p2PState != P2PState.END) {
 323             p2PState = insertP2PObject(p2PState, objects, viObjects, builder, metrics, errors, rp);
 324             if (!p2PState.equals(P2PState.END)) {
 325                 objects.remove(0);
 326             }
 327         }
 328         if (!metrics.isEmpty()) {
 329             builder.setMetrics(metrics);
 330         }
 331         if (!viObjects.isEmpty()) {
 332             builder.setVendorInformationObject(viObjects);
 333         }
 334
 335         if (rp.isReoptimization()
 336                 && builder.getBandwidth() != null
 337                 && !builder.getReportedRoute().getReoptimizationBandwidth().getBandwidth().equals(
 338                         new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.Bandwidth(new byte[] { 0 }))
 339                 && builder.getReportedRoute().getRro() == null) {
 340             errors.add(createErrorMsg(PCEPErrors.RRO_MISSING, Optional.of(rp)));
 341             return null;
 342         }
 343         return new SegmentComputationBuilder().setP2p(builder.build()).build();
 344     }
 345
 346     private static P2PState insertP2PObject(final P2PState p2PState,
 347                                             final List<Object> objects,
 348                                             final List<VendorInformationObject> viObjects,
 349                                             final P2pBuilder builder,
 350                                             final List<Metrics> metrics,
 351                                             final List<Message> errors,
 352                                             final Rp rp) {
 353         final Object obj = objects.get(0);
 354         switch (p2PState) {
 355         case INIT:
 356             if (obj instanceof Rro) {
 357                 builder.setRro((Rro) obj);
 358                 objects.remove(0);
 359                 final Object nextObj = objects.get(0);
 360                 if (nextObj instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types
 361                         .rev181109.reoptimization.bandwidth.object.ReoptimizationBandwidth) {
 362                     builder.setReoptimizationBandwidth((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns
 363                             .yang.pcep.types.rev181109.reoptimization.bandwidth.object
 364                             .ReoptimizationBandwidth) nextObj);
 365                 }
 366                 return P2PState.REPORTED_IN;
 367             }
 368         case REPORTED_IN:
 369             if (obj instanceof VendorInformationObject) {
 370                 viObjects.add((VendorInformationObject) obj);
 371                 return P2PState.REPORTED_IN;
 372             }
 373         case VENDOR_INFO_LIST:
 374             if (obj instanceof LoadBalancing) {
 375                 builder.setLoadBalancing((LoadBalancing) obj);
 376                 return P2PState.LOAD_BIN;
 377             }
 378         case LOAD_BIN:
 379             if (obj instanceof Lspa) {
 380                 builder.setLspa((Lspa) obj);
 381                 return P2PState.LSPA_IN;
 382             }
 383         case LSPA_IN:
 384             if (obj instanceof Bandwidth) {
 385                 builder.setBandwidth((Bandwidth) obj);
 386                 return P2PState.BANDWIDTH_IN;
 387             }
 388         case BANDWIDTH_IN:
 389             if (obj instanceof Metric) {
 390                 metrics.add(new MetricsBuilder().setMetric((Metric) obj).build());
 391                 return P2PState.BANDWIDTH_IN;
 392             }
 393         case METRIC_IN:
 394             if (obj instanceof Iro) {
 395                 builder.setIro((Iro) obj);
 396                 return P2PState.IRO_IN;
 397             }
 398         case IRO_IN:
 399             if (obj instanceof Rro) {
 400                 builder.setRro((Rro) obj);
 401                 return P2PState.RRO_IN;
 402             }
 403         case RRO_IN:
 404             if (obj instanceof Xro) {
 405                 builder.setXro((Xro) obj);
 406                 return P2PState.XRO_IN;
 407             }
 408         case XRO_IN:
 409             if (obj instanceof Of) {
 410                 builder.setOf((Of) obj);
 411                 return P2PState.OF_IN;
 412             }
 413         case OF_IN:
 414             if (obj instanceof ClassType) {
 415                 final ClassType classType = (ClassType) obj;
 416                 if (!classType.isProcessingRule()) {
 417                     errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET, Optional.of(rp)));
 418                 } else {
 419                     builder.setClassType(classType);
 420                 }
 421                 return P2PState.CT_IN;
 422             }
 423         case CT_IN:
 424         case END:
 425             return P2PState.END;
 426         default:
 427             return p2PState;
 428         }
 429     }
 430
 431     private enum P2PState {
 432         INIT, REPORTED_IN, VENDOR_INFO_LIST, LOAD_BIN, LSPA_IN, BANDWIDTH_IN, METRIC_IN, IRO_IN, RRO_IN, XRO_IN, OF_IN, CT_IN, END
 433     }
 434
 435     protected SegmentComputation  getP2MPSegmentComputation(final List<Object> objects,
 436                                                             final List<Message> errors,
 437                                                             final Rp rp) {
 438         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.Metric> metrics =
 439                 new ArrayList<>();
 440         final P2mpBuilder builder = new P2mpBuilder();
 441         final List<EndpointRroPair> epRros = new ArrayList<>();
 442
 443         P2MPState state = P2MPState.RP;
 444         while (!objects.isEmpty() && state != P2MPState.END) {
 445             state = insertP2MPObject(state, objects, builder, epRros, metrics, errors, rp);
 446             if (!state.equals(P2MPState.END)) {
 447                 objects.remove(0);
 448             }
 449         }
 450         if (!epRros.isEmpty()) {
 451             builder.setEndpointRroPair(epRros);
 452         }
 453         if (!metrics.isEmpty()) {
 454             builder.setMetric(metrics);
 455         }
 456
 457         if (rp.isReoptimization() && builder.getBandwidth() != null) {
 458             if (!isValidReoptimizationRro(epRros) || !isValidReoptimizationBandwidth(epRros)) {
 459                 errors.add(createErrorMsg(PCEPErrors.RRO_MISSING, Optional.of(rp)));
 460             }
 461         }
 462
 463         return new SegmentComputationBuilder().setP2mp(builder.build()).build();
 464     }
 465
 466     private boolean isValidReoptimizationRro(final List<EndpointRroPair> epRros) {
 467         for (EndpointRroPair epRro : epRros) {
 468             if (epRro.getRros() == null || epRro.getRros().isEmpty()) {
 469                 return false;
 470             }
 471         }
 472         return true;
 473     }
 474
 475     private boolean isValidReoptimizationBandwidth(final List<EndpointRroPair> epRros) {
 476         for (EndpointRroPair epRro : epRros) {
 477             if (epRro.getReoptimizationBandwidth() == null) {
 478                 return false;
 479             }
 480         }
 481         return true;
 482     }
 483
 484     private static P2MPState insertP2MPObject(final P2MPState p2MPState,
 485                                               final List<Object> objects,
 486                                               final P2mpBuilder builder,
 487                                               final List<EndpointRroPair> epRros,
 488                                               final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcreq.message.pcreq.message.requests.segment.computation.p2mp.Metric> metrics,
 489                                               final List<Message> errors,
 490                                               final Rp rp) {
 491         final Object obj = objects.get(0);
 492         switch (p2MPState) {
 493             case RP:
 494                 if (obj instanceof EndpointsObj) {
 495                     final EndpointRroPairBuilder rroPairBuilder = new EndpointRroPairBuilder();
 496                     if (obj.isProcessingRule()) {
 497                         rroPairBuilder.setEndpointsObj((EndpointsObj) obj);
 498                     } else {
 499                         errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET, Optional.of(rp)));
 500                     }
 501                     epRros.add(rroPairBuilder.setRros(new ArrayList<>()).build());
 502                     return P2MPState.ENDPOINT;
 503                 }
 504             case ENDPOINT:
 505                 if (obj instanceof Rro || obj instanceof Srro) {
 506                     if (obj.isProcessingRule()) {
 507                         final int lastIndex = epRros.size() - 1;
 508                         final EndpointRroPair endpointRroPair = epRros.get(lastIndex);
 509                         final List<Rros> rros = endpointRroPair.getRros();
 510                         if (obj instanceof Rro) {
 511                             rros.add(new RrosBuilder()
 512                                     .setRouteObject(new ReportedRouteObjectCaseBuilder().setRro((Rro) obj)
 513                                             .build()).build());
 514                         } else {
 515                             rros.add(new RrosBuilder()
 516                                     .setRouteObject(new SecondaryReportedRouteObjectCaseBuilder().setSrro((Srro) obj)
 517                                             .build()).build());
 518                         }
 519                         epRros.remove(lastIndex);
 520                         epRros.add(lastIndex, new EndpointRroPairBuilder(endpointRroPair).setRros(rros).build());
 521                     }
 522                     return P2MPState.ENDPOINT;
 523                 }
 524             case RRO_SRRO:
 525                 if (obj instanceof ReoptimizationBandwidth) {
 526                     final int lastIndex = epRros.size() - 1;
 527                     final EndpointRroPair endpointRroPair = epRros.get(lastIndex);
 528                     epRros.remove(lastIndex);
 529                     epRros.add(lastIndex, new EndpointRroPairBuilder(endpointRroPair)
 530                             .setReoptimizationBandwidth((ReoptimizationBandwidth) obj)
 531                             .build());
 532                     return P2MPState.BANDWIDTH;
 533                 }
 534             case BANDWIDTH:
 535                 if (obj instanceof EndpointsObj) {
 536                     return P2MPState.RP;
 537                 }
 538                 if (obj instanceof Of) {
 539                     builder.setOf((Of) obj);
 540                     return P2MPState.OF_IN;
 541                 }
 542             case OF_IN:
 543                 if (obj instanceof Lspa) {
 544                     builder.setLspa((Lspa) obj);
 545                     return P2MPState.LSPA_IN;
 546                 }
 547             case LSPA_IN:
 548                 if (obj instanceof Bandwidth) {
 549                     builder.setBandwidth((Bandwidth) obj);
 550                     return P2MPState.BANDWIDTH_IN;
 551                 }
 552             case BANDWIDTH_IN:
 553                 if (obj instanceof Metric) {
 554                     metrics.add(new MetricBuilder().setMetric((Metric) obj).build());
 555                     return P2MPState.BANDWIDTH_IN;
 556                 }
 557             case METRIC_IN:
 558                 if (obj instanceof Iro) {
 559                     builder.setIroBncChoice(new IroCaseBuilder().setIro((Iro) obj).build());
 560                     return P2MPState.IRO_BNC_IN;
 561                 }
 562                 if (obj instanceof BranchNodeList) {
 563                     builder.setIroBncChoice(new BncCaseBuilder().setBranchNodeType(new BranchNodeCaseBuilder()
 564                             .setBranchNodeList((BranchNodeList) obj).build()).build());
 565                     return P2MPState.IRO_BNC_IN;
 566                 }
 567                 if (obj instanceof NonBranchNodeList) {
 568                     builder.setIroBncChoice(new BncCaseBuilder().setBranchNodeType(new NonBranchNodeCaseBuilder()
 569                             .setNonBranchNodeList((NonBranchNodeList) obj).build()).build());
 570                     return P2MPState.IRO_BNC_IN;
 571                 }
 572             case IRO_BNC_IN:
 573                 if (obj instanceof LoadBalancing) {
 574                     builder.setLoadBalancing((LoadBalancing) obj);
 575                     return P2MPState.LOAD_BIN;
 576                 }
 577             case LOAD_BIN:
 578             case END:
 579             default:
 580                 return P2MPState.END;
 581         }
 582     }
 583
 584     private enum P2MPState {
 585         RP, ENDPOINT, RRO_SRRO, BANDWIDTH, OF_IN, LSPA_IN, BANDWIDTH_IN, METRIC_IN, IRO_BNC_IN, LOAD_BIN, END
 586     }
 587
 588     private static Svec getValidSvec(final SvecBuilder builder, final List<Object> objects) {
 589         Preconditions.checkArgument(objects != null && !objects.isEmpty(), "Passed list can't be null or empty.");
 590
 591         if (objects.get(0) instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.svec.object.Svec) {
 592             builder.setSvec((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.svec.object.Svec) objects.get(0));
 593             objects.remove(0);
 594         } else {
 595             return null;
 596         }
 597
 598         final List<Metrics> metrics = new ArrayList<>();
 599         final List<VendorInformationObject> viObjects = new ArrayList<>();
 600
 601         Object obj = null;
 602         SvecState state = SvecState.INIT;
 603         while (!objects.isEmpty() && !state.equals(SvecState.END)) {
 604             obj = objects.get(0);
 605             state = insertP2PObject(state, obj, builder, metrics, viObjects);
 606             if (!state.equals(SvecState.END)) {
 607                 objects.remove(0);
 608             }
 609         }
 610         if (!viObjects.isEmpty()) {
 611             builder.setVendorInformationObject(viObjects);
 612         }
 613         return builder.build();
 614     }
 615
 616     private static SvecState insertP2PObject(final SvecState state, final Object obj, final SvecBuilder builder,
 617                                              final List<Metrics> metrics, final List<VendorInformationObject> viObjects) {
 618         switch (state) {
 619         case INIT:
 620             if (obj instanceof Of) {
 621                 builder.setOf((Of) obj);
 622                 return SvecState.OF_IN;
 623             }
 624         case OF_IN:
 625             if (obj instanceof Gc) {
 626                 builder.setGc((Gc) obj);
 627                 return SvecState.GC_IN;
 628             }
 629         case GC_IN:
 630             if (obj instanceof Xro) {
 631                 builder.setXro((Xro) obj);
 632                 return SvecState.XRO_IN;
 633             }
 634         case XRO_IN:
 635             if (obj instanceof Metric) {
 636                 metrics.add(new MetricsBuilder().setMetric((Metric) obj).build());
 637                 return SvecState.XRO_IN;
 638             }
 639         case METRIC_IN:
 640             if (obj instanceof VendorInformationObject) {
 641                 viObjects.add((VendorInformationObject) obj);
 642                 return SvecState.METRIC_IN;
 643             }
 644         case VENDOR_INFO:
 645         case END:
 646             return SvecState.END;
 647         default:
 648             return state;
 649         }
 650     }
 651
 652     private enum SvecState {
 653         INIT, OF_IN, GC_IN, XRO_IN, METRIC_IN, VENDOR_INFO, END
 654     }
 655
 656     protected MonitoringRequest getMonitoring(final List<Object> objects) {
 657         final MonitoringRequestBuilder builder = new MonitoringRequestBuilder();
 658         if (!objects.isEmpty() && objects.get(0) instanceof Monitoring) {
 659             builder.setMonitoring((Monitoring) objects.get(0));
 660             objects.remove(0);
 661         } else {
 662             return null;
 663         }
 664         if (!objects.isEmpty() && objects.get(0) instanceof PccIdReq) {
 665             builder.setPccIdReq((PccIdReq) objects.get(0));
 666             objects.remove(0);
 667         }
 668         final List<PceIdList> pceIdList = new ArrayList<>();
 669         while (!objects.isEmpty() && objects.get(0) instanceof PceId) {
 670             pceIdList.add(new PceIdListBuilder().setPceId((PceId) objects.get(0)).build());
 671             objects.remove(0);
 672         }
 673         if (!pceIdList.isEmpty()) {
 674             builder.setPceIdList(pceIdList);
 675         }
 676         return builder.build();
 677     }
 678 }