HandlerMap.h

Go to the documentation of this file.

/* -*- c++ -*-
 * 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_HandlerMap_h
#define AsyncComm_HandlerMap_h


//#define HT_DISABLE_LOG_DEBUG

#include "CommAddress.h"
#include "CommBuf.h"
#include "IOHandlerData.h"
#include "IOHandlerDatagram.h"
#include "IOHandlerRaw.h"
#include "ProxyMap.h"

#include <Common/Error.h>
#include <Common/Logger.h>
#include <Common/SockAddrMap.h>
#include <Common/Time.h>
#include <Common/Timer.h>

#include <condition_variable>
#include <cassert>
#include <memory>
#include <mutex>

namespace Hypertable {

  class IOHandlerAccept;

  class HandlerMap {

  public:

    HandlerMap() : m_proxies_loaded(false) { }

    void insert_handler(IOHandlerAccept *handler);

    void insert_handler(IOHandlerData *handler, bool checkout=false);

    void insert_handler(IOHandlerDatagram *handler);

    void insert_handler(IOHandlerRaw *handler);

    int checkout_handler(const CommAddress &addr, IOHandlerAccept **handler);

    int checkout_handler(const CommAddress &addr, IOHandlerData **handler);

    int checkout_handler(const CommAddress &addr, IOHandlerDatagram **handler);

    int checkout_handler(const CommAddress &addr, IOHandlerRaw **handler);

    int contains_data_handler(const CommAddress &addr);

    void decrement_reference_count(IOHandler *handler);

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

    int remove_handler(IOHandler *handler);

    void decomission_handler_unlocked(IOHandler *handler);

    void decomission_handler(IOHandler *handler) {
      std::lock_guard<std::mutex> lock(m_mutex);
      decomission_handler_unlocked(handler);
    }

    void decomission_all();

    bool destroy_ok(IOHandler *handler);

    bool translate_proxy_address(const CommAddress &proxy_addr, InetAddr *addr);

    void purge_handler(IOHandler *handler);

    void wait_for_empty();

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

    int remove_proxy(const String &proxy);

    void get_proxy_map(ProxyMapT &proxy_map);

    void update_proxy_map(const char *message, size_t message_len);

    int32_t propagate_proxy_map(IOHandlerData *handler);

    bool wait_for_proxy_map(Timer &timer);

  private:

    int propagate_proxy_map(ProxyMapT &mappings);

    int translate_address(const CommAddress &addr, InetAddr *inet_addr);

    int remove_handler_unlocked(IOHandler *handler);

    IOHandlerAccept *lookup_accept_handler(const InetAddr &addr);

    IOHandlerData *lookup_data_handler(const InetAddr &addr);

    IOHandlerDatagram *lookup_datagram_handler(const InetAddr &addr);

    IOHandlerRaw *lookup_raw_handler(const InetAddr &addr);

    std::mutex m_mutex;

    std::condition_variable m_cond;

    std::condition_variable m_cond_proxy;

    SockAddrMap<IOHandlerAccept *> m_accept_handler_map;

    SockAddrMap<IOHandlerData *> m_data_handler_map;

    SockAddrMap<IOHandlerDatagram *> m_datagram_handler_map;

    SockAddrMap<IOHandlerRaw *> m_raw_handler_map;

    std::set<IOHandler *> m_decomissioned_handlers;

    ProxyMap m_proxy_map;

    bool m_proxies_loaded;
  };

  typedef std::shared_ptr<HandlerMap> HandlerMapPtr;

}


#endif // AsyncComm_HandlerMap_h