package org.opendaylight.protocol.pcep.crabbe.initiated00;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated._00.rev140113.Pcinitiate;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof Pcinitiate)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance of " + message.getClass()
+ ". Needed PcinitiateMessage.");
}
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated._00.rev140113.pcinitiate.message.PcinitiateMessage init = ((Pcinitiate) message).getPcinitiateMessage();
+ ByteBuf buffer = Unpooled.buffer();
for (final Requests req : init.getRequests()) {
buffer.writeBytes(serializeObject(req.getEndpointsObj()));
buffer.writeBytes(serializeObject(req.getLspa()));
}
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.ietf.stateful02;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.impl.message.PCEPReplyMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.stateful._02.rev140110.Replies1;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof Pcrep)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance of " + message.getClass()
+ ". Nedded PcrepMessage.");
if (repMsg.getReplies() == null || repMsg.getReplies().isEmpty()) {
throw new IllegalArgumentException("Replies cannot be null or empty.");
}
+ ByteBuf buffer = Unpooled.buffer();
for (final Replies reply : repMsg.getReplies()) {
if (reply.getRp() == null) {
throw new IllegalArgumentException("Reply must contain RP object.");
}
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.ietf.stateful02;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof Pcrpt)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance of " + message.getClass()
+ ". Nedded PcrptMessage.");
}
final Pcrpt msg = (Pcrpt) message;
final List<Reports> reports = msg.getPcrptMessage().getReports();
+ ByteBuf buffer = Unpooled.buffer();
for (final Reports report : reports) {
buffer.writeBytes(serializeObject(report.getLsp()));
final Path p = report.getPath();
}
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.ietf.stateful02;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof Pcupd)) {
throw new IllegalArgumentException("Wrong instance of PCEPMessage. Passed instance of " + message.getClass()
+ ". Nedded PcupdMessage.");
}
final Pcupd msg = (Pcupd) message;
final List<Updates> updates = msg.getPcupdMessage().getUpdates();
+ ByteBuf buffer = Unpooled.buffer();
for (final Updates update : updates) {
buffer.writeBytes(serializeObject(update.getLsp()));
final Path p = update.getPath();
}
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
builder.setRequests(reqs);
assertEquals(new PcinitiateBuilder().setPcinitiateMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
final ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcinitiateBuilder().setPcinitiateMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
package org.opendaylight.protocol.pcep.ietf.initiated00;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.Pcinitiate;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof PcinitiateMessage)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance of " + message.getClass()
+ ". Needed PcinitiateMessage.");
}
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.crabbe.initiated.rev131126.pcinitiate.message.PcinitiateMessage init = ((Pcinitiate) message).getPcinitiateMessage();
+ ByteBuf buffer = Unpooled.buffer();
for (final Requests req : init.getRequests()) {
buffer.writeBytes(serializeObject(req.getSrp()));
buffer.writeBytes(serializeObject(req.getLsp()));
buffer.writeBytes(serializeObject(req.getIro()));
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.ietf.stateful07;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.protocol.pcep.impl.message.PCEPErrorMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof PcerrMessage)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance " + message.getClass()
+ ". Nedded ErrorMessage.");
if (err.getErrors() == null || err.getErrors().isEmpty()) {
throw new IllegalArgumentException("Errors should not be empty.");
}
+ ByteBuf buffer = Unpooled.buffer();
if (err.getErrorType() instanceof RequestCase) {
final List<Rps> rps = ((RequestCase) err.getErrorType()).getRequest().getRps();
if (err.getErrorType() instanceof SessionCase) {
buffer.writeBytes(serializeObject(((SessionCase) err.getErrorType()).getSession().getOpen()));
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.ietf.stateful07;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof Pcrpt)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance of " + message.getClass()
+ ". Nedded PcrptMessage.");
}
final Pcrpt msg = (Pcrpt) message;
final List<Reports> reports = msg.getPcrptMessage().getReports();
+ ByteBuf buffer = Unpooled.buffer();
for (final Reports report : reports) {
if (report.getSrp() != null) {
buffer.writeBytes(serializeObject(report.getSrp()));
}
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.ietf.stateful07;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof Pcupd)) {
throw new IllegalArgumentException("Wrong instance of PCEPMessage. Passed instance of " + message.getClass()
+ ". Nedded PcupdMessage.");
}
final Pcupd msg = (Pcupd) message;
final List<Updates> updates = msg.getPcupdMessage().getUpdates();
+ ByteBuf buffer = Unpooled.buffer();
for (final Updates update : updates) {
buffer.writeBytes(serializeObject(update.getSrp()));
buffer.writeBytes(serializeObject(update.getLsp()));
}
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
builder.setOpen(b.build());
assertEquals(new OpenBuilder().setOpenMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
final ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(new OpenBuilder().setOpenMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
@Test
public void testKeepAliveMsg() throws IOException, PCEPDeserializerException {
- final byte[] result = new byte[] {};
+ final byte[] result = new byte[] {32, 2, 0, 4};
final PCEPKeepAliveMessageParser parser = new PCEPKeepAliveMessageParser(this.objectRegistry);
final KeepaliveBuilder builder = new KeepaliveBuilder().setKeepaliveMessage(new KeepaliveMessageBuilder().build());
- assertEquals(builder.build(), parser.parseMessage(result, Collections.<Message> emptyList()));
+ assertEquals(builder.build(), parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
final ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(builder.build(), buf);
- assertArrayEquals(result, buf.array());
+ assertArrayEquals(result, buf.readBytes(buf.readableBytes()).array());
}
@Test
final CloseBuilder builder = new CloseBuilder().setCCloseMessage(new CCloseMessageBuilder().setCClose(
new CCloseBuilder().setIgnore(false).setProcessingRule(false).setReason((short) 5).build()).build());
- assertEquals(builder.build(), parser.parseMessage(result, Collections.<Message> emptyList()));
+ assertEquals(builder.build(), parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
final ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(builder.build(), buf);
assertArrayEquals(result, buf.array());
builder.setRequests(reqs1);
assertEquals(new PcreqBuilder().setPcreqMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcreqBuilder().setPcreqMessage(builder.build()).build(), buf);
this.svec).build()));
assertEquals(new PcreqBuilder().setPcreqMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcreqBuilder().setPcreqMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setReplies(replies1);
assertEquals(new PcrepBuilder().setPcrepMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcrepBuilder().setPcrepMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setReplies(replies2);
assertEquals(new PcrepBuilder().setPcrepMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcrepBuilder().setPcrepMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setReplies(replies3);
assertEquals(new PcrepBuilder().setPcrepMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcrepBuilder().setPcrepMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setReplies(replies4);
assertEquals(new PcrepBuilder().setPcrepMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcrepBuilder().setPcrepMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setUpdates(updates);
assertEquals(new PcupdBuilder().setPcupdMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcupdBuilder().setPcupdMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setUpdates(updates1);
assertEquals(new PcupdBuilder().setPcupdMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcupdBuilder().setPcupdMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setReports(reports);
assertEquals(new PcrptBuilder().setPcrptMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcrptBuilder().setPcrptMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setReports(reports1);
assertEquals(new PcrptBuilder().setPcrptMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcrptBuilder().setPcrptMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setReports(reports2);
assertEquals(new PcrptBuilder().setPcrptMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcrptBuilder().setPcrptMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setReports(reports3);
assertEquals(new PcrptBuilder().setPcrptMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcrptBuilder().setPcrptMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setRequests(reqs);
assertEquals(new PcinitiateBuilder().setPcinitiateMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
final ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcinitiateBuilder().setPcinitiateMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setNotifications(nots);
assertEquals(new PcntfBuilder().setPcntfMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
final ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcntfBuilder().setPcntfMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setErrorType(new SessionCaseBuilder().setSession(new SessionBuilder().setOpen(this.open).build()).build());
assertEquals(new PcerrBuilder().setPcerrMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
ByteBuf buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcerrBuilder().setPcerrMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
builder.setErrorType(new RequestCaseBuilder().setRequest(new RequestBuilder().setRps(rps).build()).build());
assertEquals(new PcerrBuilder().setPcerrMessage(builder.build()).build(),
- parser.parseMessage(result, Collections.<Message> emptyList()));
+ parser.parseMessage(ByteArray.cutBytes(result, 4), Collections.<Message> emptyList()));
buf = Unpooled.buffer(result.length);
parser.serializeMessage(new PcerrBuilder().setPcerrMessage(builder.build()).build(), buf);
assertArrayEquals(result, buf.array());
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.protocol.pcep.spi.MessageHandlerRegistry;
+import org.opendaylight.protocol.pcep.spi.MessageRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
+import org.opendaylight.protocol.pcep.spi.PCEPMessageConstants;
import org.opendaylight.protocol.util.ByteArray;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
import org.slf4j.Logger;
private static final int LENGTH_SIZE = 2;
- private final MessageHandlerRegistry registry;
+ private final MessageRegistry registry;
- public PCEPByteToMessageDecoder(final MessageHandlerRegistry registry) {
+ public PCEPByteToMessageDecoder(final MessageRegistry registry) {
this.registry = Preconditions.checkNotNull(registry);
}
throw new PCEPDeserializerException("Body size " + msgBody.length + " does not match header size "
+ (msgLength - PCEPMessageConstants.COMMON_HEADER_LENGTH));
}
-
- final Message msg = this.registry.getMessageParser(type).parseMessage(msgBody, errors);
- LOG.debug("Message was parsed. {}", msg);
- return msg;
+ return this.registry.parseMessage(type, msgBody, errors);
}
}
import org.opendaylight.protocol.framework.SessionNegotiatorFactory;
import org.opendaylight.protocol.pcep.PCEPDispatcher;
import org.opendaylight.protocol.pcep.PCEPSessionListener;
-import org.opendaylight.protocol.pcep.spi.MessageHandlerRegistry;
+import org.opendaylight.protocol.pcep.spi.MessageRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
import com.google.common.base.Preconditions;
/**
* Creates an instance of PCEPDispatcherImpl, gets the default selector and opens it.
*/
- public PCEPDispatcherImpl(final MessageHandlerRegistry registry,
+ public PCEPDispatcherImpl(final MessageRegistry registry,
final SessionNegotiatorFactory<Message, PCEPSessionImpl, PCEPSessionListener> negotiatorFactory, EventLoopGroup bossGroup,
EventLoopGroup workerGroup) {
super(bossGroup, workerGroup);
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelOutboundHandler;
-import org.opendaylight.protocol.pcep.spi.MessageHandlerRegistry;
+import org.opendaylight.protocol.pcep.spi.MessageRegistry;
import com.google.common.base.Preconditions;
* PCEP specific factory for protocol inbound/outbound handlers.
*/
public final class PCEPHandlerFactory {
- private final MessageHandlerRegistry registry;
+ private final MessageRegistry registry;
private final ChannelOutboundHandler encoder;
- public PCEPHandlerFactory(final MessageHandlerRegistry registry) {
+ public PCEPHandlerFactory(final MessageRegistry registry) {
this.registry = Preconditions.checkNotNull(registry);
this.encoder = new PCEPMessageToByteEncoder(registry);
}
package org.opendaylight.protocol.pcep.impl;
import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
-import org.opendaylight.protocol.pcep.spi.MessageHandlerRegistry;
-import org.opendaylight.protocol.pcep.spi.MessageSerializer;
+import org.opendaylight.protocol.pcep.spi.MessageRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.base.Preconditions;
-import com.google.common.primitives.UnsignedBytes;
/**
*
*/
@Sharable
public final class PCEPMessageToByteEncoder extends MessageToByteEncoder<Message> {
+
private static final Logger LOG = LoggerFactory.getLogger(PCEPMessageToByteEncoder.class);
- private static final int VERSION_SF_LENGTH = 3;
- private final MessageHandlerRegistry registry;
- public PCEPMessageToByteEncoder(final MessageHandlerRegistry registry) {
+ private final MessageRegistry registry;
+
+ public PCEPMessageToByteEncoder(final MessageRegistry registry) {
this.registry = Preconditions.checkNotNull(registry);
}
@Override
protected void encode(final ChannelHandlerContext ctx, final Message msg, final ByteBuf out) throws Exception {
Preconditions.checkNotNull(msg);
- LOG.debug("Sent to encode : {}", msg);
-
- final ByteBuf body = Unpooled.buffer();
- final MessageSerializer serializer = this.registry.getMessageSerializer(msg);
- LOG.trace("Choosen serializer {}", serializer);
- serializer.serializeMessage(msg, body);
-
- final int msgLength = body.readableBytes() + PCEPMessageConstants.COMMON_HEADER_LENGTH;
- final byte[] header = new byte[] {
- UnsignedBytes.checkedCast(PCEPMessageConstants.PCEP_VERSION << (Byte.SIZE - VERSION_SF_LENGTH)),
- UnsignedBytes.checkedCast(serializer.getMessageType()),
- UnsignedBytes.checkedCast(msgLength / 256),
- UnsignedBytes.checkedCast(msgLength % 256)
- };
- Preconditions.checkState(header.length == PCEPMessageConstants.COMMON_HEADER_LENGTH);
- out.writeBytes(header);
- out.writeBytes(body);
+ this.registry.serializeMessage(msg, out);
+ LOG.debug("Encoded : {}", msg);
}
}
package org.opendaylight.protocol.pcep.impl.message;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Close;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof CloseMessage)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance of " + message.getClass()
+ ". Nedded CloseMessage.");
if (close.getCClose() == null) {
throw new IllegalArgumentException("Close Object must be present in Close Message.");
}
+ ByteBuf buffer = Unpooled.buffer();
buffer.writeBytes(serializeObject(close.getCClose()));
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.impl.message;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof PcerrMessage)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance " + message.getClass()
+ ". Nedded ErrorMessage.");
if (err.getErrors() == null || err.getErrors().isEmpty()) {
throw new IllegalArgumentException("Errors should not be empty.");
}
+ ByteBuf buffer = Unpooled.buffer();
if (err.getErrorType() instanceof RequestCase) {
final List<Rps> rps = ((RequestCase) err.getErrorType()).getRequest().getRps();
for (final Rps r : rps) {
if (err.getErrorType() instanceof SessionCase) {
buffer.writeBytes(serializeObject(((SessionCase) err.getErrorType()).getSession().getOpen()));
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.impl.message;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.KeepaliveBuilder;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof KeepaliveMessage)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance of " + message.getClass()
+ ". Need KeepaliveMessage.");
}
- buffer.writeBytes(new byte[0]);
+ MessageUtil.formatMessage(TYPE, Unpooled.EMPTY_BUFFER, out);
}
@Override
package org.opendaylight.protocol.pcep.impl.message;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof PcntfMessage)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance of " + message.getClass()
+ ". Needed PcntfMessage.");
}
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcntf.message.PcntfMessage msg = ((PcntfMessage) message).getPcntfMessage();
+ ByteBuf buffer = Unpooled.buffer();
for (final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcntf.message.pcntf.message.Notifications n : msg.getNotifications()) {
if (n.getRps() != null && !n.getRps().isEmpty()) {
for (final Rps rps : n.getRps()) {
}
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.impl.message;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.OpenBuilder;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof OpenMessage)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance " + message.getClass() + ". Needed OpenMessage.");
}
if (open.getOpen() == null) {
throw new IllegalArgumentException("Open Object must be present in Open Message.");
}
-
+ ByteBuf buffer = Unpooled.buffer();
buffer.writeBytes(serializeObject(open.getOpen()));
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.impl.message;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof Pcrep)) {
throw new IllegalArgumentException("Wrong instance of Message. Passed instance of " + message.getClass()
+ ". Nedded PcrepMessage.");
if (repMsg.getReplies() == null || repMsg.getReplies().isEmpty()) {
throw new IllegalArgumentException("Replies cannot be null or empty.");
}
+ ByteBuf buffer = Unpooled.buffer();
for (final Replies reply : repMsg.getReplies()) {
if (reply.getRp() == null) {
throw new IllegalArgumentException("Reply must contain RP object.");
}
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
@Override
package org.opendaylight.protocol.pcep.impl.message;
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageUtil;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.PCEPErrors;
}
@Override
- public void serializeMessage(final Message message, final ByteBuf buffer) {
+ public void serializeMessage(final Message message, final ByteBuf out) {
if (!(message instanceof Pcreq)) {
throw new IllegalArgumentException("Wrong instance of PCEPMessage. Passed instance of " + message.getClass()
+ ". Needed PcrepMessage.");
if (msg.getRequests() == null || msg.getRequests().isEmpty()) {
throw new IllegalArgumentException("Requests cannot be null or empty.");
}
+ ByteBuf buffer = Unpooled.buffer();
for (final Requests req : msg.getRequests()) {
buffer.writeBytes(serializeObject(req.getRp()));
if (req.getPathKeyExpansion() != null) {
}
}
}
+ MessageUtil.formatMessage(TYPE, buffer, out);
}
protected void serializeP2P(final ByteBuf buffer, final P2p p2p) {
&& builder.getBandwidth() != null
&& builder.getReportedRoute().getBandwidth().getBandwidth() != new BandwidthBuilder().setBandwidth(
new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.Bandwidth(new byte[] { 0 })).build()
- && builder.getReportedRoute().getRro() == null) {
+ && builder.getReportedRoute().getRro() == null) {
errors.add(createErrorMsg(PCEPErrors.RRO_MISSING, rp));
return null;
}
+++ /dev/null
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.protocol.pcep.spi;
-
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
-
-public interface MessageHandlerRegistry {
- MessageParser getMessageParser(int messageType);
- MessageSerializer getMessageSerializer(Message message);
-}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.pcep.spi;
+
+import io.netty.buffer.ByteBuf;
+
+import java.util.List;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
+
+public interface MessageRegistry {
+ /**
+ * Finds parser for given message type in the registry. Delegates parsing to found parser.
+ * @param type message type, key in parser registry
+ * @param buffer message raw binary value to be parsed
+ * @param errors list of error messages, that is filled during parsing
+ * @return null if the parser for this message could not be found
+ * @throws PCEPDeserializerException if the parsing did not succeed
+ */
+ Message parseMessage(int messageType, byte[] buffer, List<Message> errors) throws PCEPDeserializerException;
+
+ /**
+ * Find serializer for given message. Delegates parsing to found serializer.
+ * @param message to be parsed
+ * @param buffer byte buffer that will be filled with serialized message
+ */
+ void serializeMessage(Message message, ByteBuf buffer);
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.pcep.spi;
+
+import io.netty.buffer.ByteBuf;
+
+import com.google.common.base.Preconditions;
+import com.google.common.primitives.UnsignedBytes;
+
+public class MessageUtil {
+
+ private static final int VERSION_SF_LENGTH = 3;
+
+ private MessageUtil() {
+ }
+
+ public static void formatMessage(final int messageType, final ByteBuf body, ByteBuf out) {
+ final int msgLength = body.readableBytes();
+ final byte[] header = new byte[] {
+ UnsignedBytes.checkedCast(PCEPMessageConstants.PCEP_VERSION << (Byte.SIZE - VERSION_SF_LENGTH)),
+ UnsignedBytes.checkedCast(messageType),
+ UnsignedBytes.checkedCast((msgLength + PCEPMessageConstants.COMMON_HEADER_LENGTH) / 256),
+ UnsignedBytes.checkedCast((msgLength + PCEPMessageConstants.COMMON_HEADER_LENGTH) % 256)
+ };
+ Preconditions.checkState(header.length == PCEPMessageConstants.COMMON_HEADER_LENGTH);
+ out.writeBytes(header);
+ out.writeBytes(body);
+ }
+}
LabelRegistry getLabelHandlerRegistry();
- MessageHandlerRegistry getMessageHandlerRegistry();
+ MessageRegistry getMessageHandlerRegistry();
ObjectRegistry getObjectHandlerRegistry();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.protocol.pcep.impl;
+package org.opendaylight.protocol.pcep.spi;
/**
*
*/
-final class PCEPMessageConstants {
+public final class PCEPMessageConstants {
/**
* Length of the common message header, in bytes.
*/
*/
package org.opendaylight.protocol.pcep.spi.pojo;
+import io.netty.buffer.ByteBuf;
+
+import java.util.List;
+
import org.opendaylight.protocol.concepts.HandlerRegistry;
-import org.opendaylight.protocol.pcep.spi.MessageHandlerRegistry;
import org.opendaylight.protocol.pcep.spi.MessageParser;
+import org.opendaylight.protocol.pcep.spi.MessageRegistry;
import org.opendaylight.protocol.pcep.spi.MessageSerializer;
+import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.util.Values;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import com.google.common.base.Preconditions;
-public final class SimpleMessageHandlerRegistry implements MessageHandlerRegistry {
+public final class SimpleMessageRegistry implements MessageRegistry {
private final HandlerRegistry<DataContainer, MessageParser, MessageSerializer> handlers = new HandlerRegistry<>();
}
@Override
- public MessageParser getMessageParser(final int messageType) {
+ public Message parseMessage(int messageType, byte[] buffer, List<Message> errors) throws PCEPDeserializerException {
Preconditions.checkArgument(messageType >= 0 && messageType <= Values.UNSIGNED_BYTE_MAX_VALUE);
- return this.handlers.getParser(messageType);
+ final MessageParser parser = this.handlers.getParser(messageType);
+ if (parser == null) {
+ return null;
+ }
+ return parser.parseMessage(buffer, errors);
}
@Override
- public MessageSerializer getMessageSerializer(final Message message) {
- return this.handlers.getSerializer(message.getImplementedInterface());
+ public void serializeMessage(Message message, ByteBuf buffer) {
+ final MessageSerializer serializer = this.handlers.getSerializer(message.getImplementedInterface());
+ if (serializer == null) {
+ return;
+ }
+ serializer.serializeMessage(message, buffer);
}
}
import org.opendaylight.protocol.pcep.spi.LabelRegistry;
import org.opendaylight.protocol.pcep.spi.LabelParser;
import org.opendaylight.protocol.pcep.spi.LabelSerializer;
-import org.opendaylight.protocol.pcep.spi.MessageHandlerRegistry;
+import org.opendaylight.protocol.pcep.spi.MessageRegistry;
import org.opendaylight.protocol.pcep.spi.MessageParser;
import org.opendaylight.protocol.pcep.spi.MessageSerializer;
import org.opendaylight.protocol.pcep.spi.ObjectRegistry;
@ThreadSafe
public class SimplePCEPExtensionProviderContext implements PCEPExtensionProviderContext {
private final SimpleLabelRegistry labelReg = new SimpleLabelRegistry();
- private final SimpleMessageHandlerRegistry msgReg = new SimpleMessageHandlerRegistry();
+ private final SimpleMessageRegistry msgReg = new SimpleMessageRegistry();
private final SimpleObjectRegistry objReg = new SimpleObjectRegistry();
private final SimpleEROSubobjectRegistry eroSubReg = new SimpleEROSubobjectRegistry();
private final SimpleRROSubobjectRegistry rroSubReg = new SimpleRROSubobjectRegistry();
}
@Override
- public final MessageHandlerRegistry getMessageHandlerRegistry() {
+ public final MessageRegistry getMessageHandlerRegistry() {
return this.msgReg;
}