SshSocketHandler.h

Go to the documentation of this file.

/* -*- c++ -*-
 * Copyright (C) 2007-2014 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or any later version.
 *
 * Hypertable is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */


#ifndef Tools_cluster_SshSocketHandler_h
#define Tools_cluster_SshSocketHandler_h

#include "SshOutputCollector.h"

#include <AsyncComm/Comm.h>
#include <AsyncComm/CommAddress.h>
#include <AsyncComm/RawSocketHandler.h>

#include <Common/PageArena.h>

#include <libssh/callbacks.h>
#include <libssh/libssh.h> 

#include <cerrno>
#include <chrono>
#include <condition_variable>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <memory>
#include <mutex>
#include <ostream>
#include <string>
#include <tuple>

namespace Hypertable {


  class SshSocketHandler : public RawSocketHandler {
  public:

    SshSocketHandler(const std::string &hostname);

    virtual ~SshSocketHandler();

    virtual bool handle(int sd, int events);

    virtual void deregister(int sd);

    virtual int poll_interest(int sd) { return m_poll_interest; }

    void log_callback(ssh_session session, int priority, const char *message);

    int auth_callback(const char *prompt, char *buf, size_t len,
                      int echo, int verify);

    void connect_status_callback(float status);

    void global_request_callback(ssh_session session, ssh_message message);

    void set_exit_status(int exit_status);

    bool wait_for_connection(std::chrono::system_clock::time_point deadline);

    bool issue_command(const std::string &command);

    bool wait_for_command_completion();

    void cancel();

    void dump_log(std::ostream &out);

    void set_terminal_output(bool val);

    static void enable_debug();

    static void set_libssh_verbosity(const std::string &value);

    const std::string hostname() const { return m_hostname; }

  private:

    bool verify_knownhost();

    void write_to_stdout(const char *output, size_t len);

    void write_to_stderr(const char *output, size_t len);

    bool socket_has_data();

    static bool ms_debug_enabled;

    static int ms_libssh_verbosity;

    std::mutex m_mutex;

    std::condition_variable m_cond;

    Comm *m_comm;

    std::string m_hostname;

    ssh_session m_ssh_session;

    CommAddress m_comm_address;

    ssh_channel m_channel;

    int m_state {};

    int m_sd {};

    int m_poll_interest {};

    std::string m_error;

    ssh_callbacks_struct m_callbacks;

    ssh_channel_callbacks_struct m_channel_callbacks;

    std::string m_command;

    int m_command_exit_status {};

    bool m_command_exit_status_is_set {};

    bool m_terminal_output {};

    bool m_line_prefix_needed_stdout {};

    bool m_line_prefix_needed_stderr {};

    bool m_cancelled {};

    bool m_channel_is_eof {};

    SshOutputCollector m_log_collector;

    SshOutputCollector::Buffer m_log_buffer {};

    SshOutputCollector m_stdout_collector;

    SshOutputCollector::Buffer m_stdout_buffer {};

    SshOutputCollector m_stderr_collector;

    SshOutputCollector::Buffer m_stderr_buffer {};
    
  };

  typedef std::shared_ptr<SshSocketHandler> SshSocketHandlerPtr;


} // namespace Hypertable

#endif // Tools_cluster_SshSocketHandler_h