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