netconf/mdsal-netconf-ssh/src/main/java/org/opendaylight/netconf/ssh/RemoteNetconfCommand.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.ssh;
   9
  10 import com.google.common.base.Preconditions;
  11 import io.netty.bootstrap.Bootstrap;
  12 import io.netty.channel.Channel;
  13 import io.netty.channel.ChannelFuture;
  14 import io.netty.channel.ChannelInitializer;
  15 import io.netty.channel.EventLoopGroup;
  16 import io.netty.channel.local.LocalAddress;
  17 import io.netty.channel.local.LocalChannel;
  18 import java.io.InputStream;
  19 import java.io.OutputStream;
  20 import java.net.InetSocketAddress;
  21 import java.net.SocketAddress;
  22 import org.apache.sshd.common.NamedFactory;
  23 import org.apache.sshd.common.io.IoInputStream;
  24 import org.apache.sshd.common.io.IoOutputStream;
  25 import org.apache.sshd.server.Environment;
  26 import org.apache.sshd.server.ExitCallback;
  27 import org.apache.sshd.server.channel.ChannelSession;
  28 import org.apache.sshd.server.command.AsyncCommand;
  29 import org.apache.sshd.server.command.Command;
  30 import org.apache.sshd.server.session.ServerSession;
  31 import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 /**
  36  * This command handles all netconf related rpc and forwards to delegate server.
  37  * Uses netty to make a local connection to delegate server.
  38  *
  39  * <p>
  40  * Command is Apache Mina SSH terminology for objects handling ssh data.
  41  */
  42 public class RemoteNetconfCommand implements AsyncCommand {
  43
  44     private static final Logger LOG = LoggerFactory.getLogger(RemoteNetconfCommand.class);
  45
  46     private final EventLoopGroup clientEventGroup;
  47     private final LocalAddress localAddress;
  48
  49     private IoInputStream in;
  50     private IoOutputStream out;
  51     private ExitCallback callback;
  52     private NetconfHelloMessageAdditionalHeader netconfHelloMessageAdditionalHeader;
  53
  54     private Channel clientChannel;
  55     private ChannelFuture clientChannelFuture;
  56
  57     public RemoteNetconfCommand(final EventLoopGroup clientEventGroup, final LocalAddress localAddress) {
  58         this.clientEventGroup = clientEventGroup;
  59         this.localAddress = localAddress;
  60     }
  61
  62     @Override
  63     @SuppressWarnings("checkstyle:hiddenField")
  64     public void setIoInputStream(final IoInputStream in) {
  65         this.in = in;
  66     }
  67
  68     @Override
  69     @SuppressWarnings("checkstyle:hiddenField")
  70     public void setIoOutputStream(final IoOutputStream out) {
  71         this.out = out;
  72     }
  73
  74     @Override
  75     public void setIoErrorStream(final IoOutputStream err) {
  76         // TODO do we want to use error stream in some way ?
  77     }
  78
  79     @Override
  80     @SuppressWarnings("checkstyle:hiddenField")
  81     public void setInputStream(final InputStream in) {
  82         throw new UnsupportedOperationException("Synchronous IO is unsupported");
  83     }
  84
  85     @Override
  86     @SuppressWarnings("checkstyle:hiddenField")
  87     public void setOutputStream(final OutputStream out) {
  88         throw new UnsupportedOperationException("Synchronous IO is unsupported");
  89
  90     }
  91
  92     @Override
  93     public void setErrorStream(final OutputStream err) {
  94         throw new UnsupportedOperationException("Synchronous IO is unsupported");
  95
  96     }
  97
  98     @Override
  99     @SuppressWarnings("checkstyle:hiddenField")
 100     public void setExitCallback(final ExitCallback callback) {
 101         this.callback = callback;
 102     }
 103
 104     @Override
 105     public void start(final ChannelSession channel, final Environment env) {
 106         final ServerSession session = channel.getServerSession();
 107         final SocketAddress remoteAddress = session.getIoSession().getRemoteAddress();
 108         final String hostName;
 109         final String port;
 110         if (remoteAddress instanceof InetSocketAddress) {
 111             hostName = ((InetSocketAddress) remoteAddress).getAddress().getHostAddress();
 112             port = Integer.toString(((InetSocketAddress) remoteAddress).getPort());
 113         } else {
 114             hostName = "";
 115             port = "";
 116         }
 117         netconfHelloMessageAdditionalHeader = new NetconfHelloMessageAdditionalHeader(session.getUsername(), hostName,
 118             port, "ssh", "client");
 119
 120         LOG.trace("Establishing internal connection to netconf server for client: {}", getClientAddress());
 121
 122         final Bootstrap clientBootstrap = new Bootstrap();
 123         clientBootstrap.group(clientEventGroup).channel(LocalChannel.class);
 124
 125         clientBootstrap.handler(new ChannelInitializer<LocalChannel>() {
 126             @Override
 127             public void initChannel(final LocalChannel ch) {
 128                 ch.pipeline()
 129                         .addLast(new SshProxyClientHandler(in, out, netconfHelloMessageAdditionalHeader, callback));
 130             }
 131         });
 132         clientChannelFuture = clientBootstrap.connect(localAddress);
 133         clientChannelFuture.addListener(future -> {
 134             if (future.isSuccess()) {
 135                 clientChannel = clientChannelFuture.channel();
 136             } else {
 137                 LOG.warn("Unable to establish internal connection to netconf server for client: {}",
 138                         getClientAddress());
 139                 Preconditions.checkNotNull(callback, "Exit callback must be set");
 140                 callback.onExit(1, "Unable to establish internal connection to netconf server for client: "
 141                         + getClientAddress());
 142             }
 143         });
 144     }
 145
 146     @Override
 147     public void destroy(final ChannelSession channel) {
 148         LOG.trace("Releasing internal connection to netconf server for client: {} on channel: {}",
 149                 getClientAddress(), clientChannel);
 150
 151         clientChannelFuture.cancel(true);
 152         if (clientChannel != null) {
 153             clientChannel.close().addListener(future -> {
 154                 if (!future.isSuccess()) {
 155                     LOG.warn("Unable to release internal connection to netconf server on channel: {}",
 156                             clientChannel);
 157                 }
 158             });
 159         }
 160     }
 161
 162     private String getClientAddress() {
 163         return netconfHelloMessageAdditionalHeader.getAddress();
 164     }
 165
 166     public static class NetconfCommandFactory implements NamedFactory<Command> {
 167
 168         public static final String NETCONF = "netconf";
 169
 170         private final EventLoopGroup clientBootstrap;
 171         private final LocalAddress localAddress;
 172
 173         public NetconfCommandFactory(final EventLoopGroup clientBootstrap, final LocalAddress localAddress) {
 174
 175             this.clientBootstrap = clientBootstrap;
 176             this.localAddress = localAddress;
 177         }
 178
 179         @Override
 180         public String getName() {
 181             return NETCONF;
 182         }
 183
 184         @Override
 185         public RemoteNetconfCommand create() {
 186             return new RemoteNetconfCommand(clientBootstrap, localAddress);
 187         }
 188     }
 189 }