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