Eliminate PCEPDispatcherDependencies

This is a useless indirection hiding the things we are passing to the
dispatcher. Enumerate them explicitly, as we will be adding a few more
things as well.

JIRA: BGPCEP-962
Change-Id: Iaf950762547b6685c852e965591033fdc9024aed
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/pcep/api/src/main/java/org/opendaylight/protocol/pcep/PCEPDispatcher.java b/pcep/api/src/main/java/org/opendaylight/protocol/pcep/PCEPDispatcher.java
index cf14d08d8fb6b321a91ce21d1006143d6f542cef..04a11d4b1daf1642078fa87b4b34eb506d82d35a 100644 (file)
--- a/pcep/api/src/main/java/org/opendaylight/protocol/pcep/PCEPDispatcher.java
+++ b/pcep/api/src/main/java/org/opendaylight/protocol/pcep/PCEPDispatcher.java
@@ -8,7 +8,9 @@
 package org.opendaylight.protocol.pcep;
 
 import io.netty.channel.ChannelFuture;
+import java.net.InetSocketAddress;
 import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.protocol.concepts.KeyMapping;
 
 /**
  * Dispatcher class for creating servers and clients.
@@ -17,10 +19,13 @@ public interface PCEPDispatcher {
     /**
      * Creates server. Each server needs three factories to pass their instances to client sessions.
      *
-     * @param dispatcherDependencies contains required dependencies for instantiate a PCEP Server
-     * @return instance of PCEPServer
+     * @param listenAddress Server listen address
+     * @param tcpKeys RFC2385 TCP-MD5 keys
+     * @param negotiatorDependencies PCEPSessionNegotiatorFactoryDependencies
+     * @return A future completing when the PCEP server is created
      */
-    @NonNull ChannelFuture createServer(@NonNull PCEPDispatcherDependencies dispatcherDependencies);
+    @NonNull ChannelFuture createServer(@NonNull InetSocketAddress listenAddress, @NonNull KeyMapping tcpKeys,
+        @NonNull PCEPSessionNegotiatorFactoryDependencies negotiatorDependencies);
 
     @NonNull PCEPSessionNegotiatorFactory getPCEPSessionNegotiatorFactory();
 }

diff --git a/pcep/api/src/main/java/org/opendaylight/protocol/pcep/PCEPDispatcherDependencies.java b/pcep/api/src/main/java/org/opendaylight/protocol/pcep/PCEPDispatcherDependencies.java
deleted file mode 100644 (file)
index 0e33a9c..0000000
--- a/pcep/api/src/main/java/org/opendaylight/protocol/pcep/PCEPDispatcherDependencies.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2017 AT&T Intellectual Property. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.protocol.pcep;
-
-import java.net.InetSocketAddress;
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.protocol.concepts.KeyMapping;
-
-/**
- * Contains all required dependencies for instantiate a PCEPDispatcher.
- */
-@NonNullByDefault
-public interface PCEPDispatcherDependencies extends PCEPSessionNegotiatorFactoryDependencies {
-    /**
-     * Return the address to be bound with the server.
-     *
-     * @return ip address
-     */
-    InetSocketAddress getAddress();
-
-    /**
-     * RFC2385 key mapping.
-     *
-     * @return map containing Keys
-     */
-    KeyMapping getKeys();
-}

diff --git a/pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/PCEPDispatcherImpl.java b/pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/PCEPDispatcherImpl.java
index df874bb25c0d54f01cf5aac2e89825b394825ec0..4bb0892705869486eab1d6b87e03713af9fd4d24 100644 (file)
--- a/pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/PCEPDispatcherImpl.java
+++ b/pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/PCEPDispatcherImpl.java
@@ -9,6 +9,7 @@ package org.opendaylight.protocol.pcep.impl;
 
 import static java.util.Objects.requireNonNull;
 
+import com.google.common.annotations.VisibleForTesting;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.buffer.PooledByteBufAllocator;
 import io.netty.channel.ChannelFuture;
@@ -30,14 +31,13 @@ import io.netty.util.concurrent.Promise;
 import java.io.Closeable;
 import java.net.InetSocketAddress;
 import java.util.concurrent.TimeUnit;
-import org.checkerframework.checker.lock.qual.GuardedBy;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.protocol.concepts.KeyMapping;
 import org.opendaylight.protocol.pcep.MessageRegistry;
 import org.opendaylight.protocol.pcep.PCEPDispatcher;
-import org.opendaylight.protocol.pcep.PCEPDispatcherDependencies;
 import org.opendaylight.protocol.pcep.PCEPSession;
 import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactory;
+import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -48,13 +48,12 @@ public class PCEPDispatcherImpl implements PCEPDispatcher, Closeable {
     private static final Logger LOG = LoggerFactory.getLogger(PCEPDispatcherImpl.class);
     private static final Integer SOCKET_BACKLOG_SIZE = 128;
     private static final long TIMEOUT = 10;
+
     private final PCEPSessionNegotiatorFactory snf;
     private final PCEPHandlerFactory hf;
     private final EventLoopGroup bossGroup;
     private final EventLoopGroup workerGroup;
     private final EventExecutor executor;
-    @GuardedBy("this")
-    private KeyMapping keys;
 
     /**
      * Creates an instance of PCEPDispatcherImpl, gets the default selector and opens it.
@@ -80,27 +79,24 @@ public class PCEPDispatcherImpl implements PCEPDispatcher, Closeable {
     }
 
     @Override
-    public final synchronized ChannelFuture createServer(final PCEPDispatcherDependencies dispatcherDependencies) {
-        keys = dispatcherDependencies.getKeys();
-
+    public final synchronized ChannelFuture createServer(final InetSocketAddress listenAddress,
+            final KeyMapping tcpKeys, final PCEPSessionNegotiatorFactoryDependencies negotiatorDependencies) {
         final ChannelPipelineInitializer initializer = (ch, promise) -> {
             ch.pipeline().addLast(hf.getDecoders());
-            ch.pipeline().addLast("negotiator", snf
-                    .getSessionNegotiator(dispatcherDependencies, ch, promise));
+            ch.pipeline().addLast("negotiator", snf.getSessionNegotiator(negotiatorDependencies, ch, promise));
             ch.pipeline().addLast(hf.getEncoders());
         };
 
-        final ServerBootstrap b = createServerBootstrap(initializer);
-        final InetSocketAddress address = dispatcherDependencies.getAddress();
-        final ChannelFuture f = b.bind(address);
-        LOG.debug("Initiated server {} at {}.", f, address);
+        final ServerBootstrap b = createServerBootstrap(initializer, tcpKeys);
+        final ChannelFuture f = b.bind(listenAddress);
+        LOG.debug("Initiated server {} at {}.", f, listenAddress);
 
-        // FIXME: err, why are we resetting this?
-        keys = KeyMapping.of();
         return f;
     }
 
-    synchronized ServerBootstrap createServerBootstrap(final ChannelPipelineInitializer initializer) {
+    @VisibleForTesting
+    ServerBootstrap createServerBootstrap(final ChannelPipelineInitializer initializer,
+            final KeyMapping tcpKeys) {
         final ServerBootstrap b = new ServerBootstrap();
         b.childHandler(new ChannelInitializer<SocketChannel>() {
             @Override
@@ -118,9 +114,9 @@ public class PCEPDispatcherImpl implements PCEPDispatcher, Closeable {
         } else {
             b.channel(NioServerSocketChannel.class);
         }
-        if (!keys.isEmpty()) {
+        if (!tcpKeys.isEmpty()) {
             if (Epoll.isAvailable()) {
-                b.option(EpollChannelOption.TCP_MD5SIG, keys.asMap());
+                b.option(EpollChannelOption.TCP_MD5SIG, tcpKeys.asMap());
             } else {
                 throw new UnsupportedOperationException("Setting TCP-MD5 signatures is not supported",
                         Epoll.unavailabilityCause().getCause());

diff --git a/pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/PCEPDispatcherImplTest.java b/pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/PCEPDispatcherImplTest.java
index 4dd0067518105a4e57ea95abf9b631912c525de2..f700e5ca72abc2f14403a9b3c00735ad1c319e26 100644 (file)
--- a/pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/PCEPDispatcherImplTest.java
+++ b/pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/PCEPDispatcherImplTest.java
@@ -17,6 +17,7 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
@@ -47,10 +48,10 @@ import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.protocol.concepts.KeyMapping;
 import org.opendaylight.protocol.pcep.MessageRegistry;
-import org.opendaylight.protocol.pcep.PCEPDispatcherDependencies;
 import org.opendaylight.protocol.pcep.PCEPSession;
 import org.opendaylight.protocol.pcep.PCEPSessionListenerFactory;
 import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactory;
+import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
 import org.opendaylight.protocol.pcep.PCEPSessionProposalFactory;
 import org.opendaylight.protocol.pcep.spi.pojo.DefaultPCEPExtensionConsumerContext;
 import org.opendaylight.protocol.util.InetSocketAddressUtil;
@@ -71,7 +72,7 @@ public class PCEPDispatcherImplTest {
     @Mock
     private Channel mockChannel;
     @Mock
-    private PCEPDispatcherDependencies dispatcherDependencies;
+    private PCEPSessionNegotiatorFactoryDependencies negotiatorDependencies;
     @Mock
     private PCEPSessionListenerFactory listenerFactory;
     @Mock
@@ -96,8 +97,7 @@ public class PCEPDispatcherImplTest {
                 new DefaultPCEPSessionNegotiatorFactory(sessionProposal, errorPolicy),
                 eventLoopGroup, eventLoopGroup);
 
-        doReturn(KeyMapping.of()).when(dispatcherDependencies).getKeys();
-        doReturn(null).when(dispatcherDependencies).getPeerProposal();
+        doReturn(null).when(negotiatorDependencies).getPeerProposal();
 
         final PCEPDispatcherImpl dispatcher2 = new PCEPDispatcherImpl(msgReg,
                 new DefaultPCEPSessionNegotiatorFactory(sessionProposal, errorPolicy),
@@ -115,10 +115,10 @@ public class PCEPDispatcherImplTest {
         final InetSocketAddress clientAddr1 = InetSocketAddressUtil.getRandomLoopbackInetSocketAddress(port);
         final InetSocketAddress clientAddr2 = InetSocketAddressUtil.getRandomLoopbackInetSocketAddress(port);
 
-        doReturn(serverAddr).when(dispatcherDependencies).getAddress();
-        doReturn(listenerFactory).when(dispatcherDependencies).getListenerFactory();
+        doReturn(listenerFactory).when(negotiatorDependencies).getListenerFactory();
         doReturn(new SimpleSessionListener()).when(listenerFactory).getSessionListener();
-        final ChannelFuture futureChannel = dispatcher.createServer(dispatcherDependencies);
+        final ChannelFuture futureChannel = dispatcher.createServer(serverAddr, KeyMapping.of(),
+            negotiatorDependencies);
         futureChannel.sync();
 
         try (var session1 = (PCEPSessionImpl) pccMock.createClient(clientAddr1,
@@ -146,11 +146,10 @@ public class PCEPDispatcherImplTest {
         final InetSocketAddress serverAddr = new InetSocketAddress("0.0.0.0", port);
         final InetSocketAddress clientAddr = InetSocketAddressUtil.getRandomLoopbackInetSocketAddress(port);
 
-        doReturn(serverAddr).when(dispatcherDependencies).getAddress();
-        doReturn(listenerFactory).when(dispatcherDependencies).getListenerFactory();
+        doReturn(listenerFactory).when(negotiatorDependencies).getListenerFactory();
         doReturn(new SimpleSessionListener()).when(listenerFactory).getSessionListener();
 
-        dispatcher.createServer(dispatcherDependencies).sync();
+        dispatcher.createServer(serverAddr, KeyMapping.of(), negotiatorDependencies).sync();
         final Future<PCEPSession> futureClient = pccMock.createClient(clientAddr, RETRY_TIMER, CONNECT_TIMEOUT,
                 SimpleSessionListener::new);
         futureClient.sync();
@@ -171,10 +170,9 @@ public class PCEPDispatcherImplTest {
         final int port = InetSocketAddressUtil.getRandomPort();
         final InetSocketAddress clientAddr = InetSocketAddressUtil.getRandomLoopbackInetSocketAddress(port);
 
-        doReturn(new InetSocketAddress("0.0.0.0", port)).when(dispatcherDependencies).getAddress();
-        doReturn(listenerFactory).when(dispatcherDependencies).getListenerFactory();
+        doReturn(listenerFactory).when(negotiatorDependencies).getListenerFactory();
         doReturn(new SimpleSessionListener()).when(listenerFactory).getSessionListener();
-        dispatcher.createServer(dispatcherDependencies).sync();
+        dispatcher.createServer(new InetSocketAddress("0.0.0.0", port), KeyMapping.of(), negotiatorDependencies).sync();
         final PCEPSessionImpl session1 = (PCEPSessionImpl) pccMock.createClient(clientAddr,
                 RETRY_TIMER, CONNECT_TIMEOUT, SimpleSessionListener::new).get();
 
@@ -201,11 +199,9 @@ public class PCEPDispatcherImplTest {
             clientAddr1.getAddress(), "CLIENT1_ADDRESS",
             clientAddr2.getAddress(), "CLIENT2_ADDRESS"));
 
-        doReturn(new InetSocketAddress("0.0.0.0", port)).when(dispatcherDependencies).getAddress();
-
-        final ChannelFuture futureChannel = disp2Spy.createServer(dispatcherDependencies);
-        futureChannel.sync();
-        verify(disp2Spy).createServerBootstrap(any(PCEPDispatcherImpl.ChannelPipelineInitializer.class));
+        final ChannelFuture futureChannel = disp2Spy.createServer(new InetSocketAddress("0.0.0.0", port),
+            keys, negotiatorDependencies).sync();
+        verify(disp2Spy).createServerBootstrap(any(PCEPDispatcherImpl.ChannelPipelineInitializer.class), same(keys));
     }
 
     @After

diff --git a/pcep/pcc-mock/src/test/java/org/opendaylight/protocol/pcep/pcc/mock/PCCDispatcherImplTest.java b/pcep/pcc-mock/src/test/java/org/opendaylight/protocol/pcep/pcc/mock/PCCDispatcherImplTest.java
index 675d799063a8eb1f20577e87fdf5648053e9d38a..01130f4e255f2ded3264740b974b4fe8177d9484 100644 (file)
--- a/pcep/pcc-mock/src/test/java/org/opendaylight/protocol/pcep/pcc/mock/PCCDispatcherImplTest.java
+++ b/pcep/pcc-mock/src/test/java/org/opendaylight/protocol/pcep/pcc/mock/PCCDispatcherImplTest.java
@@ -29,8 +29,8 @@ import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.protocol.concepts.KeyMapping;
 import org.opendaylight.protocol.pcep.MessageRegistry;
 import org.opendaylight.protocol.pcep.PCEPDispatcher;
-import org.opendaylight.protocol.pcep.PCEPDispatcherDependencies;
 import org.opendaylight.protocol.pcep.PCEPSession;
+import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
 import org.opendaylight.protocol.pcep.PCEPSessionProposalFactory;
 import org.opendaylight.protocol.pcep.impl.BasePCEPSessionProposalFactory;
 import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory;
@@ -58,7 +58,7 @@ public class PCCDispatcherImplTest {
     private MessageRegistry registry;
 
     @Mock
-    PCEPDispatcherDependencies dispatcherDependencies;
+    PCEPSessionNegotiatorFactoryDependencies negotiatorDependencies;
 
     @Before
     public void setUp() {
@@ -71,9 +71,7 @@ public class PCCDispatcherImplTest {
         pcepDispatcher = new PCEPDispatcherImpl(registry, nf, bossGroup, workerGroup);
         serverAddress = InetSocketAddressUtil.getRandomLoopbackInetSocketAddress();
         clientAddress = InetSocketAddressUtil.getRandomLoopbackInetSocketAddress(0);
-        doReturn(KeyMapping.of()).when(dispatcherDependencies).getKeys();
-        doReturn(serverAddress).when(dispatcherDependencies).getAddress();
-        doReturn(null).when(dispatcherDependencies).getPeerProposal();
+        doReturn(null).when(negotiatorDependencies).getPeerProposal();
     }
 
     @After
@@ -92,9 +90,10 @@ public class PCCDispatcherImplTest {
         final Future<PCEPSession> futureSession = dispatcher.createClient(serverAddress, 1,
             new TestingSessionListenerFactory(), nf, KeyMapping.of(), clientAddress);
         final TestingSessionListenerFactory slf = new TestingSessionListenerFactory();
-        doReturn(slf).when(dispatcherDependencies).getListenerFactory();
+        doReturn(slf).when(negotiatorDependencies).getListenerFactory();
 
-        final ChannelFuture futureServer = pcepDispatcher.createServer(dispatcherDependencies);
+        final ChannelFuture futureServer = pcepDispatcher.createServer(serverAddress, KeyMapping.of(),
+            negotiatorDependencies);
         futureServer.sync();
         final Channel channel = futureServer.channel();
         assertNotNull(futureSession.get());
@@ -110,8 +109,9 @@ public class PCCDispatcherImplTest {
         pcepDispatcher = new PCEPDispatcherImpl(registry, nf, bossGroup, workerGroup);
 
         final TestingSessionListenerFactory slf2 = new TestingSessionListenerFactory();
-        doReturn(slf2).when(dispatcherDependencies).getListenerFactory();
-        final ChannelFuture future2 = pcepDispatcher.createServer(dispatcherDependencies);
+        doReturn(slf2).when(negotiatorDependencies).getListenerFactory();
+        final ChannelFuture future2 = pcepDispatcher.createServer(serverAddress, KeyMapping.of(),
+            negotiatorDependencies);
         future2.sync();
         final Channel channel2 = future2.channel();
         final TestingSessionListener sl2 = checkSessionListenerNotNull(slf2,

diff --git a/pcep/pcc-mock/src/test/java/org/opendaylight/protocol/pcep/pcc/mock/PCCMockCommon.java b/pcep/pcc-mock/src/test/java/org/opendaylight/protocol/pcep/pcc/mock/PCCMockCommon.java
index fdddbd57d421bef15d67d23d07dd27677ea7021a..d91d65e0c21b2dd6b1cd5d49059edcb65a6373fc 100644 (file)
--- a/pcep/pcc-mock/src/test/java/org/opendaylight/protocol/pcep/pcc/mock/PCCMockCommon.java
+++ b/pcep/pcc-mock/src/test/java/org/opendaylight/protocol/pcep/pcc/mock/PCCMockCommon.java
@@ -34,11 +34,11 @@ import org.opendaylight.protocol.concepts.KeyMapping;
 import org.opendaylight.protocol.pcep.MessageRegistry;
 import org.opendaylight.protocol.pcep.PCEPCapability;
 import org.opendaylight.protocol.pcep.PCEPDispatcher;
-import org.opendaylight.protocol.pcep.PCEPDispatcherDependencies;
 import org.opendaylight.protocol.pcep.PCEPPeerProposal;
 import org.opendaylight.protocol.pcep.PCEPSession;
 import org.opendaylight.protocol.pcep.PCEPSessionListenerFactory;
 import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactory;
+import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
 import org.opendaylight.protocol.pcep.ietf.stateful.StatefulActivator;
 import org.opendaylight.protocol.pcep.impl.BasePCEPSessionProposalFactory;
 import org.opendaylight.protocol.pcep.impl.DefaultPCEPSessionNegotiatorFactory;
@@ -131,7 +131,7 @@ public abstract class PCCMockCommon {
         optimizationsActivator.start(extensionProvider);
 
         final ChannelFuture future = pceDispatcher
-                .createServer(new DispatcherDependencies(serverAddress2, factory, peerProposal));
+                .createServer(serverAddress2, KeyMapping.of(), new NegotiatorDependencies(factory, peerProposal));
         waitFutureSuccess(future);
         return future.channel();
     }
@@ -233,31 +233,16 @@ public abstract class PCCMockCommon {
         return checkSessionListenerNotNull(factory, localAddress.getHostString());
     }
 
-    private static class DispatcherDependencies implements PCEPDispatcherDependencies {
-        private final KeyMapping keys = KeyMapping.of();
-        private final InetSocketAddress address;
+    private static class NegotiatorDependencies implements PCEPSessionNegotiatorFactoryDependencies {
         private final TestingSessionListenerFactory listenerFactory;
         private final PCEPPeerProposal peerProposal;
 
-        DispatcherDependencies(
-                final InetSocketAddress address,
-                final TestingSessionListenerFactory listenerFactory,
+        NegotiatorDependencies(final TestingSessionListenerFactory listenerFactory,
                 final PCEPPeerProposal peerProposal) {
-            this.address = address;
             this.listenerFactory = listenerFactory;
             this.peerProposal = peerProposal;
         }
 
-        @Override
-        public InetSocketAddress getAddress() {
-            return address;
-        }
-
-        @Override
-        public KeyMapping getKeys() {
-            return keys;
-        }
-
         @Override
         public PCEPSessionListenerFactory getListenerFactory() {
             return listenerFactory;

diff --git a/pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/Main.java b/pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/Main.java
index 7a532859eecdfeba0bd8aba5f2f410cf245ef289..3f131176f081bd1e85bb17b604bae84f161729e6 100644 (file)
--- a/pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/Main.java
+++ b/pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/Main.java
@@ -15,6 +15,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.ServiceLoader;
 import java.util.concurrent.ExecutionException;
+import org.opendaylight.protocol.concepts.KeyMapping;
 import org.opendaylight.protocol.pcep.MessageRegistry;
 import org.opendaylight.protocol.pcep.PCEPCapability;
 import org.opendaylight.protocol.pcep.PCEPSessionProposalFactory;
@@ -144,6 +145,6 @@ public final class Main {
         final PCEPDispatcherImpl dispatcher = new PCEPDispatcherImpl(handlerRegistry,
             new DefaultPCEPSessionNegotiatorFactory(spf, ERROR_POLICY),
             new NioEventLoopGroup(), new NioEventLoopGroup());
-        dispatcher.createServer(new TestToolPCEPDispatcherDependencies(address)).get();
+        dispatcher.createServer(address, KeyMapping.of(), new TestToolPCEPNegotiatorDependencies()).get();
     }
 }

diff --git a/pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/TestToolPCEPDispatcherDependencies.java b/pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/TestToolPCEPNegotiatorDependencies.java
similarity index 54%
rename from pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/TestToolPCEPDispatcherDependencies.java
rename to pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/TestToolPCEPNegotiatorDependencies.java
index 6c06411a878f9c874cc1410fc23434f812ac03ed..756e8cbae79ff8c2a971d8370006577b9a08b05a 100644 (file)
--- a/pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/TestToolPCEPDispatcherDependencies.java
+++ b/pcep/testtool/src/main/java/org/opendaylight/protocol/pcep/testtool/TestToolPCEPNegotiatorDependencies.java
@@ -7,29 +7,12 @@
  */
 package org.opendaylight.protocol.pcep.testtool;
 
-import java.net.InetSocketAddress;
 import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.protocol.concepts.KeyMapping;
-import org.opendaylight.protocol.pcep.PCEPDispatcherDependencies;
 import org.opendaylight.protocol.pcep.PCEPSessionListenerFactory;
+import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
 
-public final class TestToolPCEPDispatcherDependencies implements PCEPDispatcherDependencies {
+public final class TestToolPCEPNegotiatorDependencies implements PCEPSessionNegotiatorFactoryDependencies {
     private final @NonNull PCEPSessionListenerFactory listenerFactory = new TestingSessionListenerFactory();
-    private final InetSocketAddress address;
-
-    TestToolPCEPDispatcherDependencies(final InetSocketAddress address) {
-        this.address = address;
-    }
-
-    @Override
-    public InetSocketAddress getAddress() {
-        return address;
-    }
-
-    @Override
-    public KeyMapping getKeys() {
-        return KeyMapping.of();
-    }
 
     @Override
     public PCEPSessionListenerFactory getListenerFactory() {

diff --git a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPDispatcherDependenciesImpl.java b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPSessionNegotiatorFactoryDependenciesImpl.java
similarity index 57%
rename from pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPDispatcherDependenciesImpl.java
rename to pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPSessionNegotiatorFactoryDependenciesImpl.java
index 59ed19f1baa337c42f0f86f4c8f531b9a1726680..1596c3905c689032646a2fce8408b2bde0d8d72f 100644 (file)
--- a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPDispatcherDependenciesImpl.java
+++ b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPSessionNegotiatorFactoryDependenciesImpl.java
@@ -9,24 +9,19 @@ package org.opendaylight.bgpcep.pcep.topology.provider;
 
 import static java.util.Objects.requireNonNull;
 
-import java.net.InetSocketAddress;
 import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.protocol.concepts.KeyMapping;
-import org.opendaylight.protocol.pcep.PCEPDispatcherDependencies;
 import org.opendaylight.protocol.pcep.PCEPPeerProposal;
 import org.opendaylight.protocol.pcep.PCEPSessionListenerFactory;
+import org.opendaylight.protocol.pcep.PCEPSessionNegotiatorFactoryDependencies;
 
-final class PCEPDispatcherDependenciesImpl implements PCEPDispatcherDependencies {
+final class PCEPSessionNegotiatorFactoryDependenciesImpl implements PCEPSessionNegotiatorFactoryDependencies {
     private final @NonNull PCEPSessionListenerFactory listenerFactory;
     private final @NonNull PCEPPeerProposal peerProposal;
 
-    private final @NonNull PCEPTopologyConfiguration topologyConfig;
-
-    PCEPDispatcherDependenciesImpl(final PCEPSessionListenerFactory listenerFactory,
-            final PCEPPeerProposal peerProposal, final PCEPTopologyConfiguration topologyConfig) {
+    PCEPSessionNegotiatorFactoryDependenciesImpl(final PCEPSessionListenerFactory listenerFactory,
+            final PCEPPeerProposal peerProposal) {
         this.listenerFactory = requireNonNull(listenerFactory);
         this.peerProposal = requireNonNull(peerProposal);
-        this.topologyConfig = requireNonNull(topologyConfig);
     }
 
     @Override
@@ -38,14 +33,4 @@ final class PCEPDispatcherDependenciesImpl implements PCEPDispatcherDependencies
     public PCEPPeerProposal getPeerProposal() {
         return peerProposal;
     }
-
-    @Override
-    public InetSocketAddress getAddress() {
-        return topologyConfig.getAddress();
-    }
-
-    @Override
-    public KeyMapping getKeys() {
-        return topologyConfig.getKeys();
-    }
 }

diff --git a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPTopologyProvider.java b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPTopologyProvider.java
index 7eed9488b6d156bb0fd6cb1b396d49c4aafeb319..01d65ddae05ce8981f3e37670bab11a09c43a8c2 100644 (file)
--- a/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPTopologyProvider.java
+++ b/pcep/topology/topology-provider/src/main/java/org/opendaylight/bgpcep/pcep/topology/provider/PCEPTopologyProvider.java
@@ -191,8 +191,8 @@ final class PCEPTopologyProvider extends DefaultTopologyReference {
         proposal = new PCEPStatefulPeerProposal(dependencies.getDataBroker(), instanceIdentifier);
 
         LOG.info("PCEP Topology Provider {} starting server channel", topologyId());
-        final var channelFuture = dependencies.getPCEPDispatcher().createServer(
-            new PCEPDispatcherDependenciesImpl(manager, proposal, currentConfig));
+        final var channelFuture = dependencies.getPCEPDispatcher().createServer(currentConfig.getAddress(),
+            currentConfig.getKeys(), new PCEPSessionNegotiatorFactoryDependenciesImpl(manager, proposal));
         channelFuture.addListener(ignored -> enableRPCs(future, channelFuture));
     }