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