*/
package org.opendaylight.netconf.client.conf;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import java.net.InetSocketAddress;
import java.util.List;
+import java.util.Optional;
+import org.checkerframework.checker.index.qual.NonNegative;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
import org.opendaylight.netconf.client.SslHandlerFactory;
+import org.opendaylight.netconf.nettyutil.ReconnectStrategy;
import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
-import org.opendaylight.protocol.framework.ReconnectStrategy;
+import org.opendaylight.netconf.nettyutil.handler.ssh.client.NetconfSshClient;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class NetconfClientConfiguration {
-
private static final Logger LOG = LoggerFactory.getLogger(NetconfClientConfiguration.class);
private final NetconfClientProtocol clientProtocol;
private final AuthenticationHandler authHandler;
private final SslHandlerFactory sslHandlerFactory;
+ private final NetconfSshClient sshClient;
private final List<Uri> odlHelloCapabilities;
+ private final @NonNegative int maximumIncomingChunkSize;
NetconfClientConfiguration(final NetconfClientProtocol protocol, final InetSocketAddress address,
final Long connectionTimeoutMillis,
final NetconfHelloMessageAdditionalHeader additionalHeader,
final NetconfClientSessionListener sessionListener,
final ReconnectStrategy reconnectStrategy, final AuthenticationHandler authHandler,
- final SslHandlerFactory sslHandlerFactory,
- final List<Uri> odlHelloCapabilities) {
+ final SslHandlerFactory sslHandlerFactory, final NetconfSshClient sshClient,
+ final List<Uri> odlHelloCapabilities, final @NonNegative int maximumIncomingChunkSize) {
this.address = address;
this.connectionTimeoutMillis = connectionTimeoutMillis;
this.additionalHeader = additionalHeader;
this.sessionListener = sessionListener;
- this.clientProtocol = protocol;
+ clientProtocol = protocol;
this.reconnectStrategy = reconnectStrategy;
this.authHandler = authHandler;
this.sslHandlerFactory = sslHandlerFactory;
+ this.sshClient = sshClient;
this.odlHelloCapabilities = odlHelloCapabilities;
+ this.maximumIncomingChunkSize = maximumIncomingChunkSize;
validateConfiguration();
}
}
public final Optional<NetconfHelloMessageAdditionalHeader> getAdditionalHeader() {
- return Optional.fromNullable(additionalHeader);
+ return Optional.ofNullable(additionalHeader);
}
public final NetconfClientSessionListener getSessionListener() {
return sessionListener;
}
+ @Deprecated(forRemoval = true)
public final ReconnectStrategy getReconnectStrategy() {
return reconnectStrategy;
}
return sslHandlerFactory;
}
+ public NetconfSshClient getSshClient() {
+ return sshClient;
+ }
+
public List<Uri> getOdlHelloCapabilities() {
return odlHelloCapabilities;
}
+ public @NonNegative int getMaximumIncomingChunkSize() {
+ return maximumIncomingChunkSize;
+ }
+
private void validateConfiguration() {
- Preconditions.checkNotNull(clientProtocol, " ");
- switch (clientProtocol) {
+ switch (requireNonNull(clientProtocol)) {
case TLS:
validateTlsConfiguration();
validateTcpConfiguration();
}
}
- protected void validateTlsConfiguration() {
- Preconditions.checkNotNull(sslHandlerFactory, "sslHandlerFactory");
+ protected final void validateTlsConfiguration() {
+ requireNonNull(sslHandlerFactory, "sslHandlerFactory");
}
- protected void validateSshConfiguration() {
- Preconditions.checkNotNull(authHandler, "authHandler");
+ protected final void validateSshConfiguration() {
+ requireNonNull(authHandler, "authHandler");
}
- protected void validateTcpConfiguration() {
- Preconditions.checkNotNull(address, "address");
- Preconditions.checkNotNull(clientProtocol, "clientProtocol");
- Preconditions.checkNotNull(connectionTimeoutMillis, "connectionTimeoutMillis");
- Preconditions.checkNotNull(sessionListener, "sessionListener");
- Preconditions.checkNotNull(reconnectStrategy, "reconnectStrategy");
+ protected final void validateTcpConfiguration() {
+ requireNonNull(address, "address");
+ requireNonNull(clientProtocol, "clientProtocol");
+ requireNonNull(connectionTimeoutMillis, "connectionTimeoutMillis");
+ requireNonNull(sessionListener, "sessionListener");
+ requireNonNull(reconnectStrategy, "reconnectStrategy");
}
@Override