pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/message/PCEPReplyMessageParser.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.impl.Util;
  17 import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
  18 import org.opendaylight.protocol.pcep.spi.MessageUtil;
  19 import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
  20 import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
  21 import org.opendaylight.protocol.pcep.spi.PCEPErrors;
  22 import org.opendaylight.protocol.pcep.spi.VendorInformationObjectRegistry;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Pcrep;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.PcrepBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Object;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.bandwidth.object.Bandwidth;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.Ero;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.include.route.object.Iro;
  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.monitoring.metrics.MetricPce;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.monitoring.object.Monitoring;
  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.pcc.id.req.object.PccIdReq;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pce.id.object.PceId;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.PcrepMessageBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.Replies;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.RepliesBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.Result;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.FailureCase;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.FailureCaseBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.SuccessCase;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.SuccessCaseBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.failure._case.NoPath;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.success._case.SuccessBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.success._case.success.Paths;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.pcrep.message.replies.result.success._case.success.PathsBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.rp.object.Rp;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.vendor.information.objects.VendorInformationObject;
  53
  54 /**
  55  * Parser for {@link Pcrep}
  56  */
  57 public class PCEPReplyMessageParser extends AbstractMessageParser {
  58
  59     public static final int TYPE = 4;
  60
  61     public PCEPReplyMessageParser(final ObjectRegistry registry, final VendorInformationObjectRegistry viRegistry) {
  62         super(registry, viRegistry);
  63     }
  64
  65     @Override
  66     public void serializeMessage(final Message message, final ByteBuf out) {
  67         Preconditions.checkArgument(message instanceof Pcrep, "Wrong instance of Message. Passed instance of %s. Need Pcrep.", message.getClass());
  68         final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcrep.message.PcrepMessage repMsg = ((Pcrep) message).getPcrepMessage();
  69         if (repMsg.getReplies() == null || repMsg.getReplies().isEmpty()) {
  70             throw new IllegalArgumentException("Replies cannot be null or empty.");
  71         }
  72         final ByteBuf buffer = Unpooled.buffer();
  73         for (final Replies reply : repMsg.getReplies()) {
  74             if (reply.getRp() == null) {
  75                 throw new IllegalArgumentException("Reply must contain RP object.");
  76             }
  77             serializeReply(reply, buffer);
  78         }
  79         MessageUtil.formatMessage(TYPE, buffer, out);
  80     }
  81
  82     protected void serializeReply(final Replies reply, final ByteBuf buffer) {
  83         serializeObject(reply.getRp(), buffer);
  84         serializeMonitoring(reply, buffer);
  85         serializeVendorInformationObjects(reply.getVendorInformationObject(), buffer);
  86         if (reply.getResult() == null) {
  87             return;
  88         }
  89         if (reply.getResult() instanceof FailureCase) {
  90             final FailureCase f = ((FailureCase) reply.getResult());
  91             serializeFailure(f, buffer);
  92             return;
  93         }
  94         final SuccessCase s = (SuccessCase) reply.getResult();
  95         serializeSuccess(s, buffer);
  96         serializeMonitoringMetrics(reply, buffer);
  97     }
  98
  99     private void serializeFailure(final FailureCase f, final ByteBuf buffer) {
 100         if (f == null) {
 101             return;
 102         }
 103         serializeObject(f.getNoPath(), buffer);
 104         serializeObject(f.getLspa(), buffer);
 105         serializeObject(f.getBandwidth(), buffer);
 106         if (f.getMetrics() != null) {
 107             for (final Metrics m : f.getMetrics()) {
 108                 serializeObject(m.getMetric(), buffer);
 109             }
 110         }
 111         serializeObject(f.getIro(), buffer);
 112     }
 113
 114     private void serializeSuccess(final SuccessCase s, final ByteBuf buffer) {
 115         if (s == null || s.getSuccess() == null) {
 116             return;
 117         }
 118         for (final Paths p : s.getSuccess().getPaths()) {
 119             serializeObject(p.getEro(), buffer);
 120             serializeObject(p.getLspa(), buffer);
 121             serializeObject(p.getOf(), buffer);
 122             serializeObject(p.getBandwidth(), buffer);
 123             if (p.getMetrics() != null) {
 124                 for (final Metrics m : p.getMetrics()) {
 125                     serializeObject(m.getMetric(), buffer);
 126                 }
 127             }
 128             serializeObject(p.getIro(), buffer);
 129         }
 130         serializeVendorInformationObjects(s.getSuccess().getVendorInformationObject(), buffer);
 131     }
 132
 133     private void serializeMonitoring(final Replies reply, final ByteBuf buffer) {
 134         serializeObject(reply.getMonitoring(), buffer);
 135         serializeObject(reply.getPccIdReq(), buffer);
 136     }
 137
 138     private void serializeMonitoringMetrics(final Replies reply, final ByteBuf buffer) {
 139         if (reply.getMetricPce() != null) {
 140             for (final MetricPce metricPce : reply.getMetricPce()) {
 141                 serializeMetricPce(metricPce, buffer);
 142             }
 143         }
 144     }
 145
 146     protected void serializeMetricPce(final MetricPce metricPce, final ByteBuf buffer) {
 147         Preconditions.checkArgument(metricPce.getPceId() != null, "PCE-ID must be present.");
 148         serializeObject(metricPce.getPceId(), buffer);
 149         serializeObject(metricPce.getProcTime(), buffer);
 150         serializeObject(metricPce.getOverload(), buffer);
 151     }
 152
 153     @Override
 154     protected Pcrep validate(final List<Object> objects, final List<Message> errors) throws PCEPDeserializerException {
 155         if (objects == null) {
 156             throw new IllegalArgumentException("Passed list can't be null.");
 157         }
 158         if (objects.isEmpty()) {
 159             throw new PCEPDeserializerException("Pcrep message cannot be empty.");
 160         }
 161         final List<Replies> replies = new ArrayList<>();
 162         while (!objects.isEmpty()) {
 163             final Replies r = this.getValidReply(objects, errors);
 164             if (r != null) {
 165                 replies.add(r);
 166             }
 167         }
 168         if (!objects.isEmpty()) {
 169             throw new PCEPDeserializerException("Unprocessed Objects: " + objects);
 170         }
 171         return new PcrepBuilder().setPcrepMessage(new PcrepMessageBuilder().setReplies(replies).build()).build();
 172     }
 173
 174     protected Replies getValidReply(final List<Object> objects, final List<Message> errors) throws PCEPDeserializerException {
 175         if (!(objects.get(0) instanceof Rp)) {
 176             errors.add(createErrorMsg(PCEPErrors.RP_MISSING, Optional.<Rp>absent()));
 177             return null;
 178         }
 179         final Rp rp = (Rp) objects.get(0);
 180         objects.remove(0);
 181         final RepliesBuilder repliesBuilder = new RepliesBuilder();
 182         if (!objects.isEmpty() && objects.get(0) instanceof Monitoring) {
 183             repliesBuilder.setMonitoring((Monitoring) objects.get(0));
 184             objects.remove(0);
 185         }
 186         if (!objects.isEmpty() && objects.get(0) instanceof PccIdReq) {
 187             repliesBuilder.setPccIdReq((PccIdReq) objects.get(0));
 188             objects.remove(0);
 189         }
 190         final List<VendorInformationObject> vendorInfo = addVendorInformationObjects(objects);
 191         Result res = null;
 192         if (!objects.isEmpty()) {
 193             if (objects.get(0) instanceof NoPath) {
 194                 res = handleNoPath((NoPath) objects.get(0), objects);
 195             } else if (objects.get(0) instanceof Ero) {
 196                 res = handleEro((Ero) objects.get(0), objects);
 197             }
 198         }
 199         final List<MetricPce> metricPceList = new ArrayList<>();
 200         if (!objects.isEmpty() && objects.get(0) instanceof PceId) {
 201             while (!objects.isEmpty()) {
 202                 metricPceList.add(Util.validateMonitoringMetrics(objects));
 203             }
 204         }
 205         if (!vendorInfo.isEmpty()) {
 206             repliesBuilder.setVendorInformationObject(vendorInfo);
 207         }
 208         if (!metricPceList.isEmpty()) {
 209             repliesBuilder.setMetricPce(metricPceList);
 210         }
 211         return repliesBuilder.setRp(rp).setResult(res).build();
 212     }
 213
 214     private Result handleNoPath(final NoPath noPath, final List<Object> objects) {
 215         objects.remove(0);
 216         final FailureCaseBuilder builder = new FailureCaseBuilder();
 217         builder.setNoPath(noPath);
 218         while (!objects.isEmpty() && !(objects.get(0) instanceof PceId)) {
 219             this.parseAttributes(builder, objects);
 220         }
 221         return builder.build();
 222     }
 223
 224     private Result handleEro(final Ero ero, final List<Object> objects) {
 225         objects.remove(0);
 226         final SuccessBuilder builder = new SuccessBuilder();
 227         final List<Paths> paths = new ArrayList<>();
 228         final PathsBuilder pBuilder = new PathsBuilder();
 229         pBuilder.setEro(ero);
 230         while (!objects.isEmpty() && !(objects.get(0) instanceof PceId)) {
 231             final List<VendorInformationObject> vendorInfoObjects = addVendorInformationObjects(objects);
 232             if (!vendorInfoObjects.isEmpty()) {
 233                 builder.setVendorInformationObject(vendorInfoObjects);
 234             }
 235             this.parsePath(pBuilder, objects);
 236             paths.add(pBuilder.build());
 237         }
 238         builder.setPaths(paths);
 239         return new SuccessCaseBuilder().setSuccess(builder.build()).build();
 240     }
 241
 242     protected void parseAttributes(final FailureCaseBuilder builder, final List<Object> objects) {
 243         final List<Metrics> pathMetrics = new ArrayList<>();
 244
 245         Object obj;
 246         State state = State.INIT;
 247         while (!objects.isEmpty() && !state.equals(State.END)) {
 248             obj = objects.get(0);
 249
 250             switch (state) {
 251             case INIT:
 252                 state = State.LSPA_IN;
 253                 if (obj instanceof Lspa) {
 254                     builder.setLspa((Lspa) obj);
 255                     break;
 256                 }
 257             case LSPA_IN:
 258                 state = State.BANDWIDTH_IN;
 259                 if (obj instanceof Bandwidth) {
 260                     builder.setBandwidth((Bandwidth) obj);
 261                     break;
 262                 }
 263             case BANDWIDTH_IN:
 264                 state = State.METRIC_IN;
 265                 if (obj instanceof Metric) {
 266                     pathMetrics.add(new MetricsBuilder().setMetric((Metric) obj).build());
 267                     state = State.METRIC_IN;
 268                     break;
 269                 }
 270             case METRIC_IN:
 271                 state = State.IRO_IN;
 272                 if (obj instanceof Iro) {
 273                     builder.setIro((Iro) obj);
 274                     break;
 275                 }
 276             case IRO_IN:
 277                 state = State.END;
 278                 break;
 279             case END:
 280                 break;
 281             default:
 282                 break;
 283             }
 284             if (!state.equals(State.END)) {
 285                 objects.remove(0);
 286             }
 287         }
 288         if (!pathMetrics.isEmpty()) {
 289             builder.setMetrics(pathMetrics);
 290         }
 291     }
 292
 293     protected void parsePath(final PathsBuilder builder, final List<Object> objects) {
 294         final List<Metrics> pathMetrics = new ArrayList<>();
 295
 296         Object obj;
 297         State state = State.INIT;
 298         while (!objects.isEmpty() && !state.equals(State.END)) {
 299             obj = objects.get(0);
 300
 301             switch (state) {
 302             case INIT:
 303                 state = State.LSPA_IN;
 304                 if (obj instanceof Lspa) {
 305                     builder.setLspa((Lspa) obj);
 306                     break;
 307                 }
 308             case LSPA_IN:
 309                 state = State.OF_IN;
 310                 if (obj instanceof Of) {
 311                     builder.setOf((Of) obj);
 312                     break;
 313                 }
 314             case OF_IN:
 315                 state = State.BANDWIDTH_IN;
 316                 if (obj instanceof Bandwidth) {
 317                     builder.setBandwidth((Bandwidth) obj);
 318                     break;
 319                 }
 320             case BANDWIDTH_IN:
 321                 state = State.METRIC_IN;
 322                 if (obj instanceof Metric) {
 323                     pathMetrics.add(new MetricsBuilder().setMetric((Metric) obj).build());
 324                     state = State.BANDWIDTH_IN;
 325                     break;
 326                 }
 327             case METRIC_IN:
 328                 state = State.IRO_IN;
 329                 if (obj instanceof Iro) {
 330                     builder.setIro((Iro) obj);
 331                     break;
 332                 }
 333             case IRO_IN:
 334                 state = State.END;
 335                 break;
 336             case END:
 337                 break;
 338             default:
 339                 break;
 340             }
 341             if (!state.equals(State.END)) {
 342                 objects.remove(0);
 343             }
 344         }
 345         if (!pathMetrics.isEmpty()) {
 346             builder.setMetrics(pathMetrics);
 347         }
 348     }
 349
 350     private enum State {
 351         INIT, LSPA_IN, OF_IN, BANDWIDTH_IN, METRIC_IN, IRO_IN, END
 352     }
 353 }