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.ObjectHandlerRegistry;
  15 import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
  16 import org.opendaylight.protocol.pcep.spi.PCEPErrors;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Pcreq;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.PcreqBuilder;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.bandwidth.object.Bandwidth;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.bandwidth.object.BandwidthBuilder;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.classtype.object.ClassType;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.endpoints.object.EndpointsObj;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.exclude.route.object.Xro;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.gc.object.Gc;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.include.route.object.Iro;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.load.balancing.object.LoadBalancing;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.attributes.Metrics;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.attributes.MetricsBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.lsp.object.Lsp;
  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                 if (p2p.getLsp() != null) {
 151                         buffer.writeBytes(serializeObject(p2p.getLsp()));
 152                 }
 153         }
 154
 155         @Override
 156         protected Message validate(
 157                         final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object> objects,
 158                         final List<Message> errors) throws PCEPDeserializerException {
 159                 if (objects == null) {
 160                         throw new IllegalArgumentException("Passed list can't be null.");
 161                 }
 162
 163                 final List<Requests> requests = Lists.newArrayList();
 164                 final List<Svec> svecList = Lists.newArrayList();
 165                 while (!objects.isEmpty()) {
 166                         final RequestsBuilder rBuilder = new RequestsBuilder();
 167                         Rp rpObj = null;
 168                         if (objects.get(0) instanceof Rp) {
 169                                 rpObj = (Rp) objects.get(0);
 170                                 objects.remove(0);
 171                                 if (!rpObj.isProcessingRule()) {
 172                                         errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET));
 173                                 } else {
 174                                         rBuilder.setRp(rpObj);
 175                                 }
 176                         } else {
 177                                 // if RP obj is missing return error only
 178                                 errors.add(createErrorMsg(PCEPErrors.RP_MISSING));
 179                                 return null;
 180                         }
 181
 182                         // expansion
 183                         if (rpObj.isPathKey()) {
 184                                 if (objects.get(0) instanceof PathKey) {
 185                                         rBuilder.setPathKeyExpansion(new PathKeyExpansionBuilder().setPathKey((PathKey) objects.get(0)).build());
 186                                 }
 187                                 continue;
 188                         }
 189
 190                         final P2pBuilder p2pBuilder = new P2pBuilder();
 191
 192                         if (objects.get(0) instanceof EndpointsObj) {
 193                                 final EndpointsObj ep = (EndpointsObj) objects.get(0);
 194                                 objects.remove(0);
 195                                 if (!ep.isProcessingRule()) {
 196                                         errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET, rpObj));
 197                                 } else {
 198                                         p2pBuilder.setEndpointsObj(ep);
 199                                 }
 200                         } else {
 201                                 errors.add(createErrorMsg(PCEPErrors.END_POINTS_MISSING, rpObj));
 202                                 return null;
 203                         }
 204                         // p2p
 205                         if (!rpObj.isP2mp()) {
 206                                 final SegmentComputation segm = getSegmentComputation(p2pBuilder, objects, errors, rpObj);
 207                                 if (segm != null) {
 208                                         rBuilder.setSegmentComputation(segm);
 209                                 }
 210                         }
 211                         while (!objects.isEmpty()) {
 212                                 final SvecBuilder sBuilder = new SvecBuilder();
 213                                 final Svec svecComp = getValidSvec(sBuilder, objects);
 214                                 if (svecComp == null) {
 215                                         break;
 216                                 }
 217                                 svecList.add(svecComp);
 218                         }
 219                         requests.add(rBuilder.build());
 220                 }
 221
 222                 final PcreqMessageBuilder mBuilder = new PcreqMessageBuilder();
 223                 mBuilder.setRequests(requests);
 224                 if (!svecList.isEmpty()) {
 225                         mBuilder.setSvec(svecList);
 226                 }
 227                 return new PcreqBuilder().setPcreqMessage(mBuilder.build()).build();
 228         }
 229
 230         private SegmentComputation getSegmentComputation(final P2pBuilder builder, final List<Object> objects, final List<Message> errors,
 231                         final Rp rp) {
 232                 final List<Metrics> metrics = Lists.newArrayList();
 233
 234                 State state = State.Init;
 235                 while (!objects.isEmpty() && state != State.End) {
 236                         Object obj = objects.get(0);
 237
 238                         switch (state) {
 239                         case Init:
 240                                 state = State.ReportedIn;
 241                                 if (obj instanceof Rro) {
 242                                         final ReportedRouteBuilder rrBuilder = new ReportedRouteBuilder();
 243                                         rrBuilder.setRro((Rro) obj);
 244                                         objects.remove(0);
 245                                         obj = objects.get(0);
 246                                         if (obj instanceof Bandwidth) {
 247                                                 rrBuilder.setBandwidth((Bandwidth) obj);
 248                                         }
 249                                         break;
 250                                 }
 251                         case ReportedIn:
 252                                 state = State.LoadBIn;
 253                                 if (obj instanceof LoadBalancing) {
 254                                         builder.setLoadBalancing((LoadBalancing) obj);
 255                                         break;
 256                                 }
 257                         case LoadBIn:
 258                                 state = State.LspaIn;
 259                                 if (obj instanceof Lspa) {
 260                                         builder.setLspa((Lspa) obj);
 261                                         break;
 262                                 }
 263                         case LspaIn:
 264                                 state = State.BandwidthIn;
 265                                 if (obj instanceof Bandwidth) {
 266                                         builder.setBandwidth((Bandwidth) obj);
 267                                         break;
 268                                 }
 269                         case BandwidthIn:
 270                                 state = State.MetricIn;
 271                                 if (obj instanceof Metric) {
 272                                         metrics.add(new MetricsBuilder().setMetric((Metric) obj).build());
 273                                         state = State.BandwidthIn;
 274                                         break;
 275                                 }
 276                         case MetricIn:
 277                                 state = State.IroIn;
 278                                 if (obj instanceof Iro) {
 279                                         builder.setIro((Iro) obj);
 280                                         break;
 281                                 }
 282                         case IroIn:
 283                                 state = State.RroIn;
 284                                 if (obj instanceof Rro) {
 285                                         builder.setRro((Rro) obj);
 286                                         break;
 287                                 }
 288                         case RroIn:
 289                                 state = State.XroIn;
 290                                 if (obj instanceof Xro) {
 291                                         builder.setXro((Xro) obj);
 292                                         break;
 293                                 }
 294                         case XroIn:
 295                                 state = State.OfIn;
 296                                 if (obj instanceof Of) {
 297                                         builder.setOf((Of) obj);
 298                                         break;
 299                                 }
 300                         case OfIn:
 301                                 state = State.CtIn;
 302                                 if (obj instanceof ClassType) {
 303                                         final ClassType classType = (ClassType) obj;
 304                                         if (!classType.isProcessingRule()) {
 305                                                 errors.add(createErrorMsg(PCEPErrors.P_FLAG_NOT_SET, rp));
 306                                         } else {
 307                                                 builder.setClassType(classType);
 308                                         }
 309                                         break;
 310                                 }
 311                         case CtIn:
 312                                 state = State.LspIn;
 313                                 if (obj instanceof Lsp) {
 314                                         builder.setLsp((Lsp) obj);
 315                                         break;
 316                                 }
 317                         case LspIn:
 318                                 state = State.End;
 319                                 break;
 320                         case End:
 321                                 break;
 322                         }
 323                         if (!state.equals(State.End)) {
 324                                 objects.remove(0);
 325                         }
 326                 }
 327                 if (!metrics.isEmpty()) {
 328                         builder.setMetrics(metrics);
 329                 }
 330
 331                 if (rp.isReoptimization()
 332                                 && builder.getBandwidth() != null
 333                                 && builder.getReportedRoute().getBandwidth().getBandwidth() != new BandwidthBuilder().setBandwidth(
 334                                                 new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.Bandwidth(new byte[] { 0 })).build()
 335                                 && builder.getReportedRoute().getRro() == null) {
 336                         errors.add(createErrorMsg(PCEPErrors.RRO_MISSING, rp));
 337                         return null;
 338                 }
 339                 return new SegmentComputationBuilder().setP2p(builder.build()).build();
 340         }
 341
 342         private enum State {
 343                 Init, ReportedIn, LoadBIn, LspaIn, BandwidthIn, MetricIn, IroIn, RroIn, XroIn, OfIn, CtIn, LspIn, End
 344         }
 345
 346         private Svec getValidSvec(final SvecBuilder builder, final List<Object> objects) {
 347                 if (objects == null || objects.isEmpty()) {
 348                         throw new IllegalArgumentException("List cannot be null or empty.");
 349                 }
 350
 351                 if (objects.get(0) instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.svec.object.Svec) {
 352                         builder.setSvec((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.svec.object.Svec) objects.get(0));
 353                         objects.remove(0);
 354                 } else {
 355                         return null;
 356                 }
 357
 358                 final List<Metrics> metrics = Lists.newArrayList();
 359
 360                 Object obj = null;
 361                 SvecState state = SvecState.Init;
 362                 while (!objects.isEmpty() && !state.equals(SvecState.End)) {
 363                         obj = objects.get(0);
 364
 365                         switch (state) {
 366                         case Init:
 367                                 state = SvecState.OfIn;
 368                                 if (obj instanceof Of) {
 369                                         builder.setOf((Of) obj);
 370                                         break;
 371                                 }
 372                         case OfIn:
 373                                 state = SvecState.GcIn;
 374                                 if (obj instanceof Gc) {
 375                                         builder.setGc((Gc) obj);
 376                                         break;
 377                                 }
 378                         case GcIn:
 379                                 state = SvecState.XroIn;
 380                                 if (obj instanceof Xro) {
 381                                         builder.setXro((Xro) obj);
 382                                         break;
 383                                 }
 384                         case XroIn:
 385                                 state = SvecState.MetricIn;
 386                                 if (obj instanceof Metric) {
 387                                         metrics.add(new MetricsBuilder().setMetric((Metric) obj).build());
 388                                         state = SvecState.XroIn;
 389                                         break;
 390                                 }
 391                         case MetricIn:
 392                                 state = SvecState.End;
 393                                 break;
 394                         case End:
 395                                 break;
 396                         }
 397                         if (!state.equals(SvecState.End)) {
 398                                 objects.remove(0);
 399                         }
 400                 }
 401                 return builder.build();
 402         }
 403
 404         private enum SvecState {
 405                 Init, OfIn, GcIn, XroIn, MetricIn, End
 406         }
 407
 408         @Override
 409         public int getMessageType() {
 410                 return TYPE;
 411         }
 412 }