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%2FServerSessionManager.java;h=972713afad40b6a8402cda5a3b75af4af7a3e36b;hb=a4cf3c1ad99445d6e9aa7fe1ef5afd4c28a4a0e4;hp=33863186cb3aa898afc9a9b03b1e22e77190e3c6;hpb=4d2a6ddcf804cdcb6451f7edbd7334e7c2119b86;p=bgpcep.git diff --git a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/ServerSessionManager.java b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/ServerSessionManager.java old mode 100755 new mode 100644 index 33863186cb..972713afad --- a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/ServerSessionManager.java +++ b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/ServerSessionManager.java @@ -14,163 +14,214 @@ import com.google.common.util.concurrent.FluentFuture; import com.google.common.util.concurrent.FutureCallback; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.MoreExecutors; +import com.google.common.util.concurrent.SettableFuture; +import io.netty.util.HashedWheelTimer; +import io.netty.util.Timer; import java.net.InetAddress; -import java.net.InetSocketAddress; -import java.util.ArrayList; import java.util.HashMap; +import java.util.List; import java.util.Map; -import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; -import javax.annotation.concurrent.GuardedBy; -import org.opendaylight.bgpcep.pcep.topology.provider.config.PCEPTopologyConfiguration; -import org.opendaylight.bgpcep.pcep.topology.provider.config.PCEPTopologyProviderDependencies; -import org.opendaylight.bgpcep.pcep.topology.spi.stats.TopologySessionStatsRegistry; +import org.checkerframework.checker.lock.qual.GuardedBy; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.bgpcep.pcep.server.PceServerProvider; import org.opendaylight.mdsal.binding.api.WriteTransaction; import org.opendaylight.mdsal.common.api.CommitInfo; import org.opendaylight.mdsal.common.api.LogicalDatastoreType; -import org.opendaylight.protocol.pcep.PCEPDispatcherDependencies; -import org.opendaylight.protocol.pcep.PCEPPeerProposal; -import org.opendaylight.protocol.pcep.PCEPSession; -import org.opendaylight.protocol.pcep.PCEPSessionListener; import org.opendaylight.protocol.pcep.PCEPSessionListenerFactory; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.graph.rev191125.graph.topology.GraphKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.stats.rev171113.PcepSessionState; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.open.TlvsBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.AddLspArgs; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.EnsureLspOperationalInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.OperationResult; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.RemoveLspArgs; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.TearDownSessionInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.TopologyTypes1; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.TopologyTypes1Builder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.TriggerSyncArgs; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.UpdateLspArgs; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev171025.topology.pcep.type.TopologyPcepBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.AddLspArgs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.EnsureLspOperationalInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.OperationResult; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.RemoveLspArgs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.TearDownSessionInput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.TearDownSessionInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.TopologyTypes1Builder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.TriggerSyncArgs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.UpdateLspArgs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev200120.topology.pcep.type.TopologyPcepBuilder; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId; -import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.TopologyTypesBuilder; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; -import org.opendaylight.yangtools.yang.common.RpcError; +import org.opendaylight.yangtools.yang.common.ErrorType; import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.common.RpcResultBuilder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -final class ServerSessionManager implements PCEPSessionListenerFactory, TopologySessionRPCs, PCEPPeerProposal, - TopologySessionStatsRegistry { +// Non-final for testing +class ServerSessionManager implements PCEPSessionListenerFactory, TopologySessionRPCs { private static final Logger LOG = LoggerFactory.getLogger(ServerSessionManager.class); private static final long DEFAULT_HOLD_STATE_NANOS = TimeUnit.MINUTES.toNanos(5); - private static final String FAILURE_MSG = "Failed to find session"; + + private final @NonNull KeyedInstanceIdentifier topology; + private final @NonNull PCEPTopologyProviderDependencies dependencies; + private final @NonNull HashedWheelTimer timer = new HashedWheelTimer(); + @VisibleForTesting final AtomicBoolean isClosed = new AtomicBoolean(false); @GuardedBy("this") private final Map nodes = new HashMap<>(); @GuardedBy("this") private final Map state = new HashMap<>(); - private final TopologySessionListenerFactory listenerFactory; - private final InstanceIdentifier topology; - private final PCEPStatefulPeerProposal peerProposal; - private final short rpcTimeout; - private final PCEPTopologyProviderDependencies dependenciesProvider; - private final PCEPDispatcherDependencies pcepDispatcherDependencies; - - ServerSessionManager( - final PCEPTopologyProviderDependencies dependenciesProvider, - final TopologySessionListenerFactory listenerFactory, - final PCEPTopologyConfiguration configDependencies) { - this.dependenciesProvider = requireNonNull(dependenciesProvider); - this.topology = requireNonNull(configDependencies.getTopology()); - this.listenerFactory = requireNonNull(listenerFactory); - this.peerProposal = PCEPStatefulPeerProposal - .createStatefulPeerProposal(this.dependenciesProvider.getDataBroker(), this.topology); - this.rpcTimeout = configDependencies.getRpcTimeout(); - this.pcepDispatcherDependencies = new PCEPDispatcherDependenciesImpl(this, configDependencies); + + private volatile short rpcTimeout; + + private final GraphKey graphKey; + + ServerSessionManager(final KeyedInstanceIdentifier instanceIdentifier, + final PCEPTopologyProviderDependencies dependencies, final short rpcTimeout, final GraphKey graphKey) { + this.dependencies = requireNonNull(dependencies); + topology = requireNonNull(instanceIdentifier); + this.rpcTimeout = rpcTimeout; + this.graphKey = requireNonNull(graphKey); } - private static NodeId createNodeId(final InetAddress addr) { - return new NodeId("pcc://" + addr.getHostAddress()); + // Initialize the operational view of the topology. + final ListenableFuture start() { + LOG.info("Creating PCEP Topology {}", topologyId()); + final var tx = dependencies.getDataBroker().newWriteOnlyTransaction(); + tx.put(LogicalDatastoreType.OPERATIONAL, topology, new TopologyBuilder() + .withKey(topology.getKey()) + .setTopologyTypes(new TopologyTypesBuilder() + .addAugmentation(new TopologyTypes1Builder().setTopologyPcep(new TopologyPcepBuilder().build()).build()) + .build()) + .build()); + + final var future = SettableFuture.create(); + final var txFuture = tx.commit(); + txFuture.addCallback(new FutureCallback() { + @Override + public void onSuccess(final CommitInfo result) { + LOG.info("PCEP Topology {} created successfully.", topologyId()); + isClosed.set(false); + future.set(Boolean.TRUE); + } + + @Override + public void onFailure(final Throwable failure) { + LOG.error("Failed to create PCEP Topology {}.", topologyId(), failure); + isClosed.set(true); + future.set(Boolean.FALSE); + } + }, MoreExecutors.directExecutor()); + + // Register this new topology to PCE Server + final PceServerProvider server = dependencies.getPceServerProvider(); + if (server != null) { + server.registerPcepTopology(topology, graphKey); + } + return future; } - /** - * Create Base Topology. - */ - synchronized void instantiateServiceInstance() { - final TopologyKey key = InstanceIdentifier.keyOf(this.topology); - final TopologyId topologyId = key.getTopologyId(); - final WriteTransaction tx = this.dependenciesProvider.getDataBroker().newWriteOnlyTransaction(); - tx.put(LogicalDatastoreType.OPERATIONAL, this.topology, new TopologyBuilder().withKey(key) - .setTopologyId(topologyId).setTopologyTypes(new TopologyTypesBuilder() - .addAugmentation(TopologyTypes1.class, new TopologyTypes1Builder().setTopologyPcep( - new TopologyPcepBuilder().build()).build()).build()) - .setNode(new ArrayList<>()).build(), true); - try { - tx.commit().get(); - LOG.info("PCEP Topology {} created successfully.", topologyId.getValue()); - ServerSessionManager.this.isClosed.set(false); - } catch (final ExecutionException | InterruptedException throwable) { - LOG.error("Failed to create PCEP Topology {}.", topologyId.getValue(), throwable); - ServerSessionManager.this.isClosed.set(true); + final synchronized FluentFuture stop() { + if (isClosed.getAndSet(true)) { + LOG.error("Session Manager has already been closed."); + return CommitInfo.emptyFluentFuture(); + } + + // Clean up sessions + for (final TopologySessionListener node : nodes.values()) { + node.close(); + } + nodes.clear(); + + // Clean up remembered metadata + for (final TopologyNodeState topologyNodeState : state.values()) { + topologyNodeState.close(); + } + state.clear(); + + // Stop the timer + final var cancelledTasks = timer.stop().size(); + if (cancelledTasks != 0) { + LOG.warn("Stopped timer with {} remaining tasks", cancelledTasks); } + + // Un-Register Pcep Topology into PCE Server + final PceServerProvider server = dependencies.getPceServerProvider(); + if (server != null) { + server.unRegisterPcepTopology(topology); + } + + final WriteTransaction t = dependencies.getDataBroker().newWriteOnlyTransaction(); + t.delete(LogicalDatastoreType.OPERATIONAL, topology); + final FluentFuture future = t.commit(); + future.addCallback(new FutureCallback() { + @Override + public void onSuccess(final CommitInfo result) { + LOG.debug("Topology {} removed", topology); + } + + @Override + public void onFailure(final Throwable throwable) { + LOG.warn("Failed to remove Topology {}", topology, throwable); + } + }, MoreExecutors.directExecutor()); + return future; } - synchronized void releaseNodeState(final TopologyNodeState nodeState, final PCEPSession session, + final synchronized void releaseNodeState(final TopologyNodeState nodeState, final InetAddress peerAddress, final boolean persistNode) { - if (this.isClosed.get()) { + if (isClosed.get()) { LOG.error("Session Manager has already been closed."); return; } - this.nodes.remove(createNodeId(session.getRemoteAddress())); + final NodeId nodeId = createNodeId(peerAddress); + nodes.remove(nodeId); + state.remove(nodeId); if (nodeState != null) { LOG.debug("Node {} unbound", nodeState.getNodeId()); nodeState.released(persistNode); } } - synchronized TopologyNodeState takeNodeState(final InetAddress address, + final synchronized TopologyNodeState takeNodeState(final InetAddress address, final TopologySessionListener sessionListener, final boolean retrieveNode) { final NodeId id = createNodeId(address); - if (this.isClosed.get()) { - LOG.error("Server Session Manager is closed. Unable to create topology node {} with listener {}", - id, sessionListener); + if (isClosed.get()) { + LOG.error("Server Session Manager is closed. Unable to create topology node {} with listener {}", id, + sessionListener); return null; } LOG.debug("Node {} requested by listener {}", id, sessionListener); - TopologyNodeState ret = this.state.get(id); + TopologyNodeState ret = state.get(id); if (ret == null) { - ret = new TopologyNodeState(this.dependenciesProvider.getDataBroker(), this.topology, id, - DEFAULT_HOLD_STATE_NANOS); + ret = new TopologyNodeState(dependencies.getDataBroker(), topology, id, DEFAULT_HOLD_STATE_NANOS); LOG.debug("Created topology node {} for id {} at {}", ret, id, ret.getNodeId()); - this.state.put(id, ret); + state.put(id, ret); } // if another listener requests the same session, close it - final TopologySessionListener existingSessionListener = this.nodes.get(id); + final TopologySessionListener existingSessionListener = nodes.get(id); if (existingSessionListener != null && !sessionListener.equals(existingSessionListener)) { LOG.error("New session listener {} is in conflict with existing session listener {} on node {}," + " closing the existing one.", existingSessionListener, sessionListener, id); existingSessionListener.close(); } ret.taken(retrieveNode); - this.nodes.put(id, sessionListener); + nodes.put(id, sessionListener); LOG.debug("Node {} bound to listener {}", id, sessionListener); return ret; } + // Non-final for testing @Override - public PCEPSessionListener getSessionListener() { - return this.listenerFactory.createTopologySessionListener(this); + public PCEPTopologySessionListener getSessionListener() { + return new PCEPTopologySessionListener(this); } private synchronized TopologySessionListener checkSessionPresence(final NodeId nodeId) { // Get the listener corresponding to the node - final TopologySessionListener l = this.nodes.get(nodeId); + final TopologySessionListener l = nodes.get(nodeId); if (l == null) { LOG.debug("Session for node {} not found", nodeId); return null; @@ -179,100 +230,85 @@ final class ServerSessionManager implements PCEPSessionListenerFactory, Topology } @Override - public synchronized ListenableFuture addLsp(final AddLspArgs input) { + public final synchronized ListenableFuture addLsp(final AddLspArgs input) { final TopologySessionListener l = checkSessionPresence(input.getNode()); return l != null ? l.addLsp(input) : OperationResults.UNSENT.future(); } @Override - public synchronized ListenableFuture removeLsp(final RemoveLspArgs input) { + public final synchronized ListenableFuture removeLsp(final RemoveLspArgs input) { final TopologySessionListener l = checkSessionPresence(input.getNode()); return l != null ? l.removeLsp(input) : OperationResults.UNSENT.future(); } @Override - public synchronized ListenableFuture updateLsp(final UpdateLspArgs input) { + public final synchronized ListenableFuture updateLsp(final UpdateLspArgs input) { final TopologySessionListener l = checkSessionPresence(input.getNode()); return l != null ? l.updateLsp(input) : OperationResults.UNSENT.future(); } @Override - public synchronized ListenableFuture ensureLspOperational(final EnsureLspOperationalInput input) { + public final synchronized ListenableFuture ensureLspOperational( + final EnsureLspOperationalInput input) { final TopologySessionListener l = checkSessionPresence(input.getNode()); return l != null ? l.ensureLspOperational(input) : OperationResults.UNSENT.future(); } @Override - public synchronized ListenableFuture triggerSync(final TriggerSyncArgs input) { + public final synchronized ListenableFuture triggerSync(final TriggerSyncArgs input) { final TopologySessionListener l = checkSessionPresence(input.getNode()); return l != null ? l.triggerSync(input) : OperationResults.UNSENT.future(); } @Override - public ListenableFuture> tearDownSession(final TearDownSessionInput input) { - final TopologySessionListener listener = checkSessionPresence(input.getNode()); - if (listener == null) { - return RpcResultBuilder.failed().withError(RpcError.ErrorType.RPC, - FAILURE_MSG).buildFuture(); + public final ListenableFuture> tearDownSession(final TearDownSessionInput input) { + final NodeId nodeId = input.getNode(); + final TopologySessionListener listener = checkSessionPresence(nodeId); + if (listener != null) { + return listener.tearDownSession(input); } - return listener.tearDownSession(input); + return RpcResultBuilder.failed() + .withError(ErrorType.RPC, "Failed to find session " + nodeId) + .buildFuture(); } - synchronized FluentFuture closeServiceInstance() { - if (this.isClosed.getAndSet(true)) { - LOG.error("Session Manager has already been closed."); - return CommitInfo.emptyFluentFuture(); - } - for (final TopologySessionListener node : this.nodes.values()) { - node.close(); - } - this.nodes.clear(); - for (final TopologyNodeState topologyNodeState : this.state.values()) { - topologyNodeState.close(); - } - this.state.clear(); - - final WriteTransaction t = this.dependenciesProvider.getDataBroker().newWriteOnlyTransaction(); - t.delete(LogicalDatastoreType.OPERATIONAL, this.topology); - final FluentFuture future = t.commit(); - future.addCallback(new FutureCallback() { - @Override - public void onSuccess(final CommitInfo result) { - LOG.debug("Topology {} removed", ServerSessionManager.this.topology); - } + final @NonNull Timer timer() { + return timer; + } - @Override - public void onFailure(final Throwable throwable) { - LOG.warn("Failed to remove Topology {}", ServerSessionManager.this.topology, throwable); - } - }, MoreExecutors.directExecutor()); - return future; + final short getRpcTimeout() { + return rpcTimeout; } - @Override - public void setPeerSpecificProposal(final InetSocketAddress address, final TlvsBuilder openBuilder) { - requireNonNull(address); - final byte[] speakerId = this.pcepDispatcherDependencies.getSpeakerIdMapping().get(address.getAddress()); - this.peerProposal.setPeerProposal(createNodeId(address.getAddress()), openBuilder, speakerId); + final void setRpcTimeout(final short rpcTimeout) { + this.rpcTimeout = rpcTimeout; } - short getRpcTimeout() { - return this.rpcTimeout; + final void tearDownSessions(final List outdatedNodes) { + for (var address : outdatedNodes) { + tearDownSession(new TearDownSessionInputBuilder().setNode(createNodeId(address)).build()); + } } - @Override - public synchronized void bind(final KeyedInstanceIdentifier nodeId, + final synchronized void bind(final KeyedInstanceIdentifier nodeId, final PcepSessionState sessionState) { - this.dependenciesProvider.getStateRegistry().bind(nodeId, sessionState); + dependencies.getStateRegistry().bind(nodeId, sessionState); } - @Override - public synchronized void unbind(final KeyedInstanceIdentifier nodeId) { - this.dependenciesProvider.getStateRegistry().unbind(nodeId); + final synchronized void unbind(final KeyedInstanceIdentifier nodeId) { + dependencies.getStateRegistry().unbind(nodeId); + } + + final PCEPTopologyProviderDependencies getPCEPTopologyProviderDependencies() { + return dependencies; + } + + static @NonNull NodeId createNodeId(final InetAddress addr) { + return new NodeId("pcc://" + addr.getHostAddress()); } - PCEPDispatcherDependencies getPCEPDispatcherDependencies() { - return this.pcepDispatcherDependencies; + private @NonNull String topologyId() { + return TopologyUtils.friendlyId(topology); } } \ No newline at end of file