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