X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=pcep%2Ftopology%2Ftopology-provider%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fbgpcep%2Fpcep%2Ftopology%2Fprovider%2FAbstractTopologySessionListener.java;h=6190db4f5c347a6a180614146d15b4e8888fa8a6;hb=refs%2Fchanges%2F11%2F100711%2F3;hp=2fa800fd934468f5e14868feec6fb523442540de;hpb=0c0e5fe562ace67be1a3f87e7e93d731278a9cc2;p=bgpcep.git diff --git a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/AbstractTopologySessionListener.java b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/AbstractTopologySessionListener.java index 2fa800fd93..6190db4f5c 100644 --- a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/AbstractTopologySessionListener.java +++ b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/AbstractTopologySessionListener.java @@ -33,6 +33,8 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import org.checkerframework.checker.lock.qual.GuardedBy; import org.checkerframework.checker.lock.qual.Holding; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.bgpcep.pcep.topology.provider.session.stats.SessionStateImpl; import org.opendaylight.bgpcep.pcep.topology.provider.session.stats.TopologySessionStats; import org.opendaylight.mdsal.binding.api.WriteTransaction; @@ -43,13 +45,18 @@ import org.opendaylight.protocol.pcep.PCEPSession; import org.opendaylight.protocol.pcep.PCEPTerminationReason; import org.opendaylight.protocol.pcep.TerminationReason; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IetfInetUtil; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.initiated.rev200720.Stateful1; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.LspObject; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.Path1; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.PlspId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.SrpIdNumber; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.StatefulTlv1Builder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.Tlvs1; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.lsp.object.Lsp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev200720.stateful.capability.tlv.Stateful; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.Message; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.MessageHeader; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.Object; -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.open.object.open.Tlvs; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.LspId; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.Node1; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.Node1Builder; @@ -62,6 +69,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.ReportedLsp; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.ReportedLspBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.ReportedLspKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.StatefulTlvBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.reported.lsp.Path; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.pcep.client.attributes.path.computation.client.reported.lsp.PathKey; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node; @@ -69,7 +77,6 @@ import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.common.RpcResultBuilder; -import org.opendaylight.yangtools.yang.common.Uint8; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -77,35 +84,21 @@ import org.slf4j.LoggerFactory; * Base class for PCEP topology providers. It handles the common tasks involved in managing a PCEP server (PCE) * endpoint, and exposing a network topology based on it. It needs to be subclassed to form a fully functional block, * where the subclass provides handling of incoming messages. - * - * @param identifier type of requests - * @param identifier type for LSPs */ -public abstract class AbstractTopologySessionListener implements TopologySessionListener, TopologySessionStats { +public abstract class AbstractTopologySessionListener implements TopologySessionListener, TopologySessionStats { private static final Logger LOG = LoggerFactory.getLogger(AbstractTopologySessionListener.class); - static final String MISSING_XML_TAG = "Mandatory XML tags are missing."; - static final MessageHeader MESSAGE_HEADER = new MessageHeader() { - private final ProtocolVersion version = new ProtocolVersion(Uint8.ONE); - - @Override - public Class implementedInterface() { - return MessageHeader.class; - } - - @Override - public ProtocolVersion getVersion() { - return version; - } - }; + private final AtomicBoolean statefulCapability = new AtomicBoolean(false); + private final AtomicBoolean lspUpdateCapability = new AtomicBoolean(false); + private final AtomicBoolean initiationCapability = new AtomicBoolean(false); @GuardedBy("this") - final Map lsps = new HashMap<>(); + final Map lsps = new HashMap<>(); @GuardedBy("this") SessionStateImpl listenerState; @GuardedBy("this") - private final Map requests = new HashMap<>(); + private final Map requests = new HashMap<>(); @GuardedBy("this") private final Map lspData = new ConcurrentHashMap<>(); private final ServerSessionManager serverSessionManager; @@ -126,7 +119,7 @@ public abstract class AbstractTopologySessionListener implements TopologyS @Override public final void onSessionUp(final PCEPSession psession) { - synchronized (this.serverSessionManager) { + synchronized (serverSessionManager) { synchronized (this) { /* * The session went up. Look up the router in Inventory model, create it if it @@ -135,92 +128,132 @@ public abstract class AbstractTopologySessionListener implements TopologyS */ final InetAddress peerAddress = psession.getRemoteAddress(); - this.syncOptimization = new SyncOptimization(psession); + syncOptimization = new SyncOptimization(psession); + final boolean haveLspDbVersion = syncOptimization.isDbVersionPresent(); final TopologyNodeState state = - this.serverSessionManager.takeNodeState(peerAddress, this, isLspDbRetreived()); + serverSessionManager.takeNodeState(peerAddress, this, haveLspDbVersion); // takeNodeState(..) may fail when the server session manager is being restarted // due to configuration change if (state == null) { LOG.error("Unable to fetch topology node state for PCEP session. Closing session {}", psession); psession.close(TerminationReason.UNKNOWN); - this.onSessionTerminated(psession, new PCEPCloseTermination(TerminationReason.UNKNOWN)); + onSessionTerminated(psession, new PCEPCloseTermination(TerminationReason.UNKNOWN)); return; } - if (this.session != null || this.nodeState != null) { - LOG.error("PCEP session is already up with {}. Closing session {}", psession.getRemoteAddress(), - psession); + if (session != null || nodeState != null) { + LOG.error("PCEP session is already up with {}. Closing session {}", peerAddress, psession); psession.close(TerminationReason.UNKNOWN); - this.onSessionTerminated(psession, new PCEPCloseTermination(TerminationReason.UNKNOWN)); + onSessionTerminated(psession, new PCEPCloseTermination(TerminationReason.UNKNOWN)); return; } - this.session = psession; - this.nodeState = state; + session = psession; + nodeState = state; LOG.trace("Peer {} resolved to topology node {}", peerAddress, state.getNodeId()); // Our augmentation in the topology node - final PathComputationClientBuilder pccBuilder = new PathComputationClientBuilder(); + final PathComputationClientBuilder pccBuilder = new PathComputationClientBuilder() + .setIpAddress(IetfInetUtil.INSTANCE.ipAddressNoZoneFor(peerAddress)); - onSessionUp(psession, pccBuilder); - this.synced.set(isSynchronized()); + // Let subclass fill the details + updateStatefulCapabilities(pccBuilder, peerAddress, psession.getRemoteTlvs()); + + synced.set(isSynchronized()); - pccBuilder.setIpAddress(IetfInetUtil.INSTANCE.ipAddressNoZoneFor(peerAddress)); final InstanceIdentifier topologyAugment = state.getNodeId().augmentation(Node1.class); - this.pccIdentifier = topologyAugment.child(PathComputationClient.class); - final Node initialNodeState = state.getInitialNodeState(); - final boolean isNodePresent = isLspDbRetreived() && initialNodeState != null; - if (isNodePresent) { - loadLspData(initialNodeState, this.lspData, this.lsps, isIncrementalSynchro()); - pccBuilder.setReportedLsp( + pccIdentifier = topologyAugment.child(PathComputationClient.class); + + if (haveLspDbVersion) { + final Node initialNodeState = state.getInitialNodeState(); + if (initialNodeState != null) { + loadLspData(initialNodeState, lspData, lsps, isIncrementalSynchro()); + pccBuilder.setReportedLsp( initialNodeState.augmentation(Node1.class).getPathComputationClient().getReportedLsp()); + } } state.storeNode(topologyAugment, new Node1Builder().setPathComputationClient(pccBuilder.build()).build(), psession); - this.listenerState = new SessionStateImpl(this, psession); - this.serverSessionManager.bind(state.getNodeId(), this.listenerState); - LOG.info("Session with {} attached to topology node {}", psession.getRemoteAddress(), - state.getNodeId()); + listenerState = new SessionStateImpl(this, psession); + serverSessionManager.bind(state.getNodeId(), listenerState); + LOG.info("Session with {} attached to topology node {}", peerAddress, state.getNodeId()); } } } - protected abstract void onSessionUp(PCEPSession session, PathComputationClientBuilder pccBuilder); + @Holding("this") + private void updateStatefulCapabilities(final PathComputationClientBuilder pccBuilder, + final InetAddress peerAddress, final @Nullable Tlvs remoteTlvs) { + if (remoteTlvs != null) { + final Tlvs1 statefulTlvs = remoteTlvs.augmentation(Tlvs1.class); + if (statefulTlvs != null) { + final Stateful stateful = statefulTlvs.getStateful(); + if (stateful != null) { + statefulCapability.set(true); + final var updateCap = stateful.getLspUpdateCapability(); + if (updateCap != null) { + lspUpdateCapability.set(updateCap); + } + final Stateful1 stateful1 = stateful.augmentation(Stateful1.class); + if (stateful1 != null) { + final var initiation = stateful1.getInitiation(); + if (initiation != null) { + initiationCapability.set(initiation); + } + } + + pccBuilder.setReportedLsp(Map.of()); + if (isSynchronized()) { + pccBuilder.setStateSync(PccSyncState.Synchronized); + } else if (isTriggeredInitialSynchro()) { + pccBuilder.setStateSync(PccSyncState.TriggeredInitialSync); + } else if (isIncrementalSynchro()) { + pccBuilder.setStateSync(PccSyncState.IncrementalSync); + } else { + pccBuilder.setStateSync(PccSyncState.InitialResync); + } + pccBuilder.setStatefulTlv(new StatefulTlvBuilder() + .addAugmentation(new StatefulTlv1Builder(statefulTlvs).build()) + .build()); + return; + } + } + } + LOG.debug("Peer {} does not advertise stateful TLV", peerAddress); + } synchronized void updatePccState(final PccSyncState pccSyncState) { - if (this.nodeState == null) { + if (nodeState == null) { LOG.info("Server Session Manager is closed."); - AbstractTopologySessionListener.this.session.close(TerminationReason.UNKNOWN); + session.close(TerminationReason.UNKNOWN); return; } - final MessageContext ctx = new MessageContext(this.nodeState.getChain().newWriteOnlyTransaction()); + final MessageContext ctx = new MessageContext(nodeState.getChain().newWriteOnlyTransaction()); updatePccNode(ctx, new PathComputationClientBuilder().setStateSync(pccSyncState).build()); if (pccSyncState != PccSyncState.Synchronized) { - this.synced.set(false); - this.triggeredResyncInProcess = true; + synced.set(false); + triggeredResyncInProcess = true; } // All set, commit the modifications ctx.trans.commit().addCallback(new FutureCallback() { @Override public void onSuccess(final CommitInfo result) { - LOG.trace("Pcc Internal state for session {} updated successfully", - AbstractTopologySessionListener.this.session); + LOG.trace("Pcc Internal state for session {} updated successfully", session); } @Override - public void onFailure(final Throwable throwable) { - LOG.error("Failed to update Pcc internal state for session {}", - AbstractTopologySessionListener.this.session, throwable); - AbstractTopologySessionListener.this.session.close(TerminationReason.UNKNOWN); + public void onFailure(final Throwable cause) { + LOG.error("Failed to update Pcc internal state for session {}", session, cause); + session.close(TerminationReason.UNKNOWN); } }, MoreExecutors.directExecutor()); } synchronized boolean isTriggeredSyncInProcess() { - return this.triggeredResyncInProcess; + return triggeredResyncInProcess; } /** @@ -230,25 +263,25 @@ public abstract class AbstractTopologySessionListener implements TopologyS @SuppressWarnings("checkstyle:IllegalCatch") private void tearDown(final PCEPSession psession) { requireNonNull(psession); - synchronized (this.serverSessionManager) { + synchronized (serverSessionManager) { synchronized (this) { - this.serverSessionManager.releaseNodeState(this.nodeState, psession, isLspDbPersisted()); + serverSessionManager.releaseNodeState(nodeState, psession.getRemoteAddress(), isLspDbPersisted()); clearNodeState(); try { - if (this.session != null) { - this.session.close(); + if (session != null) { + session.close(); } psession.close(); } catch (final Exception e) { LOG.error("Session {} cannot be closed.", psession, e); } - this.session = null; - this.listenerState = null; - this.syncOptimization = null; + session = null; + listenerState = null; + syncOptimization = null; // Clear all requests we know about - for (final Entry e : this.requests.entrySet()) { + for (final Entry e : requests.entrySet()) { final PCEPRequest r = e.getValue(); switch (r.getState()) { case DONE: @@ -271,7 +304,7 @@ public abstract class AbstractTopologySessionListener implements TopologyS break; } } - this.requests.clear(); + requests.clear(); } } } @@ -290,12 +323,12 @@ public abstract class AbstractTopologySessionListener implements TopologyS @Override public final synchronized void onMessage(final PCEPSession psession, final Message message) { - if (this.nodeState == null) { + if (nodeState == null) { LOG.warn("Topology node state is null. Unhandled message {} on session {}", message, psession); psession.close(TerminationReason.UNKNOWN); return; } - final MessageContext ctx = new MessageContext(this.nodeState.getChain().newWriteOnlyTransaction()); + final MessageContext ctx = new MessageContext(nodeState.getChain().newWriteOnlyTransaction()); if (onMessage(ctx, message)) { LOG.warn("Unhandled message {} on session {}", message, psession); @@ -342,12 +375,12 @@ public abstract class AbstractTopologySessionListener implements TopologyS @Override public void close() { - synchronized (this.serverSessionManager) { + synchronized (serverSessionManager) { synchronized (this) { clearNodeState(); - if (this.session != null) { + if (session != null) { LOG.info("Closing session {}", session); - this.session.close(TerminationReason.UNKNOWN); + session.close(TerminationReason.UNKNOWN); } } } @@ -355,29 +388,29 @@ public abstract class AbstractTopologySessionListener implements TopologyS @Holding({"this.serverSessionManager", "this"}) private void clearNodeState() { - if (this.nodeState != null) { - this.serverSessionManager.unbind(this.nodeState.getNodeId()); - LOG.debug("Clear Node state: {}", this.nodeState.getNodeId()); - this.nodeState = null; + if (nodeState != null) { + serverSessionManager.unbind(nodeState.getNodeId()); + LOG.debug("Clear Node state: {}", nodeState.getNodeId()); + nodeState = null; } } - final synchronized PCEPRequest removeRequest(final S id) { - final PCEPRequest ret = this.requests.remove(id); - if (ret != null && this.listenerState != null) { - this.listenerState.processRequestStats(ret.getElapsedMillis()); + final synchronized PCEPRequest removeRequest(final SrpIdNumber id) { + final PCEPRequest ret = requests.remove(id); + if (ret != null && listenerState != null) { + listenerState.processRequestStats(ret.getElapsedMillis()); } LOG.trace("Removed request {} object {}", id, ret); return ret; } - final synchronized ListenableFuture sendMessage(final Message message, final S requestId, + final synchronized ListenableFuture sendMessage(final Message message, final SrpIdNumber requestId, final Metadata metadata) { - final var sendFuture = this.session.sendMessage(message); - this.listenerState.updateStatefulSentMsg(message); + final var sendFuture = session.sendMessage(message); + listenerState.updateStatefulSentMsg(message); final PCEPRequest req = new PCEPRequest(metadata); - this.requests.put(requestId, req); - final short rpcTimeout = this.serverSessionManager.getRpcTimeout(); + requests.put(requestId, req); + final short rpcTimeout = serverSessionManager.getRpcTimeout(); LOG.trace("RPC response timeout value is {} seconds", rpcTimeout); if (rpcTimeout > 0) { setupTimeoutHandler(requestId, req, rpcTimeout); @@ -386,7 +419,7 @@ public abstract class AbstractTopologySessionListener implements TopologyS sendFuture.addListener((FutureListener) future -> { if (!future.isSuccess()) { synchronized (AbstractTopologySessionListener.this) { - AbstractTopologySessionListener.this.requests.remove(requestId); + requests.remove(requestId); } req.done(OperationResults.UNSENT); LOG.info("Failed to send request {}, instruction cancelled", requestId, future.cause()); @@ -399,13 +432,13 @@ public abstract class AbstractTopologySessionListener implements TopologyS return req.getFuture(); } - private void setupTimeoutHandler(final S requestId, final PCEPRequest req, final short timeout) { + private void setupTimeoutHandler(final SrpIdNumber requestId, final PCEPRequest req, final short timeout) { final Timer timer = req.getTimer(); timer.schedule(new TimerTask() { @Override public void run() { synchronized (AbstractTopologySessionListener.this) { - AbstractTopologySessionListener.this.requests.remove(requestId); + requests.remove(requestId); } req.done(); LOG.info("Request {} timed-out waiting for response", requestId); @@ -424,12 +457,12 @@ public abstract class AbstractTopologySessionListener implements TopologyS * @param solicited True if the update was solicited * @param remove True if this is an LSP path removal */ - protected final synchronized void updateLsp(final MessageContext ctx, final L id, final String lspName, + protected final synchronized void updateLsp(final MessageContext ctx, final PlspId id, final String lspName, final ReportedLspBuilder rlb, final boolean solicited, final boolean remove) { final String name; if (lspName == null) { - name = this.lsps.get(id); + name = lsps.get(id); if (name == null) { LOG.error("PLSPID {} seen for the first time, not reporting the LSP", id); return; @@ -439,10 +472,9 @@ public abstract class AbstractTopologySessionListener implements TopologyS } LOG.debug("Saved LSP {} with name {}", id, name); - this.lsps.put(id, name); - + lsps.put(id, name); - final ReportedLsp previous = this.lspData.get(name); + final ReportedLsp previous = lspData.get(name); // if no previous report about the lsp exist, just proceed if (previous != null) { final Map updatedPaths = makeBeforeBreak(rlb, previous, name, remove); @@ -459,16 +491,16 @@ public abstract class AbstractTopologySessionListener implements TopologyS // If this is an unsolicited update. We need to make sure we retain the metadata already present if (solicited) { - this.nodeState.setLspMetadata(name, rlb.getMetadata()); + nodeState.setLspMetadata(name, rlb.getMetadata()); } else { - rlb.setMetadata(this.nodeState.getLspMetadata(name)); + rlb.setMetadata(nodeState.getLspMetadata(name)); } final ReportedLsp rl = rlb.build(); - ctx.trans.put(LogicalDatastoreType.OPERATIONAL, this.pccIdentifier.child(ReportedLsp.class, rlb.key()), rl); + ctx.trans.put(LogicalDatastoreType.OPERATIONAL, pccIdentifier.child(ReportedLsp.class, rlb.key()), rl); LOG.debug("LSP {} updated to MD-SAL", name); - this.lspData.put(name, rl); + lspData.put(name, rl); } private static Map makeBeforeBreak(final ReportedLspBuilder rlb, final ReportedLsp previous, @@ -524,26 +556,25 @@ public abstract class AbstractTopologySessionListener implements TopologyS * @param ctx Message context */ protected final synchronized void stateSynchronizationAchieved(final MessageContext ctx) { - if (this.synced.getAndSet(true)) { + if (synced.getAndSet(true)) { LOG.debug("State synchronization achieved while synchronizing, not updating state"); return; } - if (this.triggeredResyncInProcess) { - this.triggeredResyncInProcess = false; - } + + triggeredResyncInProcess = false; updatePccNode(ctx, new PathComputationClientBuilder().setStateSync(PccSyncState.Synchronized).build()); // The node has completed synchronization, cleanup metadata no longer reported back - this.nodeState.cleanupExcept(this.lsps.values()); - LOG.debug("Session {} achieved synchronized state", this.session); + nodeState.cleanupExcept(lsps.values()); + LOG.debug("Session {} achieved synchronized state", session); } protected final synchronized void updatePccNode(final MessageContext ctx, final PathComputationClient pcc) { - ctx.trans.merge(LogicalDatastoreType.OPERATIONAL, this.pccIdentifier, pcc); + ctx.trans.merge(LogicalDatastoreType.OPERATIONAL, pccIdentifier, pcc); } - protected final InstanceIdentifier lspIdentifier(final String name) { - return this.pccIdentifier.child(ReportedLsp.class, new ReportedLspKey(name)); + protected final @NonNull InstanceIdentifier lspIdentifier(final String name) { + return pccIdentifier.child(ReportedLsp.class, new ReportedLspKey(name)); } /** @@ -552,16 +583,16 @@ public abstract class AbstractTopologySessionListener implements TopologyS * @param ctx Message Context * @param id Revision-specific LSP identifier */ - protected final synchronized void removeLsp(final MessageContext ctx, final L id) { - final String name = this.lsps.remove(id); + protected final synchronized void removeLsp(final MessageContext ctx, final PlspId id) { + final String name = lsps.remove(id); LOG.debug("LSP {} removed", name); ctx.trans.delete(LogicalDatastoreType.OPERATIONAL, lspIdentifier(name)); - this.lspData.remove(name); + lspData.remove(name); } @Holding("this") - final String lookupLspName(final L id) { - return this.lsps.get(requireNonNull(id, "ID parameter null.")); + final String lookupLspName(final PlspId id) { + return lsps.get(requireNonNull(id, "ID parameter null.")); } /** @@ -571,25 +602,18 @@ public abstract class AbstractTopologySessionListener implements TopologyS * @param id InstanceIdentifier of the node * @return null if the node does not exists, or operational data */ - final synchronized FluentFuture> - readOperationalData(final InstanceIdentifier id) { - if (this.nodeState == null) { - return null; - } - return this.nodeState.readOperationalData(id); + final synchronized FluentFuture> readOperationalData( + final InstanceIdentifier id) { + return nodeState == null ? null : nodeState.readOperationalData(id); } protected abstract Object validateReportedLsp(Optional rep, LspId input); - protected abstract void loadLspData(Node node, Map lspData, Map lsps, + protected abstract void loadLspData(Node node, Map lspData, Map lsps, boolean incrementalSynchro); final boolean isLspDbPersisted() { - return this.syncOptimization != null && this.syncOptimization.isSyncAvoidanceEnabled(); - } - - final boolean isLspDbRetreived() { - return this.syncOptimization != null && this.syncOptimization.isDbVersionPresent(); + return syncOptimization != null && syncOptimization.isSyncAvoidanceEnabled(); } /** @@ -597,25 +621,25 @@ public abstract class AbstractTopologySessionListener implements TopologyS * LSP-DB-VERSION TLV values doesnt match, and LSP-SYNC-CAPABILITY is enabled. */ final synchronized boolean isIncrementalSynchro() { - return this.syncOptimization != null && this.syncOptimization.isSyncAvoidanceEnabled() - && this.syncOptimization.isDeltaSyncEnabled(); + return syncOptimization != null && syncOptimization.isSyncAvoidanceEnabled() + && syncOptimization.isDeltaSyncEnabled(); } final synchronized boolean isTriggeredInitialSynchro() { - return this.syncOptimization != null && this.syncOptimization.isTriggeredInitSyncEnabled(); + return syncOptimization != null && syncOptimization.isTriggeredInitSyncEnabled(); } final synchronized boolean isTriggeredReSyncEnabled() { - return this.syncOptimization != null && this.syncOptimization.isTriggeredReSyncEnabled(); + return syncOptimization != null && syncOptimization.isTriggeredReSyncEnabled(); } protected final synchronized boolean isSynchronized() { - return this.syncOptimization != null && this.syncOptimization.doesLspDbMatch(); + return syncOptimization != null && syncOptimization.doesLspDbMatch(); } @Override - public int getDelegatedLspsCount() { - return Math.toIntExact(this.lspData.values().stream() + public final int getDelegatedLspsCount() { + return Math.toIntExact(lspData.values().stream() .map(ReportedLsp::getPath).filter(pathList -> pathList != null && !pathList.isEmpty()) // pick the first path, as delegate status should be same in each path .map(pathList -> pathList.values().iterator().next()) @@ -626,10 +650,26 @@ public abstract class AbstractTopologySessionListener implements TopologyS } @Override - public boolean isSessionSynchronized() { - return this.synced.get(); + public final boolean isSessionSynchronized() { + return synced.get(); } + @Override + public final boolean isInitiationCapability() { + return initiationCapability.get(); + } + + @Override + public final boolean isStatefulCapability() { + return statefulCapability.get(); + } + + @Override + public final boolean isLspUpdateCapability() { + return lspUpdateCapability.get(); + } + + @Override public synchronized ListenableFuture> tearDownSession(final TearDownSessionInput input) { close();