*/
public static RouteDistinguisher parseRouteDistinguisher(final ByteBuf buffer) {
final int type = buffer.readUnsignedShort();
- final StringBuffer routeDistiguisher = new StringBuffer();
+ final StringBuilder routeDistiguisher = new StringBuilder();
switch (type) {
case IPV4_TYPE:
routeDistiguisher.append(Ipv4Util.addressForByteBuf(buffer).getValue());
return builder.build();
}
- public static void serializeBindingSidLabels(final List<SrBindingSidLabels> bindingSids, final ByteBuf aggregator, final int sid_type) {
+ public static void serializeBindingSidLabels(final List<SrBindingSidLabels> bindingSids, final ByteBuf aggregator, final int sidType) {
for (final SrBindingSidLabels bindingSid : bindingSids) {
final ByteBuf sidBuffer = Unpooled.buffer();
serializeBindingSidAttributes(bindingSid.getWeight(), bindingSid.getFlags(), bindingSid.getBindingSubTlvs(), sidBuffer);
- TlvUtil.writeTLV(sid_type, sidBuffer, aggregator);
+ TlvUtil.writeTLV(sidType, sidBuffer, aggregator);
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.dom.rev131028.DomAsyncDataBroker;
import org.opendaylight.yangtools.yang.binding.ChildOf;
-final public class DataBrokerFunction {
+public final class DataBrokerFunction {
private DataBrokerFunction() {
throw new UnsupportedOperationException();
}
}
}
return null;
- } catch (ReadFailedException e) {
+ } catch (final ReadFailedException e) {
throw new IllegalStateException("Failed to read service.", e);
}
}
private static final short DEFAULT_KEEP_ALIVE = 30;
private static final short DEFAULT_DEAD_TIMER = 120;
private static final InetAddress LOCALHOST = InetAddresses.forString("127.0.0.1");
- private static boolean TRIGGERED_INIT_SYNC = Boolean.FALSE;
- private static boolean INCLUDE_DBV = Boolean.FALSE;
- private static boolean INCREMENTAL_SYNC = Boolean.FALSE;
- private static boolean TRIGGERED_RESYNC = Boolean.FALSE;
- private static BigInteger SYNC_OPT_DB_VERSION;
- private static int RECONNECT_AFTER_X_SECOND;
- private static int DISCONNECT_AFTER_X_SECONDS;
+ private static boolean triggeredInitSync = Boolean.FALSE;
+ private static boolean includeDbv = Boolean.FALSE;
+ private static boolean incrementalSync = Boolean.FALSE;
+ private static boolean triggeredResync = Boolean.FALSE;
+ private static BigInteger syncOptDBVersion;
+ private static int reconnectAfterXSeconds;
+ private static int disonnectAfterXSeconds;
private Main() {
stateTimeout = Integer.valueOf(args[++argIdx]);
} else if (args[argIdx].equals("--state-sync-avoidance")) {
//"--state-sync-avoidance 10, 5, 10
- INCLUDE_DBV = Boolean.TRUE;
+ includeDbv = Boolean.TRUE;
final Long dbVersionAfterReconnect = Long.valueOf(args[++argIdx]);
- DISCONNECT_AFTER_X_SECONDS = Integer.valueOf(args[++argIdx]);
- RECONNECT_AFTER_X_SECOND = Integer.valueOf(args[++argIdx]);
- SYNC_OPT_DB_VERSION = BigInteger.valueOf(dbVersionAfterReconnect);
+ disonnectAfterXSeconds = Integer.valueOf(args[++argIdx]);
+ reconnectAfterXSeconds = Integer.valueOf(args[++argIdx]);
+ syncOptDBVersion = BigInteger.valueOf(dbVersionAfterReconnect);
} else if (args[argIdx].equals("--incremental-sync-procedure")) {
//TODO Check that DBv > Lsp always ??
- INCLUDE_DBV = Boolean.TRUE;
- INCREMENTAL_SYNC = Boolean.TRUE;
+ includeDbv = Boolean.TRUE;
+ incrementalSync = Boolean.TRUE;
//Version of database to be used after restart
final Long initialDbVersionAfterReconnect = Long.valueOf(args[++argIdx]);
- DISCONNECT_AFTER_X_SECONDS = Integer.valueOf(args[++argIdx]);
- RECONNECT_AFTER_X_SECOND = Integer.valueOf(args[++argIdx]);
- SYNC_OPT_DB_VERSION = BigInteger.valueOf(initialDbVersionAfterReconnect);
+ disonnectAfterXSeconds = Integer.valueOf(args[++argIdx]);
+ reconnectAfterXSeconds = Integer.valueOf(args[++argIdx]);
+ syncOptDBVersion = BigInteger.valueOf(initialDbVersionAfterReconnect);
} else if (args[argIdx].equals("--triggered-initial-sync")) {
- TRIGGERED_INIT_SYNC = Boolean.TRUE;
+ triggeredInitSync = Boolean.TRUE;
} else if (args[argIdx].equals("--triggered-re-sync")) {
- TRIGGERED_RESYNC = Boolean.TRUE;
+ triggeredResync = Boolean.TRUE;
} else {
LOG.warn("WARNING: Unrecognized argument: {}", args[argIdx]);
}
argIdx++;
}
- if (INCREMENTAL_SYNC) {
- Preconditions.checkArgument(SYNC_OPT_DB_VERSION.intValue() > lsps, "Synchronization Database Version which will be used after " +
+ if (incrementalSync) {
+ Preconditions.checkArgument(syncOptDBVersion.intValue() > lsps, "Synchronization Database Version which will be used after " +
"reconnectes requires to be higher than lsps");
}
- final Optional<BigInteger> dBVersion = Optional.fromNullable(SYNC_OPT_DB_VERSION);
+ final Optional<BigInteger> dBVersion = Optional.fromNullable(syncOptDBVersion);
final PCCsBuilder pccs = new PCCsBuilder(lsps, pcError, pccCount, localAddress, remoteAddress, ka, dt, password, reconnectTime, redelegationTimeout,
stateTimeout, dBVersion, getCapabilities());
- final TimerHandler timerHandler = new TimerHandler(pccs, dBVersion, DISCONNECT_AFTER_X_SECONDS, RECONNECT_AFTER_X_SECOND);
+ final TimerHandler timerHandler = new TimerHandler(pccs, dBVersion, disonnectAfterXSeconds, reconnectAfterXSeconds);
pccs.createPCCs(BigInteger.valueOf(lsps), Optional.fromNullable(timerHandler));
- if (!TRIGGERED_INIT_SYNC) {
+ if (!triggeredInitSync) {
timerHandler.createDisconnectTask();
}
}
private static PCEPCapability getCapabilities() {
- if (TRIGGERED_INIT_SYNC) {
- Preconditions.checkArgument(INCLUDE_DBV);
+ if (triggeredInitSync) {
+ Preconditions.checkArgument(includeDbv);
}
- return new PCEPStatefulCapability(true, true, true, TRIGGERED_INIT_SYNC, TRIGGERED_RESYNC, INCREMENTAL_SYNC, INCLUDE_DBV);
+ return new PCEPStatefulCapability(true, true, true, triggeredInitSync, triggeredResync, incrementalSync, includeDbv);
}
private static ch.qos.logback.classic.Logger getRootLogger(final LoggerContext lc) {
private static final String ENDPOINT_PREFIX = ENDPOINT_ADDRESS + "/32";
public static final int PCC_DELEGATION = -1;
- public static Map<PlspId, PCCTunnel> createTunnels(String address, final int lsps) {
+ private PCCTunnelBuilder() {
+ throw new UnsupportedOperationException();
+ }
+
+ public static Map<PlspId, PCCTunnel> createTunnels(final String address, final int lsps) {
final Map<PlspId, PCCTunnel> tunnels = new HashMap<>();
for (int i = 1; i <= lsps; i++) {
final PCCTunnel tunnel = new PCCTunnel(MsgBuilderUtil.getDefaultPathName(address, i), PCC_DELEGATION, LspType.PCC_LSP,
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.explicit.route.object.ero.Subobject;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.IpPrefixCase;
-final public class PCCTunnelManagerImpl implements PCCTunnelManager {
+public final class PCCTunnelManagerImpl implements PCCTunnelManager {
private static final Optional<Srp> NO_SRP = Optional.absent();
@GuardedBy("this")
final long srpId = request.getSrp().getOperationId().getValue();
if (tunnel != null) {
//check if tunnel has no delegation
- if (tunnel.getType() == LspType.PCE_LSP && (tunnel.getDelegationHolder() == -1 || tunnel.getDelegationHolder() == session.getId())) {
+ if ((tunnel.getType() == LspType.PCE_LSP) && ((tunnel.getDelegationHolder() == -1) || (tunnel.getDelegationHolder() == session.getId()))) {
//set delegation
tunnel.cancelTimeouts();
setDelegation(plspId, session);
lazyTunnelInicialization();
//first session - delegate all PCC's LSPs only when reporting at startup
- if (!this.sessions.containsKey(session.getId()) && session.getId() == 0) {
+ if (!this.sessions.containsKey(session.getId()) && (session.getId() == 0)) {
for (final PlspId plspId : this.tunnels.keySet()) {
setDelegation(plspId, session);
}
}
} else if (isReSyncTriggered(lsp)) {
handledDbTriggeredResync(update, session);
- } else if (lsp.isDelegate() != null && lsp.isDelegate()) {
+ } else if ((lsp.isDelegate() != null) && lsp.isDelegate()) {
//regular LSP update
reportToAll(update, session);
} else {
@Override
public void onMessagePcInitiate(@Nonnull final Requests request, @Nonnull final PCCSession session) {
- if (request.getSrp().getAugmentation(Srp1.class) != null && request.getSrp().getAugmentation(Srp1.class).isRemove()) {
+ if ((request.getSrp().getAugmentation(Srp1.class) != null) && request.getSrp().getAugmentation(Srp1.class).isRemove()) {
//remove LSP
removeTunnel(request, session);
- } else if (request.getLsp().isDelegate() != null && request.getLsp().isDelegate() && request.getEndpointsObj() == null) {
+ } else if ((request.getLsp().isDelegate() != null) && request.getLsp().isDelegate() && (request.getEndpointsObj() == null)) {
//take LSP delegation
takeDelegation(request, session);
} else {
}
}
- private Tlvs buildTlvs(final PCCTunnel tunnel, final Long plspId, Optional<List<Subobject>> subobjectsList) {
+ private Tlvs buildTlvs(final PCCTunnel tunnel, final Long plspId, final Optional<List<Subobject>> subobjectsList) {
final List<Subobject> subObject = subobjectsList.isPresent() ? subobjectsList.get() : tunnel.getLspState().getEro().getSubobject();
final String destinationAddress = getDestinationAddress(subObject, this.address);
private void lazyTunnelInicialization() {
if (this.tunnels.isEmpty()) {
final BigInteger dbV = this.syncOptimization.getLocalLspDbVersionValue();
- if (this.syncOptimization.isSyncAvoidanceEnabled() && !(dbV != null && dbV.equals(BigInteger.ONE))) {
+ if (this.syncOptimization.isSyncAvoidanceEnabled() && !((dbV != null) && dbV.equals(BigInteger.ONE))) {
this.tunnels.putAll(PCCTunnelBuilder.createTunnels(this.address, dbV.intValue()));
} else {
this.tunnels.putAll(PCCTunnelBuilder.createTunnels(this.address, this.lspsCount));
}
private boolean isInitialSyncTriggered(final Lsp lsp) {
- return lsp.getPlspId().getValue() == 0 && lsp.isSync() && this.syncOptimization.isTriggeredInitSyncEnabled();
+ return (lsp.getPlspId().getValue() == 0) && lsp.isSync() && this.syncOptimization.isTriggeredInitSyncEnabled();
}
private void handledDbTriggeredResync(final Updates update, final PCCSession session) {
}
}
- private void createLspAndSendReport(final long plspId, final PCCTunnel tunnel, final PCCSession session, Optional<Boolean> isSync, final Optional<Srp> srp) {
+ private void createLspAndSendReport(final long plspId, final PCCTunnel tunnel, final PCCSession session, final Optional<Boolean> isSync, final Optional<Srp> srp) {
final boolean delegation = hasDelegation(tunnel, session);
if (delegation) {
tunnel.cancelTimeouts();
this.syncOptimization.incrementLspDBVersion());
final boolean sync = isSync.isPresent() ? isSync.get() : this.syncOptimization.isSyncNeedIt();
- Lsp lsp = createLsp(plspId, sync, Optional.fromNullable(tlvs), delegation, false);
+ final Lsp lsp = createLsp(plspId, sync, Optional.fromNullable(tlvs), delegation, false);
final Pcrpt pcrtp = createPcRtpMessage(lsp, srp, tunnel.getLspState());
session.sendReport(pcrtp);
}
for (final Entry<PlspId, PCCTunnel> entry : this.tunnels.entrySet()) {
final PCCTunnel tunnel = entry.getValue();
- long plspId = entry.getKey().getValue();
+ final long plspId = entry.getKey().getValue();
createLspAndSendReport(plspId, tunnel, session, Optional.<Boolean>absent(), Optional.fromNullable(srp));
}
}
}
private static String getDestinationAddress(final List<Subobject> subobjects, final String defaultAddress) {
- if (subobjects != null && !subobjects.isEmpty()) {
+ if ((subobjects != null) && !subobjects.isEmpty()) {
final String prefix = ((IpPrefixCase) subobjects.get(subobjects.size() - 1).getSubobjectType())
.getIpPrefix().getIpPrefix().getIpv4Prefix().getValue();
return prefix.substring(0, prefix.indexOf('/'));