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