Comm.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2015 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 AsyncComm_Comm_h
#define AsyncComm_Comm_h

#include "Clock.h"
#include "CommAddress.h"
#include "CommBuf.h"
#include "ConnectionHandlerFactory.h"
#include "DispatchHandler.h"
#include "HandlerMap.h"
#include "RawSocketHandler.h"

#include <atomic>
#include <mutex>

namespace Hypertable {

  class Comm {
  public:

    static Comm *instance() {
      std::lock_guard<std::mutex> lock(ms_mutex);

      if (!ms_instance)
        ms_instance = new Comm();

      return ms_instance;
    }

    static void destroy();

    int register_socket(int sd, const CommAddress &addr,
                        RawSocketHandler *handler);

    int connect(const CommAddress &addr, const DispatchHandlerPtr &default_handler);

    int connect(const CommAddress &addr, const CommAddress &local_addr,
                const DispatchHandlerPtr &default_handler);

    int set_alias(const InetAddr &addr, const InetAddr &alias);

    int add_proxy(const String &proxy, const String &hostname, const InetAddr &addr);

    int remove_proxy(const String &proxy);

    bool translate_proxy(const String &proxy, InetAddr *addr);

    void get_proxy_map(ProxyMapT &proxy_map);

    bool wait_for_proxy_load(Timer &timer);

    void listen(const CommAddress &addr, ConnectionHandlerFactoryPtr &chf);

    void listen(const CommAddress &addr, ConnectionHandlerFactoryPtr &chf,
                const DispatchHandlerPtr &default_handler);

    int send_request(const CommAddress &addr, uint32_t timeout_ms,
                     CommBufPtr &cbuf, DispatchHandler *response_handler);

    int send_response(const CommAddress &addr, CommBufPtr &cbuf);

    void create_datagram_receive_socket(CommAddress &addr, int tos,
                                        const DispatchHandlerPtr &handler);

    int send_datagram(const CommAddress &addr, const CommAddress &send_addr,
                      CommBufPtr &cbuf);

    int set_timer(uint32_t duration_millis, const DispatchHandlerPtr &handler);

    int set_timer_absolute(ClockT::time_point expire_time, const DispatchHandlerPtr &handler);

    void cancel_timer(const DispatchHandlerPtr &handler);

    void close_socket(const CommAddress &addr);

    void find_available_tcp_port(InetAddr &addr);

    void find_available_udp_port(InetAddr &addr);

  private:
    
    Comm();

    ~Comm();

    int send_request(IOHandlerData *data_handler, uint32_t timeout_ms,
                     CommBufPtr &cbuf, DispatchHandler *response_handler);

    int connect_socket(int sd, const CommAddress &addr,
                       const DispatchHandlerPtr &default_handler);

    static Comm *ms_instance;

    static std::atomic<uint32_t> ms_next_request_id;

    static std::mutex ms_mutex;
    
    HandlerMapPtr m_handler_map;

    ReactorPtr m_timer_reactor;

    InetAddr m_local_addr;

    bool m_verbose {};
  };

}

#endif // AsyncComm_Comm_h