protocol/netconf-client/src/main/java/org/opendaylight/netconf/client/conf/NetconfClientConfiguration.java

   1 /*
   2  * Copyright (c) 2014 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 package org.opendaylight.netconf.client.conf;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.base.MoreObjects;
  13 import com.google.common.base.MoreObjects.ToStringHelper;
  14 import com.google.common.base.Preconditions;
  15 import java.net.InetSocketAddress;
  16 import java.util.List;
  17 import java.util.Optional;
  18 import org.checkerframework.checker.index.qual.NonNegative;
  19 import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
  20 import org.opendaylight.netconf.client.NetconfClientSessionListener;
  21 import org.opendaylight.netconf.client.SslHandlerFactory;
  22 import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
  23 import org.opendaylight.netconf.nettyutil.handler.ssh.client.NetconfSshClient;
  24 import org.opendaylight.netconf.transport.ssh.ClientFactoryManagerConfigurator;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ssh.client.rev230417.SshClientGrouping;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.tcp.client.rev230417.TcpClientGrouping;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.tls.client.rev230417.TlsClientGrouping;
  29 import org.slf4j.Logger;
  30 import org.slf4j.LoggerFactory;
  31
  32 public class NetconfClientConfiguration {
  33     private static final Logger LOG = LoggerFactory.getLogger(NetconfClientConfiguration.class);
  34
  35     private final NetconfClientProtocol clientProtocol;
  36     private final InetSocketAddress address;
  37     private final Long connectionTimeoutMillis;
  38
  39     private final NetconfHelloMessageAdditionalHeader additionalHeader;
  40     private final NetconfClientSessionListener sessionListener;
  41
  42     private final AuthenticationHandler authHandler;
  43     private final SslHandlerFactory sslHandlerFactory;
  44     private final NetconfSshClient sshClient;
  45
  46     private final List<Uri> odlHelloCapabilities;
  47     private final @NonNegative int maximumIncomingChunkSize;
  48     private final String name;
  49
  50     private final TcpClientGrouping tcpParameters;
  51     private final TlsClientGrouping tlsParameters;
  52     private final org.opendaylight.netconf.transport.tls.SslHandlerFactory transportSslHandlerFactory;
  53     private final SshClientGrouping sshParameters;
  54     private final ClientFactoryManagerConfigurator sshConfigurator;
  55
  56     NetconfClientConfiguration(final NetconfClientProtocol protocol, final InetSocketAddress address,
  57             final Long connectionTimeoutMillis,
  58             final NetconfHelloMessageAdditionalHeader additionalHeader,
  59             final NetconfClientSessionListener sessionListener,
  60             final AuthenticationHandler authHandler,
  61             final SslHandlerFactory sslHandlerFactory, final NetconfSshClient sshClient,
  62             final List<Uri> odlHelloCapabilities, final @NonNegative int maximumIncomingChunkSize,
  63             final String name) {
  64         this.address = address;
  65         this.connectionTimeoutMillis = connectionTimeoutMillis;
  66         this.additionalHeader = additionalHeader;
  67         this.sessionListener = sessionListener;
  68         clientProtocol = protocol;
  69         this.authHandler = authHandler;
  70         this.sslHandlerFactory = sslHandlerFactory;
  71         this.sshClient = sshClient;
  72         this.odlHelloCapabilities = odlHelloCapabilities;
  73         this.maximumIncomingChunkSize = maximumIncomingChunkSize;
  74         this.name = name;
  75         this.tcpParameters = null;
  76         this.tlsParameters = null;
  77         this.transportSslHandlerFactory = null;
  78         this.sshParameters = null;
  79         this.sshConfigurator = null;
  80         validateConfiguration();
  81     }
  82
  83     NetconfClientConfiguration(final NetconfClientProtocol protocol,
  84             final TcpClientGrouping tcpParameters,
  85             final TlsClientGrouping tlsParameters,
  86             final org.opendaylight.netconf.transport.tls.SslHandlerFactory transportSslHandlerFactory,
  87             final SshClientGrouping sshParameters,
  88             final ClientFactoryManagerConfigurator sshConfigurator,
  89             final NetconfClientSessionListener sessionListener,
  90             final List<Uri> odlHelloCapabilities,
  91             final Long connectionTimeoutMillis,
  92             final @NonNegative int maximumIncomingChunkSize,
  93             final NetconfHelloMessageAdditionalHeader additionalHeader,
  94             final String name) {
  95         this.clientProtocol = requireNonNull(protocol);
  96         this.tcpParameters = requireNonNull(tcpParameters);
  97         this.tlsParameters = tlsParameters;
  98         this.transportSslHandlerFactory = transportSslHandlerFactory;
  99         this.sshParameters = sshParameters;
 100         this.sshConfigurator = sshConfigurator;
 101         this.sessionListener = requireNonNull(sessionListener);
 102         this.odlHelloCapabilities = odlHelloCapabilities;
 103         this.connectionTimeoutMillis = connectionTimeoutMillis;
 104         this.maximumIncomingChunkSize = maximumIncomingChunkSize;
 105         this.additionalHeader = additionalHeader;
 106         this.name = name;
 107         this.address = null;
 108         this.authHandler = null;
 109         this.sslHandlerFactory = null;
 110         this.sshClient = null;
 111         // validate
 112         if (NetconfClientProtocol.TLS.equals(protocol)) {
 113             Preconditions.checkArgument(tlsParameters != null || transportSslHandlerFactory != null,
 114                 "Either tlsParameters or sslHandlerFactory is required");
 115         } else if (NetconfClientProtocol.SSH.equals(protocol)) {
 116             requireNonNull(sshParameters);
 117         }
 118     }
 119
 120     public final String getName() {
 121         return name;
 122     }
 123
 124     public final InetSocketAddress getAddress() {
 125         return address;
 126     }
 127
 128     public final Long getConnectionTimeoutMillis() {
 129         return connectionTimeoutMillis;
 130     }
 131
 132     public final Optional<NetconfHelloMessageAdditionalHeader> getAdditionalHeader() {
 133         return Optional.ofNullable(additionalHeader);
 134     }
 135
 136     public final NetconfClientSessionListener getSessionListener() {
 137         return sessionListener;
 138     }
 139
 140     public final AuthenticationHandler getAuthHandler() {
 141         return authHandler;
 142     }
 143
 144     public NetconfClientProtocol getProtocol() {
 145         return clientProtocol;
 146     }
 147
 148     public SslHandlerFactory getSslHandlerFactory() {
 149         return sslHandlerFactory;
 150     }
 151
 152     public NetconfSshClient getSshClient() {
 153         return sshClient;
 154     }
 155
 156     public List<Uri> getOdlHelloCapabilities() {
 157         return odlHelloCapabilities;
 158     }
 159
 160     public @NonNegative int getMaximumIncomingChunkSize() {
 161         return maximumIncomingChunkSize;
 162     }
 163
 164     public final TcpClientGrouping getTcpParameters() {
 165         return tcpParameters;
 166     }
 167
 168     public final  TlsClientGrouping getTlsParameters() {
 169         return tlsParameters;
 170     }
 171
 172     public final org.opendaylight.netconf.transport.tls.SslHandlerFactory getTransportSslHandlerFactory() {
 173         return transportSslHandlerFactory;
 174     }
 175
 176     public final SshClientGrouping getSshParameters() {
 177         return sshParameters;
 178     }
 179
 180     public ClientFactoryManagerConfigurator getSshConfigurator() {
 181         return sshConfigurator;
 182     }
 183
 184     private void validateConfiguration() {
 185         switch (requireNonNull(clientProtocol)) {
 186             case TLS:
 187                 validateTcpConfiguration();
 188                 validateTlsConfiguration();
 189                 break;
 190             case SSH:
 191                 validateSshConfiguration();
 192                 validateTcpConfiguration();
 193                 break;
 194             case TCP:
 195                 validateTcpConfiguration();
 196                 break;
 197             default:
 198                 LOG.warn("Unexpected protocol: {} in netconf client configuration.", clientProtocol);
 199         }
 200     }
 201
 202     protected final void validateTlsConfiguration() {
 203         requireNonNull(sslHandlerFactory, "sslHandlerFactory");
 204     }
 205
 206     protected final void validateSshConfiguration() {
 207         requireNonNull(authHandler, "authHandler");
 208     }
 209
 210     protected final void validateTcpConfiguration() {
 211         requireNonNull(address, "address");
 212         requireNonNull(clientProtocol, "clientProtocol");
 213         requireNonNull(connectionTimeoutMillis, "connectionTimeoutMillis");
 214         requireNonNull(sessionListener, "sessionListener");
 215     }
 216
 217     @Override
 218     public final String toString() {
 219         return buildToStringHelper().toString();
 220     }
 221
 222     protected ToStringHelper buildToStringHelper() {
 223         return MoreObjects.toStringHelper(this)
 224                 .add("address", address)
 225                 .add("connectionTimeoutMillis", connectionTimeoutMillis)
 226                 .add("additionalHeader", additionalHeader)
 227                 .add("sessionListener", sessionListener)
 228                 .add("clientProtocol", clientProtocol)
 229                 .add("authHandler", authHandler)
 230                 .add("sslHandlerFactory", sslHandlerFactory);
 231     }
 232
 233     public enum NetconfClientProtocol {
 234         TCP, SSH, TLS
 235     }
 236 }