netconf/netconf-client/src/main/java/org/opendaylight/netconf/client/NetconfClientDispatcherImpl.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.netconf.client;
  10
  11 import io.netty.channel.EventLoopGroup;
  12 import io.netty.util.Timer;
  13 import io.netty.util.concurrent.Future;
  14 import java.io.Closeable;
  15 import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
  16 import org.opendaylight.netconf.client.conf.NetconfReconnectingClientConfiguration;
  17 import org.opendaylight.protocol.framework.AbstractDispatcher;
  18 import org.slf4j.Logger;
  19 import org.slf4j.LoggerFactory;
  20
  21 public class NetconfClientDispatcherImpl extends AbstractDispatcher<NetconfClientSession, NetconfClientSessionListener>
  22         implements NetconfClientDispatcher, Closeable {
  23
  24     private static final Logger LOG = LoggerFactory.getLogger(NetconfClientDispatcherImpl.class);
  25
  26     private final Timer timer;
  27
  28     public NetconfClientDispatcherImpl(final EventLoopGroup bossGroup, final EventLoopGroup workerGroup,
  29                                        final Timer timer) {
  30         super(bossGroup, workerGroup);
  31         this.timer = timer;
  32     }
  33
  34     protected Timer getTimer() {
  35         return timer;
  36     }
  37
  38     @Override
  39     public Future<NetconfClientSession> createClient(final NetconfClientConfiguration clientConfiguration) {
  40         switch (clientConfiguration.getProtocol()) {
  41             case TCP:
  42                 return createTcpClient(clientConfiguration);
  43             case SSH:
  44                 return createSshClient(clientConfiguration);
  45             default:
  46                 throw new IllegalArgumentException("Unknown client protocol " + clientConfiguration.getProtocol());
  47         }
  48     }
  49
  50     @Override
  51     public Future<Void> createReconnectingClient(final NetconfReconnectingClientConfiguration clientConfiguration) {
  52         switch (clientConfiguration.getProtocol()) {
  53             case TCP:
  54                 return createReconnectingTcpClient(clientConfiguration);
  55             case SSH:
  56                 return createReconnectingSshClient(clientConfiguration);
  57             default:
  58                 throw new IllegalArgumentException("Unknown client protocol " + clientConfiguration.getProtocol());
  59         }
  60     }
  61
  62     private Future<NetconfClientSession> createTcpClient(final NetconfClientConfiguration currentConfiguration) {
  63         LOG.debug("Creating TCP client with configuration: {}", currentConfiguration);
  64         return super.createClient(currentConfiguration.getAddress(), currentConfiguration.getReconnectStrategy(),
  65             (ch, promise) -> new TcpClientChannelInitializer(getNegotiatorFactory(currentConfiguration),
  66                         currentConfiguration
  67                         .getSessionListener()).initialize(ch, promise));
  68     }
  69
  70     private Future<Void> createReconnectingTcpClient(
  71             final NetconfReconnectingClientConfiguration currentConfiguration) {
  72         LOG.debug("Creating reconnecting TCP client with configuration: {}", currentConfiguration);
  73         final TcpClientChannelInitializer init =
  74                 new TcpClientChannelInitializer(getNegotiatorFactory(currentConfiguration),
  75                 currentConfiguration.getSessionListener());
  76
  77         return super.createReconnectingClient(currentConfiguration.getAddress(), currentConfiguration
  78                 .getConnectStrategyFactory(),
  79                 currentConfiguration.getReconnectStrategy(), init::initialize);
  80     }
  81
  82     private Future<NetconfClientSession> createSshClient(final NetconfClientConfiguration currentConfiguration) {
  83         LOG.debug("Creating SSH client with configuration: {}", currentConfiguration);
  84         return super.createClient(currentConfiguration.getAddress(), currentConfiguration.getReconnectStrategy(),
  85             (ch, sessionPromise) -> new SshClientChannelInitializer(currentConfiguration.getAuthHandler(),
  86                         getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener())
  87                         .initialize(ch, sessionPromise));
  88     }
  89
  90     private Future<Void> createReconnectingSshClient(
  91             final NetconfReconnectingClientConfiguration currentConfiguration) {
  92         LOG.debug("Creating reconnecting SSH client with configuration: {}", currentConfiguration);
  93         final SshClientChannelInitializer init = new SshClientChannelInitializer(currentConfiguration.getAuthHandler(),
  94                 getNegotiatorFactory(currentConfiguration), currentConfiguration.getSessionListener());
  95
  96         return super.createReconnectingClient(currentConfiguration.getAddress(), currentConfiguration
  97                 .getConnectStrategyFactory(), currentConfiguration.getReconnectStrategy(),
  98                 init::initialize);
  99     }
 100
 101     protected NetconfClientSessionNegotiatorFactory getNegotiatorFactory(final NetconfClientConfiguration cfg) {
 102         return new NetconfClientSessionNegotiatorFactory(timer, cfg.getAdditionalHeader(),
 103                 cfg.getConnectionTimeoutMillis());
 104     }
 105 }