Reorder the modifiers to comply with the Java Language Specification.
Move this trailing comment on the previous empty line
Add a default case to this switch
Rename this interface name to match the regular expression
Missing curly brace.
...
Change-Id: Icb397909f33b5dcccc99d48bc602d4bc9213fd35
Signed-off-by: Claudio D. Gasparini <cgaspari@cisco.com>
package org.opendaylight.protocol.bmp.impl.app;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.net.InetAddresses;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
@GuardedBy("this")
private synchronized void tearDown() {
- if (this.session == null) { // the session has been teared down before
+ // the session has been teared down before
+ if (this.session == null) {
return;
}
// we want to display remote router's IP here, as sometimes this.session.close() is already
}
private Optional<BmpRouterPeer> getPeer(final PeerId peerId) {
- return Optional.fromNullable(this.peers.get(peerId));
+ return Optional.ofNullable(this.peers.get(peerId));
}
private static PeerId getPeerId(final PeerHeader peerHeader) {
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.extended.community.ExtendedCommunity;
public class Layer2AttributesExtCom extends AbstractExtendedCommunities {
- private static final int SUBTYPE = 4; // TODO: TBD BY IANA
+ // TODO: TBD BY IANA
+ private static final int SUBTYPE = 4;
private static final int FLAGS_SIZE = 16;
private static final int PRIMARY_PE_OFFSET = 15;
private static final int CONTROL_WORD_OFFSET = 13;
private static final NodeIdentifier EVPN_CHOICE_NID = new NodeIdentifier(EvpnChoice.QNAME);
@FunctionalInterface
- private interface extractionInterface {
+ private interface ExtractionInterface {
EvpnChoice check(EvpnRegistry reg, ChoiceNode cont);
}
public static EvpnDestination extractEvpnDestination(final DataContainerNode<? extends PathArgument> evpnChoice) {
- return extractDestination(evpnChoice, (reg, cont) -> reg.serializeEvpnModel(cont));
+ return extractDestination(evpnChoice, EvpnRegistry::serializeEvpnModel);
}
- private static EvpnDestination extractDestination(final DataContainerNode<? extends PathArgument> evpnChoice, final extractionInterface extract) {
+ private static EvpnDestination extractDestination(final DataContainerNode<? extends PathArgument> evpnChoice, final ExtractionInterface extract) {
final EvpnRegistry reg = SimpleEvpnNlriRegistry.getInstance();
final ChoiceNode cont = (ChoiceNode) evpnChoice.getChild(EVPN_CHOICE_NID).get();
final EvpnChoice evpnValue = extract.check(reg, cont);
}
public static EvpnDestination extractRouteKeyDestination(final DataContainerNode<? extends PathArgument> evpnChoice) {
- return extractDestination(evpnChoice, (reg, cont) -> reg.serializeEvpnRouteKey(cont));
+ return extractDestination(evpnChoice, EvpnRegistry::serializeEvpnRouteKey);
}
@Override
*
* @param <N> numeric operand type
*/
-abstract public class AbstractNumericOperandParser<N> extends AbstractOperandParser<NumericOperand> {
+public abstract class AbstractNumericOperandParser<N> extends AbstractOperandParser<NumericOperand> {
@VisibleForTesting
public static final String EQUALS_VALUE = "equals";
*
* @param <T> operand Type
*/
-abstract public class AbstractOperandParser<T> {
+public abstract class AbstractOperandParser<T> {
@VisibleForTesting
public static final String AND_BIT_VALUE = "and-bit";
* @author Kevin Wang
*/
public abstract class AbstractVpnNextHopParserSerializer implements NextHopParserSerializer {
- private final int IP_ADDR_LENGTH;
- private final Class<?> IP_NEXT_HOP_CASE_CLAZZ;
+ private final int ipAddrLength;
+ private final Class<?> ipNextHopCaseClazz;
protected AbstractVpnNextHopParserSerializer(final int ipAddrLength, final Class<?> ipNextHopCaseClazz) {
- IP_ADDR_LENGTH = ipAddrLength;
- IP_NEXT_HOP_CASE_CLAZZ = ipNextHopCaseClazz;
+ this.ipAddrLength = ipAddrLength;
+ this.ipNextHopCaseClazz = ipNextHopCaseClazz;
}
@Override
public CNextHop parseNextHop(final ByteBuf buffer) throws BGPParsingException {
- Preconditions.checkArgument(buffer.readableBytes() == (IP_ADDR_LENGTH + RouteDistinguisherUtil.RD_LENGTH), "Length of byte array for NEXT_HOP should be %s, but is %s", IP_ADDR_LENGTH + RouteDistinguisherUtil.RD_LENGTH, buffer.readableBytes());
+ Preconditions.checkArgument(buffer.readableBytes() == (ipAddrLength + RouteDistinguisherUtil.RD_LENGTH), "Length of byte array for NEXT_HOP should be %s, but is %s", ipAddrLength + RouteDistinguisherUtil.RD_LENGTH, buffer.readableBytes());
buffer.readBytes(RouteDistinguisherUtil.RD_LENGTH);
- return NextHopUtil.parseNextHop(buffer.readBytes(IP_ADDR_LENGTH));
+ return NextHopUtil.parseNextHop(buffer.readBytes(ipAddrLength));
}
@Override
public void serializeNextHop(final CNextHop cNextHop, final ByteBuf byteAggregator) {
- Preconditions.checkArgument(IP_NEXT_HOP_CASE_CLAZZ.isInstance(cNextHop), "cNextHop is not a VPN %s NextHop object.", IP_NEXT_HOP_CASE_CLAZZ.getSimpleName());
+ Preconditions.checkArgument(ipNextHopCaseClazz.isInstance(cNextHop), "cNextHop is not a VPN %s NextHop object.", ipNextHopCaseClazz.getSimpleName());
byteAggregator.writeZero(RouteDistinguisherUtil.RD_LENGTH);
NextHopUtil.serializeNextHop(cNextHop, byteAggregator);
}
protected abstract AdvertizedRoutes getAdvertizedRoutesByDestination(List<VpnDestination> dst);
- public static void serializeNlri(final List<VpnDestination> dests, final ByteBuf buffer) {
+ static void serializeNlri(final List<VpnDestination> dests, final ByteBuf buffer) {
final ByteBuf nlriByteBuf = Unpooled.buffer();
for (final VpnDestination dest : dests) {
final List<LabelStack> labelStack = dest.getLabelStack();
vpnDst = getWithdrawnVpnDestination(routes.getDestinationType());
}
}
- if (vpnDst != null)
+ if (vpnDst != null) {
serializeNlri(vpnDst, byteAggregator);
+ }
}
@Override
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.ipv4.rev160210.l3vpn.ipv4.destination.VpnIpv4DestinationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.rev160413.l3vpn.ip.destination.type.VpnDestination;
-public class VpnIpv4NlriParser extends AbstractVpnNlriParser {
+final class VpnIpv4NlriParser extends AbstractVpnNlriParser {
private <T extends L3vpnIpv4Destination> List<VpnDestination> getVpnDestination(DestinationType dst, Class<T> dstTypeCaseClazz) {
- if (dstTypeCaseClazz.isInstance(dst))
+ if (dstTypeCaseClazz.isInstance(dst)) {
return dstTypeCaseClazz.cast(dst).getVpnIpv4Destination().getVpnDestination();
- else
+ } else {
return null;
+ }
}
@Override
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.ipv6.rev160331.l3vpn.ipv6.destination.VpnIpv6DestinationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.vpn.rev160413.l3vpn.ip.destination.type.VpnDestination;
-/**
- * @author Kevin Wang
- */
-public class VpnIpv6NlriParser extends AbstractVpnNlriParser {
+class VpnIpv6NlriParser extends AbstractVpnNlriParser {
private <T extends L3vpnIpv6Destination> List<VpnDestination> getVpnDestination(DestinationType dst, Class<T> dstTypeCaseClazz) {
- if (dstTypeCaseClazz.isInstance(dst))
+ if (dstTypeCaseClazz.isInstance(dst)) {
return dstTypeCaseClazz.cast(dst).getVpnIpv6Destination().getVpnDestination();
- else
+ } else {
return null;
+ }
}
@Override
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-abstract public class AbstractRouteEntry implements RouteEntry {
+public abstract class AbstractRouteEntry implements RouteEntry {
protected static final NodeIdentifier ROUTES_IDENTIFIER = new NodeIdentifier(Routes.QNAME);
private static final Logger LOG = LoggerFactory.getLogger(AbstractRouteEntry.class);
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
-final public class RouteEntryUtil {
+public final class RouteEntryUtil {
+ private RouteEntryUtil() {
+ throw new UnsupportedOperationException();
+ }
+
public static MapEntryNode createSimpleRouteValue(final PathArgument routeId, final BestPath path) {
final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> b = Builders.mapEntryBuilder();
b.withNodeIdentifier((NodeIdentifierWithPredicates) routeId);
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
/**
* Invoked on routes which we get from our Internal peers. This is a special-case of
FromInternalReflectorClientImportPolicy(final Ipv4Address bgpIdentifier, final ClusterIdentifier clusterIdentifier) {
super(bgpIdentifier, clusterIdentifier);
}
-
- @Override
- ContainerNode effectiveAttributes(final ContainerNode attributes) {
- // TODO: (defensiveness) verify ORIGINATOR_ID (should have been set)
-
- return super.effectiveAttributes(attributes);
- }
}
package org.opendaylight.protocol.pcep.auto.bandwidth.extension;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.xml.bind.DatatypeConverter;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.pcep.auto.bandwidth.rev160109.bandwidth.usage.object.BandwidthUsageBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.concepts.rev131125.Bandwidth;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.Pcrpt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.PlspId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.lsp.identifiers.tlv.LspIdentifiers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.lsp.identifiers.tlv.LspIdentifiersBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.lsp.identifiers.tlv.lsp.identifiers.AddressFamily;
final LspId lspId = new LspId(1L);
final TunnelId tunnelId = new TunnelId(1);
final LspIdentifiers identifier = new LspIdentifiersBuilder().setAddressFamily(afiLsp).setLspId(lspId).setTunnelId(tunnelId).build();
- final Lsp lsp = new LspBuilder().setTlvs(new TlvsBuilder().setLspIdentifiers(identifier).build()).build();
+ final Lsp lsp = new LspBuilder().setPlspId(new PlspId(1L)).setTlvs(new TlvsBuilder().setLspIdentifiers(identifier).build()).build();
final Ero ero = new EroBuilder().build();
final List<Object> objects = Lists.<Object>newArrayList(lsp, ero, bw);
final Reports validReports = codec.getValidReports(objects, Collections.<Message>emptyList());
assertTrue(objects.isEmpty());
}
+ @Test
+ public void testGetValidReportsNegative() {
+ final PcRptMessageCodec codec = new PcRptMessageCodec(this.ctx.getObjectHandlerRegistry());
+ final BandwidthUsage bw = new BandwidthUsageBuilder().setBwSample(Lists.newArrayList(new Bandwidth(new byte[] {0, 0, 0, 1}))).build();
+ final Ipv4Builder builder = new Ipv4Builder();
+ builder.setIpv4TunnelSenderAddress(new Ipv4Address("127.0.1.1"));
+ builder.setIpv4ExtendedTunnelId(new Ipv4ExtendedTunnelId(new Ipv4Address("127.0.1.2")));
+ builder.setIpv4TunnelEndpointAddress(new Ipv4Address("127.0.1.3"));
+ final Lsp lsp = new LspBuilder().setPlspId(new PlspId(1L)).build();
+ final Ero ero = new EroBuilder().build();
+ final List<Object> objects = Lists.newArrayList(lsp, ero, bw);
+ final Reports validReports = codec.getValidReports(objects, new ArrayList<>());
+ assertNull(validReports);
+ }
+
@Test
public void testserializeObject() {
final PcRptMessageCodec codec = new PcRptMessageCodec(this.ctx.getObjectHandlerRegistry());
MessageUtil.formatMessage(TYPE, buffer, out);
}
- protected void serializeReport(final Reports report, final ByteBuf buffer) {
+ private void serializeReport(final Reports report, final ByteBuf buffer) {
if (report.getSrp() != null) {
serializeObject(report.getSrp(), buffer);
}
}
protected Reports getValidReports(final List<Object> objects, final List<Message> errors) {
- boolean isValid = true;
final ReportsBuilder builder = new ReportsBuilder();
+
boolean lspViaSR = false;
- if (objects.get(0) instanceof Srp) {
- final Srp srp = (Srp) objects.get(0);
+ Object object = objects.remove(0);
+ if (object instanceof Srp) {
+ final Srp srp = (Srp) object;
final Tlvs tlvs = srp.getTlvs();
if (tlvs != null) {
lspViaSR = PSTUtil.isDefaultPST(tlvs.getPathSetupType());
}
builder.setSrp(srp);
- objects.remove(0);
+ if(objects.isEmpty()) {
+ object = null;
+ } else {
+ object = objects.remove(0);
+ }
}
- if (objects.get(0) instanceof Lsp) {
- final Lsp lsp = (Lsp) objects.get(0);
- if(!lspViaSR && lsp.getTlvs().getLspIdentifiers() == null && lsp.getPlspId().getValue() != 0) {
- errors.add(createErrorMsg(PCEPErrors.LSP_IDENTIFIERS_TLV_MISSING, Optional.<Rp>absent()));
- isValid = false;
- } else {
- builder.setLsp(lsp);
- objects.remove(0);
+ if(validateLsp(object, lspViaSR, errors, builder)) {
+ if(!objects.isEmpty()) {
+ object = objects.remove(0);
+ if(!validateEmpty(object, objects, errors, builder)) {
+ return null;
+ }
}
+
+ return builder.build();
+ }
+ return null;
+ }
+
+ private boolean validateEmpty(final Object object, final List<Object> objects, final List<Message> errors, final ReportsBuilder builder) {
+ final PathBuilder pBuilder = new PathBuilder();
+ if (object instanceof Ero) {
+ pBuilder.setEro((Ero) object);
} else {
- errors.add(createErrorMsg(PCEPErrors.LSP_MISSING, Optional.<Rp>absent()));
- isValid = false;
+ errors.add(createErrorMsg(PCEPErrors.ERO_MISSING, Optional.<Rp>absent()));
+ return false;
}
- if (!objects.isEmpty()) {
- final PathBuilder pBuilder = new PathBuilder();
- if (objects.get(0) instanceof Ero) {
- pBuilder.setEro((Ero) objects.get(0));
- objects.remove(0);
+ parsePath(objects, pBuilder);
+ builder.setPath(pBuilder.build());
+ return true;
+ }
+
+ private boolean validateLsp(final Object object, final boolean lspViaSR, final List<Message> errors, final ReportsBuilder builder) {
+ if (object instanceof Lsp) {
+ final Lsp lsp = (Lsp) object;
+ final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev131222.lsp.object.lsp.Tlvs tlvs = lsp.getTlvs();
+ if(!lspViaSR && lsp.getPlspId().getValue() != 0 && (tlvs == null || tlvs.getLspIdentifiers() == null)) {
+ final Message errorMsg = createErrorMsg(PCEPErrors.LSP_IDENTIFIERS_TLV_MISSING, Optional.<Rp>absent());
+ errors.add(errorMsg);
+ return false;
} else {
- errors.add(createErrorMsg(PCEPErrors.ERO_MISSING, Optional.<Rp>absent()));
- isValid = false;
+ builder.setLsp(lsp);
}
- parsePath(objects, pBuilder);
- builder.setPath(pBuilder.build());
- }
- if(isValid) {
- return builder.build();
+ } else {
+ errors.add(createErrorMsg(PCEPErrors.LSP_MISSING, Optional.<Rp>absent()));
+ return false;
}
- return null;
+ return true;
}
private void parsePath(final List<Object> objects, final PathBuilder builder) {
import org.slf4j.LoggerFactory;
final class PCEPRequest {
- static enum State {
+ enum State {
UNSENT,
UNACKED,
DONE,
return state;
}
- public Timer getTimer() {
+ Timer getTimer() {
return timer;
}
- public synchronized void done(final OperationResult result) {
+ synchronized void done(final OperationResult result) {
if (state != State.DONE) {
LOG.debug("Request went from {} to {}", state, State.DONE);
state = State.DONE;
}
}
- public synchronized void done() {
- OperationResult result = null;
+ synchronized void done() {
+ OperationResult result;
switch (state) {
case UNSENT:
result = OperationResults.UNSENT;
break;
case DONE:
return;
+ default:
+ return;
}
done(result);
}
- public synchronized void sent() {
+ synchronized void sent() {
if (state == State.UNSENT) {
LOG.debug("Request went from {} to {}", state, State.UNACKED);
state = State.UNACKED;
}
}
- public long getElapsedMillis() {
+ long getElapsedMillis() {
return this.stopwatch.elapsed(TimeUnit.MILLISECONDS);
}
}
Code Review / bgpcep.git / commitdiff