regs.add(context.registerObjectParser(unreachIpv4Parser));
regs.add(context.registerObjectParser(unreachIpv6Parser));
- final PCEPUnreachDestinationSerializer unreachSerializer= new PCEPUnreachDestinationSerializer();
+ final PCEPUnreachDestinationSerializer unreachSerializer = new PCEPUnreachDestinationSerializer();
regs.add(context.registerObjectSerializer(UnreachDestinationObj.class, unreachSerializer));
final PCEPP2MPEndPointsIpv4ObjectParser endpoints4Pp2mparser = new PCEPP2MPEndPointsIpv4ObjectParser();
}
}
if (p2mp.getIroBncChoice() instanceof IroCase) {
- serializeObject(((IroCase) p2mp.getIroBncChoice()).getIro(), buffer );
+ serializeObject(((IroCase) p2mp.getIroBncChoice()).getIro(), buffer);
} else if (p2mp.getIroBncChoice() instanceof BncCase) {
final BranchNodeType branchNodeType = ((BncCase) p2mp.getIroBncChoice()).getBranchNodeType();
if (branchNodeType instanceof BranchNodeCase) {
return P2MPState.BANDWIDTH_IN;
}
case METRIC_IN:
- if (obj instanceof Iro ) {
+ if (obj instanceof Iro) {
builder.setIroBncChoice(new IroCaseBuilder().setIro((Iro) obj).build());
return P2MPState.IRO_BNC_IN;
}
objects.remove(0);
}
final List<PceIdList> pceIdList = new ArrayList<>();
- while(!objects.isEmpty() && objects.get(0) instanceof PceId) {
+ while (!objects.isEmpty() && objects.get(0) instanceof PceId) {
pceIdList.add(new PceIdListBuilder().setPceId((PceId) objects.get(0)).build());
objects.remove(0);
}
}
protected final void serializeSubobject(final List<Subobject> subobjects, final ByteBuf buffer) {
- if(subobjects != null) {
+ if (subobjects != null) {
for (final Subobject subobject : subobjects) {
this.subobjReg.serializeSubobject(subobject, buffer);
}
public void serializeObject(final Object object, final ByteBuf buffer) {
Preconditions.checkArgument(object instanceof ClassType, "Wrong instance of PCEPObject. Passed %s. Needed ClassTypeObject.", object.getClass());
final ByteBuf body = Unpooled.buffer(SIZE);
- body.writeZero(SIZE -1);
+ body.writeZero(SIZE - 1);
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.ClassType classType = ((ClassType) object).getClassType();
Preconditions.checkArgument(classType != null, "ClassType is mandatory.");
writeUnsignedByte(classType.getValue(), body);
@Override
public void serializeObject(final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.Object object, final ByteBuf buffer) {
- Preconditions.checkArgument(object instanceof ReoptimizationBandwidth, "Wrong instance of PCEPObject. Passed " +
- "%s. Needed ReoptimizationBandwidthObject.", object.getClass());
+ Preconditions.checkArgument(object instanceof ReoptimizationBandwidth, "Wrong instance of PCEPObject. Passed "
+ + "%s. Needed ReoptimizationBandwidthObject.", object.getClass());
final ByteBuf body = Unpooled.buffer();
writeFloat32(((ReoptimizationBandwidth) object).getBandwidth(), body);
ObjectUtil.formatSubobject(TYPE, CLASS, object.isProcessingRule(), object.isIgnore(), body, buffer);
@Override
protected final void addVendorInformationTlvs(final TlvsBuilder builder, final List<VendorInformationTlv> tlvs) {
- if(!tlvs.isEmpty()) {
+ if (!tlvs.isEmpty()) {
builder.setVendorInformationTlv(tlvs);
}
}
final short keepalive = bytes.readUnsignedByte();
builder.setKeepalive(keepalive);
final short deadTimer = bytes.readUnsignedByte();
- if(keepalive == 0) {
+ if (keepalive == 0) {
builder.setDeadTimer((short) 0);
} else {
builder.setDeadTimer(deadTimer);
final byte[] res = flags.array();
if (rpObj.getPriority() != null) {
final byte p = UnsignedBytes.checkedCast(rpObj.getPriority());
- res[res.length -1] = (byte) (res[res.length -1] | p);
+ res[res.length - 1] = (byte) (res[res.length - 1] | p);
}
body.writeBytes(res);
Preconditions.checkArgument(rpObj.getRequestId() != null, "RequestId is mandatory");
package org.opendaylight.protocol.pcep.parser.subobject;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeShort;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
package org.opendaylight.protocol.pcep.parser.subobject;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv4Prefix;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
package org.opendaylight.protocol.pcep.parser.subobject;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv6Prefix;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
package org.opendaylight.protocol.pcep.parser.subobject;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv4Prefix;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
package org.opendaylight.protocol.pcep.parser.subobject;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv6Prefix;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv4Prefix;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedByte;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv6Prefix;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedByte;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedByte;
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedInt;
+
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
}
private static State insertObject(final MetricPceBuilder metricPceBuilder, final State state, final Object obj) {
- switch(state) {
+ switch (state) {
case START :
if (obj instanceof ProcTime) {
metricPceBuilder.setProcTime((ProcTime) obj);
private static final Logger LOG = LoggerFactory.getLogger(AbstractPCEPSessionNegotiator.class);
private static final Keepalive KEEPALIVE = new KeepaliveBuilder().setKeepaliveMessage(new KeepaliveMessageBuilder().build()).build();
- private volatile boolean localOK, openRetry, remoteOK;
+ private volatile boolean localOK;
+ private volatile boolean openRetry;
+ private volatile boolean remoteOK;
private volatile State state = State.IDLE;
private Future<?> failTimer;
private Open localPrefs;
private static final Logger LOG = LoggerFactory.getLogger(BasePCEPSessionProposalFactory.class);
private static final int KA_TO_DEADTIMER_RATIO = 4;
- private final int keepAlive, deadTimer;
+ private final int keepAlive;
+ private final int deadTimer;
private final List<PCEPCapability> capabilities;
public BasePCEPSessionProposalFactory(final int deadTimer, final int keepAlive, final List<PCEPCapability> capabilities) {
- if(keepAlive != 0) {
+ if (keepAlive != 0) {
Preconditions.checkArgument(keepAlive >= 1, "Minimum value for keep-alive-timer-value is 1");
- if(deadTimer != 0 && (deadTimer / keepAlive != KA_TO_DEADTIMER_RATIO)) {
+ if (deadTimer != 0 && (deadTimer / keepAlive != KA_TO_DEADTIMER_RATIO)) {
LOG.warn("dead-timer-value should be {} times greater than keep-alive-timer-value", KA_TO_DEADTIMER_RATIO);
}
}
final OpenBuilder oBuilder = new OpenBuilder();
oBuilder.setSessionId((short) sessionId);
oBuilder.setKeepalive((short) BasePCEPSessionProposalFactory.this.keepAlive);
- if(BasePCEPSessionProposalFactory.this.keepAlive == 0) {
+ if (BasePCEPSessionProposalFactory.this.keepAlive == 0) {
oBuilder.setDeadTimer((short) 0);
} else {
oBuilder.setDeadTimer((short) BasePCEPSessionProposalFactory.this.deadTimer);
assertEquals(1, this.msgsSend.size());
assertTrue(this.msgsSend.get(0) instanceof Open);
this.serverSession.handleMessage(this.kaMsg);
- checkEquals(()-> {
+ checkEquals(() -> {
for (final Notification m : this.msgsSend) {
if (m instanceof Pcerr) {
final Errors obj = ((Pcerr) m).getPcerrMessage().getErrors().get(0);
PCEPSessionImpl.setTicker(this.ticker);
session.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
final Queue<Long> qeue = session.getUnknownMessagesTimes();
- CheckTestUtil.checkEquals(()-> assertEquals(1, qeue.size()));
+ CheckTestUtil.checkEquals(() -> assertEquals(1, qeue.size()));
session.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
- CheckTestUtil.checkEquals(()-> assertEquals(2, qeue.size()));
+ CheckTestUtil.checkEquals(() -> assertEquals(2, qeue.size()));
session.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
- CheckTestUtil.checkEquals(()-> assertEquals(3, qeue.size()));
+ CheckTestUtil.checkEquals(() -> assertEquals(3, qeue.size()));
session.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
- CheckTestUtil.checkEquals(()-> assertEquals(4, qeue.size()));
+ CheckTestUtil.checkEquals(() -> assertEquals(4, qeue.size()));
session.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
- CheckTestUtil.checkEquals(()-> assertEquals(3, qeue.size()));
+ CheckTestUtil.checkEquals(() -> assertEquals(3, qeue.size()));
session.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
- CheckTestUtil.checkEquals(()-> assertEquals(3, qeue.size()));
+ CheckTestUtil.checkEquals(() -> assertEquals(3, qeue.size()));
session.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
- CheckTestUtil.checkEquals(()-> assertEquals(4, qeue.size()));
+ CheckTestUtil.checkEquals(() -> assertEquals(4, qeue.size()));
session.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
- CheckTestUtil.checkEquals(()-> assertEquals(5, qeue.size()));
+ CheckTestUtil.checkEquals(() -> assertEquals(5, qeue.size()));
session.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED);
synchronized (client) {
while (client.up) {
client.wait();
}
}
- CheckTestUtil.checkEquals(()-> assertTrue(!client.up));
+ CheckTestUtil.checkEquals(() -> assertTrue(!client.up));
}
private final class TestTicker extends Ticker {
try {
this.session.sessionUp();
Assert.fail(); // expect the exception to be populated
- } catch (final RuntimeException ignored) {}
+ } catch (final RuntimeException ignored) {
+ }
Assert.assertFalse(this.listener.up);
Mockito.verify(this.session).handleException(ArgumentMatchers.any());
Mockito.verify(this.session).sendMessage(ArgumentMatchers.any(CloseMessage.class));
assertArrayEquals(PST_TLV_BYTES, ByteArray.getAllBytes(buff));
}
- @Test(expected=PCEPDeserializerException.class)
+ @Test(expected = PCEPDeserializerException.class)
public void testUnsupportedPSTParser() throws PCEPDeserializerException {
final PathSetupTypeTlvParser parser = new PathSetupTypeTlvParser();
parser.parseTlv(Unpooled.wrappedBuffer(ByteArray.cutBytes(PST_TLV_BYTES_UNSUPPORTED, 4)));
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testUnsupportedPSTSerializer() {
final PathSetupTypeTlvParser parser = new PathSetupTypeTlvParser();
final PathSetupType pstTlv = new PathSetupTypeBuilder().setPst((short) 1).build();
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.P2mpLeaves;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.ProtocolVersion;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.RequestId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bandwidth.object.BandwidthBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bnc.object.branch.node.type.BranchNodeCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.branch.node.object.BranchNodeListBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.close.message.CCloseMessageBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.bandwidth.object.BandwidthBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.close.object.CCloseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.close.object.c.close.TlvsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.endpoints.address.family.Ipv4CaseBuilder;
package org.opendaylight.protocol.pcep.impl;
import static org.junit.Assert.assertNotNull;
+
import javax.net.ssl.SSLContext;
import org.junit.Test;
import org.opendaylight.protocol.pcep.impl.tls.SslContextFactory;
import io.netty.buffer.ByteBuf;
import org.opendaylight.protocol.pcep.parser.tlv.AbstractVendorInformationTlvParser;
-import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.iana.rev130816.EnterpriseNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.vendor.information.EnterpriseSpecificInformation;
Assert.assertEquals(PCEPErrors.BAD_LABEL_VALUE.getErrorValue(), errorObject.getValue().shortValue());
}
- @Test(expected=UnsupportedOperationException.class)
+ @Test(expected = UnsupportedOperationException.class)
public void testPrivateConstructor() throws Throwable {
final Constructor<Util> c = Util.class.getDeclaredConstructor();
c.setAccessible(true);