pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/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.impl.message;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.base.Preconditions;
  12 import io.netty.buffer.ByteBuf;
  13 import io.netty.buffer.Unpooled;
  14 import java.util.ArrayList;
  15 import java.util.List;
  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.protocol.pcep.spi.VendorInformationObjectRegistry;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Pcreq;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.PcreqBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.bandwidth.object.Bandwidth;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.classtype.object.ClassType;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.endpoints.object.EndpointsObj;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.exclude.route.object.Xro;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.gc.object.Gc;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.include.route.object.Iro;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.load.balancing.object.LoadBalancing;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.attributes.Metrics;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.attributes.MetricsBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lspa.object.Lspa;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.metric.object.Metric;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.of.object.Of;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.path.key.object.PathKey;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.PcreqMessage;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.PcreqMessageBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.Requests;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.RequestsBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.Svec;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.SvecBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.requests.PathKeyExpansionBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.requests.SegmentComputation;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.requests.SegmentComputationBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.requests.segment.computation.P2p;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.requests.segment.computation.P2pBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.requests.segment.computation.p2p.ReportedRoute;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.requests.segment.computation.p2p.ReportedRouteBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.reported.route.object.Rro;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.rp.object.Rp;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.vendor.information.objects.VendorInformationObject;
  55
  56 /**
  57  * Parser for {@link Pcreq}
  58  */
  59 public class PCEPRequestMessageParser extends AbstractMessageParser {
  60
  61     public static final int TYPE = 3;
  62
  63     public PCEPRequestMessageParser(final ObjectRegistry registry, final VendorInformationObjectRegistry viRegistry) {
  64         super(registry, viRegistry);
  65     }
  66
  67     @Override
  68     public void serializeMessage(final Message message, final ByteBuf out) {
  69         Preconditions.checkArgument(message instanceof Pcreq, "Wrong instance of Message. Passed instance of %s. Need Pcreq.", message.getClass());
  70         final PcreqMessage msg = ((Pcreq) message).getPcreqMessage();
  71         if (msg.getRequests() == null || msg.getRequests().isEmpty()) {
  72             throw new IllegalArgumentException("Requests cannot be null or empty.");
  73         }
  74         final ByteBuf buffer = Unpooled.buffer();
  75         for (final Requests req : msg.getRequests()) {
  76             serializeObject(req.getRp(), buffer);
  77             serializeVendorInformationObjects(req.getVendorInformationObject(), buffer);
  78             if (req.getPathKeyExpansion() != null) {
  79                 serializeObject(req.getPathKeyExpansion().getPathKey(), buffer);
  80             }
  81             if (req.getSegmentComputation() != null) {
  82                 final SegmentComputation sc = req.getSegmentComputation();
  83                 if (sc.getP2p() != null) {
  84                     serializeP2P(buffer, sc.getP2p());
  85                 }
  86             }
  87         }
  88         if (msg.getSvec() != null) {
  89             for (final Svec s : msg.getSvec()) {
  90                 serializeObject(s.getSvec(), buffer);
  91                 serializeObject(s.getOf(), buffer);
  92                 serializeObject(s.getGc(), buffer);
  93                 serializeObject(s.getXro(), buffer);
  94                 if (s.getMetric() != null) {
  95                     for (final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcreq.message.pcreq.message.svec.Metric m : s.getMetric()) {
  96                         serializeObject(m.getMetric(), buffer);
  97                     }
  98                 }
  99                 serializeVendorInformationObjects(s.getVendorInformationObject(), buffer);
 100             }
 101         }
 102         MessageUtil.formatMessage(TYPE, buffer, out);
 103     }
 104
 105     protected void serializeP2P(final ByteBuf buffer, final P2p p2p) {
 106         serializeObject(p2p.getEndpointsObj(), buffer);
 107         serializeVendorInformationObjects(p2p.getVendorInformationObject(), buffer);
 108         if (p2p.getReportedRoute() != null) {
 109             final ReportedRoute rr = p2p.getReportedRoute();
 110             if (rr != null) {
 111                 serializeObject(rr.getRro(), buffer);
 112                 serializeObject(rr.getBandwidth(), buffer);
 113             }
 114         }
 115         serializeObject(p2p.getLoadBalancing(), buffer);
 116         serializeObject(p2p.getLspa(), buffer);
 117         serializeObject(p2p.getBandwidth(), buffer);
 118         if (p2p.getMetrics() != null) {
 119             for (final Metrics m : p2p.getMetrics()) {
 120                 serializeObject(m.getMetric(), buffer);
 121             }
 122         }
 123         serializeObject(p2p.getIro(), buffer);
 124         serializeObject(p2p.getRro(), buffer);
 125         serializeObject(p2p.getXro(), buffer);
 126         serializeObject(p2p.getOf(), buffer);
 127         serializeObject(p2p.getClassType(), buffer);
 128     }
 129
 130     @Override
 131     protected Message validate(
 132             final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object> objects,
 133             final List<Message> errors) throws PCEPDeserializerException {
 134         if (objects == null) {
 135             throw new IllegalArgumentException("Passed list can't be null.");
 136         }
 137         final List<Requests> requests = new ArrayList<>();
 138         final List<Svec> svecList = new ArrayList<>();
 139         while (!objects.isEmpty()) {
 140             final RequestsBuilder rBuilder = new RequestsBuilder();
 141             Rp rpObj = null;
 142             if (objects.get(0) instanceof Rp) {
 143                 rpObj = (Rp) objects.get(0);
 144                 objects.remove(0);
 145                 if (!rpObj.isProcessingRule()) {
 146                     errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET, Optional.<Rp>absent()));
 147                 } else {
 148                     rBuilder.setRp(rpObj);
 149                 }
 150             } else {
 151                 // if RP obj is missing return error only
 152                 errors.add(createErrorMsg(PCEPErrors.RP_MISSING, Optional.<Rp>absent()));
 153                 return null;
 154             }
 155             final List<VendorInformationObject> vendorInfo = addVendorInformationObjects(objects);
 156             if (!vendorInfo.isEmpty()) {
 157                 rBuilder.setVendorInformationObject(vendorInfo);
 158             }
 159             // expansion
 160             if (rpObj.isPathKey()) {
 161                 if (objects.get(0) instanceof PathKey) {
 162                     rBuilder.setPathKeyExpansion(new PathKeyExpansionBuilder().setPathKey((PathKey) objects.get(0)).build());
 163                 }
 164                 continue;
 165             }
 166
 167             final P2pBuilder p2pBuilder = new P2pBuilder();
 168
 169             if (objects.get(0) instanceof EndpointsObj) {
 170                 final EndpointsObj ep = (EndpointsObj) objects.get(0);
 171                 objects.remove(0);
 172                 if (!ep.isProcessingRule()) {
 173                     errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET, Optional.of(rpObj)));
 174                 } else {
 175                     p2pBuilder.setEndpointsObj(ep);
 176                 }
 177             } else {
 178                 errors.add(createErrorMsg(PCEPErrors.END_POINTS_MISSING, Optional.of(rpObj)));
 179                 return null;
 180             }
 181             // p2p
 182             if (!rpObj.isP2mp()) {
 183                 final SegmentComputation segm = getSegmentComputation(p2pBuilder, objects, errors, rpObj);
 184                 if (segm != null) {
 185                     rBuilder.setSegmentComputation(segm);
 186                 }
 187             }
 188             while (!objects.isEmpty()) {
 189                 final SvecBuilder sBuilder = new SvecBuilder();
 190                 final Svec svecComp = getValidSvec(sBuilder, objects);
 191                 if (svecComp == null) {
 192                     break;
 193                 }
 194                 svecList.add(svecComp);
 195             }
 196             requests.add(rBuilder.build());
 197         }
 198
 199         final PcreqMessageBuilder mBuilder = new PcreqMessageBuilder();
 200         mBuilder.setRequests(requests);
 201         if (!svecList.isEmpty()) {
 202             mBuilder.setSvec(svecList);
 203         }
 204         return new PcreqBuilder().setPcreqMessage(mBuilder.build()).build();
 205     }
 206
 207     protected SegmentComputation getSegmentComputation(final P2pBuilder builder, final List<Object> objects, final List<Message> errors,
 208             final Rp rp) {
 209         final List<Metrics> metrics = new ArrayList<>();
 210         final List<VendorInformationObject> viObjects = new ArrayList<>();
 211
 212         State state = State.INIT;
 213         while (!objects.isEmpty() && state != State.END) {
 214             Object obj = objects.get(0);
 215
 216             switch (state) {
 217             case INIT:
 218                 state = State.REPORTED_IN;
 219                 if (obj instanceof Rro) {
 220                     final ReportedRouteBuilder rrBuilder = new ReportedRouteBuilder();
 221                     rrBuilder.setRro((Rro) obj);
 222                     objects.remove(0);
 223                     obj = objects.get(0);
 224                     if (obj instanceof Bandwidth) {
 225                         rrBuilder.setBandwidth((Bandwidth) obj);
 226                     }
 227                     break;
 228                 }
 229             case REPORTED_IN:
 230                 state = State.VENDOR_INFO_LIST;
 231                 if (obj instanceof VendorInformationObject) {
 232                     viObjects.add((VendorInformationObject) obj);
 233                     state = State.REPORTED_IN;
 234                     break;
 235                 }
 236             case VENDOR_INFO_LIST:
 237                 state = State.LOAD_BIN;
 238                 if (obj instanceof LoadBalancing) {
 239                     builder.setLoadBalancing((LoadBalancing) obj);
 240                     break;
 241                 }
 242             case LOAD_BIN:
 243                 state = State.LSPA_IN;
 244                 if (obj instanceof Lspa) {
 245                     builder.setLspa((Lspa) obj);
 246                     break;
 247                 }
 248             case LSPA_IN:
 249                 state = State.BANDWIDTH_IN;
 250                 if (obj instanceof Bandwidth) {
 251                     builder.setBandwidth((Bandwidth) obj);
 252                     break;
 253                 }
 254             case BANDWIDTH_IN:
 255                 state = State.METRIC_IN;
 256                 if (obj instanceof Metric) {
 257                     metrics.add(new MetricsBuilder().setMetric((Metric) obj).build());
 258                     state = State.BANDWIDTH_IN;
 259                     break;
 260                 }
 261             case METRIC_IN:
 262                 state = State.IRO_IN;
 263                 if (obj instanceof Iro) {
 264                     builder.setIro((Iro) obj);
 265                     break;
 266                 }
 267             case IRO_IN:
 268                 state = State.RRO_IN;
 269                 if (obj instanceof Rro) {
 270                     builder.setRro((Rro) obj);
 271                     break;
 272                 }
 273             case RRO_IN:
 274                 state = State.XRO_IN;
 275                 if (obj instanceof Xro) {
 276                     builder.setXro((Xro) obj);
 277                     break;
 278                 }
 279             case XRO_IN:
 280                 state = State.OF_IN;
 281                 if (obj instanceof Of) {
 282                     builder.setOf((Of) obj);
 283                     break;
 284                 }
 285             case OF_IN:
 286                 state = State.CT_IN;
 287                 if (obj instanceof ClassType) {
 288                     final ClassType classType = (ClassType) obj;
 289                     if (!classType.isProcessingRule()) {
 290                         errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET, Optional.of(rp)));
 291                     } else {
 292                         builder.setClassType(classType);
 293                     }
 294                     break;
 295                 }
 296             case CT_IN:
 297                 state = State.END;
 298                 break;
 299             case END:
 300                 break;
 301             default:
 302                 break;
 303             }
 304             if (!state.equals(State.END)) {
 305                 objects.remove(0);
 306             }
 307         }
 308         if (!metrics.isEmpty()) {
 309             builder.setMetrics(metrics);
 310         }
 311         if (!viObjects.isEmpty()) {
 312             builder.setVendorInformationObject(viObjects);
 313         }
 314
 315         if (rp.isReoptimization()
 316                 && builder.getBandwidth() != null
 317                 && !builder.getReportedRoute().getBandwidth().getBandwidth().equals(
 318                         new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.Bandwidth(new byte[] { 0 }))
 319                 && builder.getReportedRoute().getRro() == null) {
 320             errors.add(createErrorMsg(PCEPErrors.RRO_MISSING, Optional.of(rp)));
 321             return null;
 322         }
 323         return new SegmentComputationBuilder().setP2p(builder.build()).build();
 324     }
 325
 326     private enum State {
 327         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
 328     }
 329
 330     private Svec getValidSvec(final SvecBuilder builder, final List<Object> objects) {
 331         if (objects == null || objects.isEmpty()) {
 332             throw new IllegalArgumentException("List cannot be null or empty.");
 333         }
 334         if (!(objects.get(0) instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.svec.object.Svec)) {
 335             return null;
 336         }
 337         builder.setSvec((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.svec.object.Svec) objects.get(0));
 338         objects.remove(0);
 339
 340         final List<Metrics> metrics = new ArrayList<>();
 341         final List<VendorInformationObject> viObjects = new ArrayList<>();
 342
 343         Object obj = null;
 344         SvecState state = SvecState.INIT;
 345         while (!objects.isEmpty() && !state.equals(SvecState.END)) {
 346             obj = objects.get(0);
 347
 348             switch (state) {
 349             case INIT:
 350                 state = SvecState.OF_IN;
 351                 if (obj instanceof Of) {
 352                     builder.setOf((Of) obj);
 353                     break;
 354                 }
 355             case OF_IN:
 356                 state = SvecState.GC_IN;
 357                 if (obj instanceof Gc) {
 358                     builder.setGc((Gc) obj);
 359                     break;
 360                 }
 361             case GC_IN:
 362                 state = SvecState.XRO_IN;
 363                 if (obj instanceof Xro) {
 364                     builder.setXro((Xro) obj);
 365                     break;
 366                 }
 367             case XRO_IN:
 368                 state = SvecState.METRIC_IN;
 369                 if (obj instanceof Metric) {
 370                     metrics.add(new MetricsBuilder().setMetric((Metric) obj).build());
 371                     state = SvecState.XRO_IN;
 372                     break;
 373                 }
 374             case METRIC_IN:
 375                 state = SvecState.VENDOR_INFO;
 376                 if (obj instanceof VendorInformationObject) {
 377                     viObjects.add((VendorInformationObject) obj);
 378                     state = SvecState.METRIC_IN;
 379                     break;
 380                 }
 381             case VENDOR_INFO:
 382                 state = SvecState.END;
 383                 break;
 384             case END:
 385                 break;
 386             default:
 387                 break;
 388             }
 389             if (!state.equals(SvecState.END)) {
 390                 objects.remove(0);
 391             }
 392         }
 393         if (!viObjects.isEmpty()) {
 394             builder.setVendorInformationObject(viObjects);
 395         }
 396         return builder.build();
 397     }
 398
 399     private enum SvecState {
 400         INIT, OF_IN, GC_IN, XRO_IN, METRIC_IN, VENDOR_INFO, END
 401     }
 402 }