LinkstateAdjRIBsIn(final KeyedInstanceIdentifier<Tables, TablesKey> basePath) {
super(basePath);
- routesBasePath = basePath.builder().child((Class)LinkstateRoutes.class).build();
+ this.routesBasePath = basePath.builder().child((Class)LinkstateRoutes.class).build();
}
@Override
public KeyedInstanceIdentifier<LinkstateRoute, LinkstateRouteKey> identifierForKey(final CLinkstateDestination key) {
final ByteBuf keyBuf = Unpooled.buffer();
LinkstateNlriParser.serializeNlri(key, keyBuf);
- return routesBasePath.child(LinkstateRoute.class,
+ return this.routesBasePath.child(LinkstateRoute.class,
new LinkstateRouteKey(ByteArray.readAllBytes(keyBuf)));
}
}
};
break;
+ default:
+ break;
}
super.add(trans, peer, key, data);
}
}
public int getType() {
- return type;
+ return this.type;
}
private NlriType getNlriType(final PathAttributesBuilder pab) {
case Node:
builder.setLinkStateAttribute(parseNodeAttributes(map));
return builder.build();
+ default:
+ throw new IllegalStateException("Unhandled NLRI type " + nlri);
}
- throw new IllegalStateException("Unhandled NLRI type " + nlri);
}
/**
case Node:
// node nlri is already parsed as it contains only the common fields for node and link nlri
break;
+ default:
+ break;
}
nlri.skipBytes(restLength);
dests.add(builder.build());
case Incomplete:
builder.setOrigin(INC);
return;
+ default:
+ return;
}
}
return;
}
break;
+ default:
+ break;
}
// Catch-all for unexpected message
ilab.addAugmentation(org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021.IgpLinkAttributes1.class,
ospfLinkAttributes(l.getLinkDescriptors().getMultiTopologyId(), la));
break;
+ default:
+ break;
}
final LinkBuilder lb = new LinkBuilder();
inab.addAugmentation(org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.ospf.topology.rev131021.IgpNodeAttributes1.class,
ospfNodeAttributes(nd, na));
break;
+ default:
+ break;
}
}
new OspfPrefixAttributesBuilder().setForwardingAddress(pa.getOspfForwardingAddress().getIpv4Address()).build()).build());
}
break;
+ default:
+ break;
}
}
break;
case END:
break;
+ default:
+ break;
}
if (!state.equals(State.END)) {
objects.remove(0);
break;
case END:
break;
+ default:
+ break;
}
if (!state.equals(State.END)) {
objects.remove(0);
break;
case END:
break;
+ default:
+ break;
}
if (!state.equals(State.END)) {
objects.remove(0);
break;
case END:
break;
+ default:
+ break;
}
if (!state.equals(State.END)) {
objects.remove(0);
negotiationFailed(new TimeoutException("OpenWait timer expired"));
AbstractPCEPSessionNegotiator.this.state = State.FINISHED;
break;
+ default:
+ break;
}
}
}, FAIL_TIMER_VALUE, TimeUnit.SECONDS);
return;
}
break;
+ default:
+ break;
}
LOG.warn("Channel {} in state {} received unexpected message {}", this.channel, this.state, msg);
sendErrorMessage(PCEPErrors.NON_OR_INVALID_OPEN_MSG);
break;
case END:
break;
+ default:
+ break;
}
if (!state.equals(State.END)) {
objects.remove(0);
break;
case END:
break;
+ default:
+ break;
}
if (!state.equals(State.END)) {
objects.remove(0);
break;
case END:
break;
+ default:
+ break;
}
if (!state.equals(State.END)) {
objects.remove(0);
break;
case END:
break;
+ default:
+ break;
}
if (!state.equals(State.END)) {
objects.remove(0);
break;
case END:
break;
+ default:
+ break;
}
if (!state.equals(SvecState.END)) {
objects.remove(0);
private static final int F_FLAG_POSITION = 4;
@Override
- public void serializeSubobject(Subobject subobject, final ByteBuf buffer) {
+ public void serializeSubobject(final Subobject subobject, final ByteBuf buffer) {
Preconditions.checkArgument(subobject.getSubobjectType() instanceof SrEroSubobject,
"Unknown subobject instance. Passed %s. Needed SrEroSubobject.", subobject.getSubobjectType()
.getClass());
ByteBufWriteUtil.writeUnsignedInt(unnumbered.getRemoteNodeId(), body);
ByteBufWriteUtil.writeUnsignedInt(unnumbered.getRemoteInterfaceId(), body);
break;
+ default:
+ break;
}
}
EROSubobjectUtil.formatSubobject(TYPE, subobject.isLoose(), body, buffer);
}
@Override
- public Subobject parseSubobject(ByteBuf buffer, boolean loose) throws PCEPDeserializerException {
+ public Subobject parseSubobject(final ByteBuf buffer, final boolean loose) throws PCEPDeserializerException {
Preconditions.checkArgument(buffer != null && buffer.isReadable(),
"Array of bytes is mandatory. Can't be null or empty.");
if (buffer.readableBytes() <= MINIMAL_LENGTH) {
final SidType sidType = SidType.forValue(sidTypeByte);
srEroSubobjectBuilder.setSidType(sidType);
- BitSet bitSet = ByteArray.bytesToBitSet(new byte[] { buffer.readByte() });
+ final BitSet bitSet = ByteArray.bytesToBitSet(new byte[] { buffer.readByte() });
final boolean f = bitSet.get(F_FLAG_POSITION);
final boolean s = bitSet.get(S_FLAG_POSITION);
final boolean c = bitSet.get(C_FLAG_POSITION);
.setLocalInterfaceId(buffer.readUnsignedInt()).setRemoteNodeId(buffer.readUnsignedInt())
.setRemoteInterfaceId(buffer.readUnsignedInt()).build());
break;
+ default:
+ break;
}
}
final SubobjectBuilder subobjectBuilder = new SubobjectBuilder();
LOG.debug("Request {} was not sent when session went down, cancelling the instruction", e.getKey());
r.done(OperationResults.UNSENT);
break;
+ default:
+ break;
}
}
this.requests.clear();
// These are transitive states, so we don't have to do anything, as they will be followed
// up...
break;
+ default:
+ break;
}
// if remove flag is set in SRP object, remove the tunnel immediately
if (srp.getAugmentation(Srp1.class) != null) {
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-
import org.opendaylight.bgpcep.programming.spi.Instruction;
import org.opendaylight.bgpcep.programming.spi.InstructionScheduler;
import org.opendaylight.bgpcep.programming.spi.SchedulerException;
try {
s = scheduler.scheduleInstruction(fwd.getInput());
- } catch (SchedulerException e) {
+ } catch (final SchedulerException e) {
LOG.info("Instuction {} failed to schedule", e.getMessage(), e);
return new FailureCaseBuilder().setFailure(e.getFailure()).build();
}
case Unsent:
insn.executionCompleted(InstructionStatus.Cancelled, null);
break;
+ default:
+ break;
}
} else {
insn.executionCompleted(InstructionStatus.Successful, null);
case Scheduled:
case Successful:
break;
+ default:
+ break;
}
}
LOG.debug("Instruction {} timed out while Scheduled, cancelling it", this.id);
cancel(this.heldUpDetails);
break;
+ default:
+ break;
}
}
case Scheduled:
cancel(details);
return null;
+ default:
+ throw new IllegalStateException("Unhandled instruction state " + this.status);
}
-
- throw new IllegalStateException("Unhandled instruction state " + this.status);
}
@Override
case Successful:
// No-op
break;
+ default:
+ break;
}
}
if (!unmet.isEmpty()) {
LOG.debug("Instruction {} cannot be cleaned because of it's in state {}", id, i.getStatus());
failed.add(id);
continue;
+ default:
+ break;
}
// The instruction is in a terminal state, we need to just unlink
case Scheduled:
case Successful:
break;
+ default:
+ break;
}
}
/*
Code Review / bgpcep.git / commitdiff