import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
import com.google.common.primitives.UnsignedBytes;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;
import java.util.Arrays;
import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
import org.opendaylight.protocol.bgp.parser.BGPError;
import org.opendaylight.protocol.bgp.parser.BGPParsingException;
* Parser for BGP Open message.
*/
public final class BGPOpenMessageParser implements MessageParser, MessageSerializer {
-
public static final int TYPE = 1;
private static final Logger LOG = LoggerFactory.getLogger(BGPOpenMessageParser.class);
LOG.trace("Started serializing open message: {}", msg);
final Open open = (Open) msg;
- final Map<byte[], Integer> optParams = Maps.newHashMap();
-
- int optParamsLength = 0;
-
+ final ByteBuf paramsBuffer = Unpooled.buffer();
if (open.getBgpParameters() != null) {
for (final BgpParameters param : open.getBgpParameters()) {
- final byte[] p = this.reg.serializeParameter(param);
- if (p != null) {
- optParams.put(p, p.length);
- optParamsLength += p.length;
- }
+ this.reg.serializeParameter(param, paramsBuffer);
}
}
final ByteBuf msgBody = Unpooled.buffer();
msgBody.writeShort(open.getHoldTimer());
msgBody.writeBytes(Ipv4Util.bytesForAddress(open.getBgpIdentifier()));
- msgBody.writeByte(optParamsLength);
+ msgBody.writeByte(paramsBuffer.writerIndex());
+ msgBody.writeBytes(paramsBuffer);
- if (optParams != null) {
- for (final Entry<byte[], Integer> entry : optParams.entrySet()) {
- // FIXME: to be switched to ByteBuf later
- msgBody.writeBytes(entry.getKey());
- }
- }
MessageUtil.formatMessage(TYPE, msgBody, bytes);
LOG.trace("Open message serialized to: {}", ByteBufUtil.hexDump(bytes));
}
import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.buffer.Unpooled;
import java.util.Arrays;
import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
}
@Override
- public byte[] serializeParameter(final BgpParameters parameter) {
+ public void serializeParameter(final BgpParameters parameter, ByteBuf byteAggregator) {
final CParameters cap = parameter.getCParameters();
LOG.trace("Started serializing BGP Capability: {}", cap);
- byte[] bytes = this.reg.serializeCapability(cap);
+ ByteBuf bytes = Unpooled.wrappedBuffer(this.reg.serializeCapability(cap));
if (bytes == null) {
throw new IllegalArgumentException("Unhandled capability class" + cap.getImplementedInterface());
}
- LOG.trace("BGP capability serialized to: {}", Arrays.toString(bytes));
+ LOG.trace("BGP capability serialized to: {}", ByteBufUtil.hexDump(bytes));
- return ParameterUtil.formatParameter(TYPE, bytes);
+ ParameterUtil.formatParameter(TYPE, bytes,byteAggregator);
}
}
public interface ParameterRegistry {
BgpParameters parseParameter(int parameterType, ByteBuf bytes) throws BGPParsingException, BGPDocumentedException;
- byte[] serializeParameter(BgpParameters parameter);
+ void serializeParameter(BgpParameters parameter, ByteBuf bytes);
}
*/
package org.opendaylight.protocol.bgp.parser.spi;
+import io.netty.buffer.ByteBuf;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.open.BgpParameters;
public interface ParameterSerializer {
- byte[] serializeParameter(BgpParameters parameter);
+ void serializeParameter(BgpParameters parameter, ByteBuf byteAggregator);
}
*/
package org.opendaylight.protocol.bgp.parser.spi;
-import com.google.common.primitives.UnsignedBytes;
+import io.netty.buffer.ByteBuf;
public final class ParameterUtil {
- private static final int HEADER_SIZE = 2;
-
private ParameterUtil() {
}
- public static byte[] formatParameter(final int type, final byte[] value) {
- final byte[] bytes = new byte[HEADER_SIZE + value.length];
- bytes[0] = UnsignedBytes.checkedCast(type);
- bytes[1] = UnsignedBytes.checkedCast(value.length);
- System.arraycopy(value, 0, bytes, HEADER_SIZE, value.length);
- return bytes;
+ public static void formatParameter(final int type, final ByteBuf value, final ByteBuf byteAggregator) {
+ byteAggregator.writeByte(type);
+ byteAggregator.writeByte(value.writerIndex());
+ byteAggregator.writeBytes(value);
}
}
return parser.parseParameter(buffer);
}
- @Override
- public byte[] serializeParameter(final BgpParameters parameter) {
+ public void serializeParameter(final BgpParameters parameter, ByteBuf bytes) {
final ParameterSerializer serializer = this.handlers.getSerializer(parameter.getImplementedInterface());
if (serializer == null) {
- return null;
+ return;
}
- return serializer.serializeParameter(parameter);
+ serializer.serializeParameter(parameter,bytes);
}
}
UnsignedBytes.MAX_VALUE, UnsignedBytes.MAX_VALUE, UnsignedBytes.MAX_VALUE, UnsignedBytes.MAX_VALUE, UnsignedBytes.MAX_VALUE,
UnsignedBytes.MAX_VALUE, UnsignedBytes.MAX_VALUE, UnsignedBytes.MAX_VALUE, 0, 23, 3, 32, 5, 14, 21 };
ByteBuf formattedMessage = Unpooled.buffer();
- MessageUtil.formatMessage(3, Unpooled.wrappedBuffer(new byte[]{32, 5, 14, 21}),formattedMessage);
+ MessageUtil.formatMessage(3, Unpooled.wrappedBuffer(new byte[] { 32, 5, 14, 21 }), formattedMessage);
assertArrayEquals(result, ByteArray.getAllBytes(formattedMessage));
}
@Test
public void testParameterUtil() {
final byte[] result = new byte[] { 1, 2, 4, 8 };
- assertArrayEquals(result, ParameterUtil.formatParameter(1, new byte[] { 4, 8 }));
+ ByteBuf aggregator = Unpooled.buffer();
+ ParameterUtil.formatParameter(1, Unpooled.wrappedBuffer(new byte[] { 4, 8 }), aggregator);
+ assertArrayEquals(result, ByteArray.getAllBytes(aggregator));
}
}