X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=netconf%2Fnetconf-client%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fnetconf%2Fclient%2FNetconfClientDispatcherImpl.java;h=e1754111b6f79c98cebd99656a219db4157b254c;hb=7bf7d3fd39c6966a2414d4ca6fd77d195021c1f8;hp=8b94b994fa622225dbe748a4a68b0398e00f0a6e;hpb=3ca922b14c83039565e577518b591cf83dda0c55;p=netconf.git diff --git a/netconf/netconf-client/src/main/java/org/opendaylight/netconf/client/NetconfClientDispatcherImpl.java b/netconf/netconf-client/src/main/java/org/opendaylight/netconf/client/NetconfClientDispatcherImpl.java index 8b94b994fa..e1754111b6 100644 --- a/netconf/netconf-client/src/main/java/org/opendaylight/netconf/client/NetconfClientDispatcherImpl.java +++ b/netconf/netconf-client/src/main/java/org/opendaylight/netconf/client/NetconfClientDispatcherImpl.java @@ -5,122 +5,149 @@ * 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.netconf.client; +import static java.util.Objects.requireNonNull; + import io.netty.channel.EventLoopGroup; -import io.netty.channel.socket.SocketChannel; import io.netty.util.Timer; import io.netty.util.concurrent.Future; -import io.netty.util.concurrent.Promise; -import java.io.Closeable; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; +import javax.inject.Inject; +import javax.inject.Singleton; import org.opendaylight.netconf.client.conf.NetconfClientConfiguration; import org.opendaylight.netconf.client.conf.NetconfReconnectingClientConfiguration; -import org.opendaylight.protocol.framework.AbstractDispatcher; +import org.opendaylight.netconf.nettyutil.AbstractNetconfDispatcher; +import org.opendaylight.netconf.nettyutil.ReconnectFuture; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri; +import org.osgi.service.component.annotations.Activate; +import org.osgi.service.component.annotations.Component; +import org.osgi.service.component.annotations.Reference; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class NetconfClientDispatcherImpl extends AbstractDispatcher - implements NetconfClientDispatcher, Closeable { - +@Singleton +@Component(immediate = true, service = NetconfClientDispatcher.class, property = "type=netconf-client-dispatcher") +public class NetconfClientDispatcherImpl + extends AbstractNetconfDispatcher + implements NetconfClientDispatcher { private static final Logger LOG = LoggerFactory.getLogger(NetconfClientDispatcherImpl.class); private final Timer timer; - public NetconfClientDispatcherImpl(final EventLoopGroup bossGroup, final EventLoopGroup workerGroup, final Timer timer) { + @Inject + @Activate + public NetconfClientDispatcherImpl(@Reference(target = "(type=global-boss-group)") final EventLoopGroup bossGroup, + @Reference(target = "(type=global-worker-group)") final EventLoopGroup workerGroup, + @Reference(target = "(type=global-timer)") final Timer timer) { super(bossGroup, workerGroup); - this.timer = timer; + this.timer = requireNonNull(timer); } - protected Timer getTimer() { + protected final Timer getTimer() { return timer; } @Override public Future createClient(final NetconfClientConfiguration clientConfiguration) { switch (clientConfiguration.getProtocol()) { - case TCP: - return createTcpClient(clientConfiguration); - case SSH: - return createSshClient(clientConfiguration); + case TCP: + return createTcpClient(clientConfiguration); + case SSH: + return createSshClient(clientConfiguration); + case TLS: + return createTlsClient(clientConfiguration); + default: + throw new IllegalArgumentException("Unknown client protocol " + clientConfiguration.getProtocol()); } - throw new IllegalArgumentException("Unknown client protocol " + clientConfiguration.getProtocol()); } @Override - public Future createReconnectingClient(final NetconfReconnectingClientConfiguration clientConfiguration) { + public ReconnectFuture createReconnectingClient(final NetconfReconnectingClientConfiguration clientConfiguration) { switch (clientConfiguration.getProtocol()) { - case TCP: - return createReconnectingTcpClient(clientConfiguration); - case SSH: - return createReconnectingSshClient(clientConfiguration); + case TCP: + return createReconnectingTcpClient(clientConfiguration); + case SSH: + return createReconnectingSshClient(clientConfiguration); + case TLS: + return createReconnectingTlsClient(clientConfiguration); + default: + throw new IllegalArgumentException("Unknown client protocol " + clientConfiguration.getProtocol()); } - throw new IllegalArgumentException("Unknown client protocol " + clientConfiguration.getProtocol()); } private Future createTcpClient(final NetconfClientConfiguration currentConfiguration) { LOG.debug("Creating TCP client with configuration: {}", currentConfiguration); return super.createClient(currentConfiguration.getAddress(), currentConfiguration.getReconnectStrategy(), - new PipelineInitializer() { - - @Override - public void initializeChannel(final SocketChannel ch, final Promise promise) { - initialize(ch, promise); - } - - private void initialize(final SocketChannel ch, final Promise promise) { - new TcpClientChannelInitializer(getNegotiatorFactory(currentConfiguration), currentConfiguration - .getSessionListener()).initialize(ch, promise); - } - }); + (ch, promise) -> new TcpClientChannelInitializer(getNegotiatorFactory(currentConfiguration), + currentConfiguration.getSessionListener()).initialize(ch, promise)); } - private Future createReconnectingTcpClient(final NetconfReconnectingClientConfiguration currentConfiguration) { + private ReconnectFuture createReconnectingTcpClient( + final NetconfReconnectingClientConfiguration currentConfiguration) { LOG.debug("Creating reconnecting TCP client with configuration: {}", currentConfiguration); - final TcpClientChannelInitializer init = new TcpClientChannelInitializer(getNegotiatorFactory(currentConfiguration), + final TcpClientChannelInitializer init = + new TcpClientChannelInitializer(getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener()); - return super.createReconnectingClient(currentConfiguration.getAddress(), currentConfiguration.getConnectStrategyFactory(), - currentConfiguration.getReconnectStrategy(), new PipelineInitializer() { - @Override - public void initializeChannel(final SocketChannel ch, final Promise promise) { - init.initialize(ch, promise); - } - }); + return super.createReconnectingClient(currentConfiguration.getAddress(), + currentConfiguration.getConnectStrategyFactory(), init::initialize); } private Future createSshClient(final NetconfClientConfiguration currentConfiguration) { LOG.debug("Creating SSH client with configuration: {}", currentConfiguration); return super.createClient(currentConfiguration.getAddress(), currentConfiguration.getReconnectStrategy(), - new PipelineInitializer() { - - @Override - public void initializeChannel(final SocketChannel ch, - final Promise sessionPromise) { - new SshClientChannelInitializer(currentConfiguration.getAuthHandler(), - getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener()) - .initialize(ch, sessionPromise); - } - - }); + (ch, sessionPromise) -> new SshClientChannelInitializer(currentConfiguration.getAuthHandler(), + getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener(), + currentConfiguration.getSshClient()).initialize(ch, sessionPromise)); } - private Future createReconnectingSshClient(final NetconfReconnectingClientConfiguration currentConfiguration) { + private ReconnectFuture createReconnectingSshClient( + final NetconfReconnectingClientConfiguration currentConfiguration) { LOG.debug("Creating reconnecting SSH client with configuration: {}", currentConfiguration); final SshClientChannelInitializer init = new SshClientChannelInitializer(currentConfiguration.getAuthHandler(), - getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener()); - - return super.createReconnectingClient(currentConfiguration.getAddress(), currentConfiguration.getConnectStrategyFactory(), currentConfiguration.getReconnectStrategy(), - new PipelineInitializer() { - @Override - public void initializeChannel(final SocketChannel ch, final Promise promise) { - init.initialize(ch, promise); - } - }); + getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener(), + currentConfiguration.getSshClient()); + + return super.createReconnectingClient(currentConfiguration.getAddress(), + currentConfiguration.getConnectStrategyFactory(), init::initialize); + } + + private Future createTlsClient(final NetconfClientConfiguration currentConfiguration) { + LOG.debug("Creating TLS client with configuration: {}", currentConfiguration); + return super.createClient(currentConfiguration.getAddress(), currentConfiguration.getReconnectStrategy(), + (ch, sessionPromise) -> new TlsClientChannelInitializer(currentConfiguration.getSslHandlerFactory(), + getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener()) + .initialize(ch, sessionPromise)); + } + + private ReconnectFuture createReconnectingTlsClient( + final NetconfReconnectingClientConfiguration currentConfiguration) { + LOG.debug("Creating reconnecting TLS client with configuration: {}", currentConfiguration); + final TlsClientChannelInitializer init = new TlsClientChannelInitializer( + currentConfiguration.getSslHandlerFactory(), getNegotiatorFactory(currentConfiguration), + currentConfiguration.getSessionListener()); + + return super.createReconnectingClient(currentConfiguration.getAddress(), + currentConfiguration.getConnectStrategyFactory(), init::initialize); } protected NetconfClientSessionNegotiatorFactory getNegotiatorFactory(final NetconfClientConfiguration cfg) { + final List odlHelloCapabilities = cfg.getOdlHelloCapabilities(); + if (odlHelloCapabilities == null || odlHelloCapabilities.isEmpty()) { + return new NetconfClientSessionNegotiatorFactory(timer, cfg.getAdditionalHeader(), + cfg.getConnectionTimeoutMillis(), cfg.getMaximumIncomingChunkSize()); + } + + // LinkedHashSet since perhaps the device cares about order of hello message capabilities. + // This allows user control of the order while complying with the existing interface. + final Set stringCapabilities = new LinkedHashSet<>(); + for (final Uri uri : odlHelloCapabilities) { + stringCapabilities.add(uri.getValue()); + } return new NetconfClientSessionNegotiatorFactory(timer, cfg.getAdditionalHeader(), - cfg.getConnectionTimeoutMillis()); + cfg.getConnectionTimeoutMillis(), stringCapabilities); } }