* 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.callhome.protocol;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Throwables;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import io.netty.channel.EventLoopGroup;
import io.netty.util.concurrent.GlobalEventExecutor;
import io.netty.util.concurrent.Promise;
import java.security.PublicKey;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
-import org.apache.sshd.ClientChannel;
-import org.apache.sshd.ClientSession;
+import org.apache.sshd.client.channel.ClientChannel;
import org.apache.sshd.client.future.AuthFuture;
import org.apache.sshd.client.future.OpenFuture;
-import org.apache.sshd.client.session.ClientSessionImpl;
-import org.apache.sshd.common.Session;
+import org.apache.sshd.client.session.ClientSession;
import org.apache.sshd.common.future.SshFutureListener;
+import org.apache.sshd.common.session.Session;
+import org.checkerframework.checker.lock.qual.Holding;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.netconf.client.NetconfClientSession;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
import org.opendaylight.netconf.client.NetconfClientSessionNegotiatorFactory;
private static final String NETCONF = "netconf";
- private final ClientSessionImpl sshSession;
+ private final ClientSession sshSession;
private final CallHomeAuthorization authorization;
private final Factory factory;
private volatile MinaSshNettyChannel nettyChannel = null;
private volatile boolean activated;
- private InetSocketAddress remoteAddress;
- private PublicKey serverKey;
-
- CallHomeSessionContext(ClientSession sshSession, CallHomeAuthorization authorization,
- SocketAddress remoteAddress, Factory factory) {
- this.authorization = Preconditions.checkNotNull(authorization, "authorization");
- Preconditions.checkArgument(this.authorization.isServerAllowed(), "Server was not allowed.");
- Preconditions.checkArgument(sshSession instanceof ClientSessionImpl,
- "sshSession must implement ClientSessionImpl");
- this.factory = Preconditions.checkNotNull(factory, "factory");
- this.sshSession = (ClientSessionImpl) sshSession;
+ private final InetSocketAddress remoteAddress;
+ private final PublicKey serverKey;
+
+ CallHomeSessionContext(final ClientSession sshSession, final CallHomeAuthorization authorization,
+ final SocketAddress remoteAddress, final Factory factory) {
+ this.authorization = requireNonNull(authorization, "authorization");
+ checkArgument(this.authorization.isServerAllowed(), "Server was not allowed.");
+ this.factory = requireNonNull(factory, "factory");
+ this.sshSession = requireNonNull(sshSession, "sshSession");
this.sshSession.setAttribute(SESSION_KEY, this);
this.remoteAddress = (InetSocketAddress) this.sshSession.getIoSession().getRemoteAddress();
this.serverKey = this.sshSession.getKex().getServerKey();
}
- static CallHomeSessionContext getFrom(ClientSession sshSession) {
+ static CallHomeSessionContext getFrom(final ClientSession sshSession) {
return sshSession.getAttribute(SESSION_KEY);
}
netconfChannel.setStreaming(ClientChannel.Streaming.Async);
netconfChannel.open().addListener(newSshFutureListener(netconfChannel));
} catch (IOException e) {
- throw Throwables.propagate(e);
+ throw new IllegalStateException(e);
}
}
};
}
- private void channelOpenFailed(Throwable e) {
- LOG.error("Unable to open netconf subsystem, disconnecting.", e);
+ @Override
+ public void terminate() {
+ sshSession.close(false);
+ removeSelf();
+ }
+
+ private void channelOpenFailed(final Throwable throwable) {
+ LOG.error("Unable to open netconf subsystem, disconnecting.", throwable);
sshSession.close(false);
}
- private void netconfChannelOpened(ClientChannel netconfChannel) {
+ private void netconfChannelOpened(final ClientChannel netconfChannel) {
nettyChannel = newMinaSshNettyChannel(netconfChannel);
- factory.getChannelOpenListener().onNetconfSubsystemOpened(CallHomeSessionContext.this,
- listener -> doActivate(listener));
+ factory.getChannelOpenListener().onNetconfSubsystemOpened(
+ CallHomeSessionContext.this, this::doActivate);
}
- @GuardedBy("this")
- private synchronized Promise<NetconfClientSession> doActivate(NetconfClientSessionListener listener) {
+ // FIXME: this does not look right
+ @Holding("this")
+ private synchronized Promise<NetconfClientSession> doActivate(final NetconfClientSessionListener listener) {
if (activated) {
return newSessionPromise().setFailure(new IllegalStateException("Session already activated."));
}
return activationPromise;
}
- protected MinaSshNettyChannel newMinaSshNettyChannel(ClientChannel netconfChannel) {
+ protected MinaSshNettyChannel newMinaSshNettyChannel(final ClientChannel netconfChannel) {
return new MinaSshNettyChannel(this, sshSession, netconfChannel);
}
- private Promise<NetconfClientSession> newSessionPromise() {
+ private static Promise<NetconfClientSession> newSessionPromise() {
return GlobalEventExecutor.INSTANCE.newPromise();
}
private final CallHomeNetconfSubsystemListener subsystemListener;
private final ConcurrentMap<String, CallHomeSessionContext> sessions = new ConcurrentHashMap<>();
- Factory(EventLoopGroup nettyGroup, NetconfClientSessionNegotiatorFactory negotiatorFactory,
- CallHomeNetconfSubsystemListener subsystemListener) {
- this.nettyGroup = Preconditions.checkNotNull(nettyGroup, "nettyGroup");
- this.negotiatorFactory = Preconditions.checkNotNull(negotiatorFactory, "negotiatorFactory");
- this.subsystemListener = Preconditions.checkNotNull(subsystemListener);
+ Factory(final EventLoopGroup nettyGroup, final NetconfClientSessionNegotiatorFactory negotiatorFactory,
+ final CallHomeNetconfSubsystemListener subsystemListener) {
+ this.nettyGroup = requireNonNull(nettyGroup, "nettyGroup");
+ this.negotiatorFactory = requireNonNull(negotiatorFactory, "negotiatorFactory");
+ this.subsystemListener = requireNonNull(subsystemListener);
}
- void remove(CallHomeSessionContext session) {
+ void remove(final CallHomeSessionContext session) {
sessions.remove(session.getSessionName(), session);
}
- ReverseSshChannelInitializer getChannelInitializer(NetconfClientSessionListener listener) {
+ ReverseSshChannelInitializer getChannelInitializer(final NetconfClientSessionListener listener) {
return ReverseSshChannelInitializer.create(negotiatorFactory, listener);
}
return this.subsystemListener;
}
- @Nullable
- CallHomeSessionContext createIfNotExists(ClientSession sshSession, CallHomeAuthorization authorization,
- SocketAddress remoteAddress) {
+ @Nullable CallHomeSessionContext createIfNotExists(final ClientSession sshSession,
+ final CallHomeAuthorization authorization, final SocketAddress remoteAddress) {
CallHomeSessionContext session = new CallHomeSessionContext(sshSession, authorization,
remoteAddress, this);
CallHomeSessionContext preexisting = sessions.putIfAbsent(session.getSessionName(), session);
Code Review / netconf.git / blobdiff