Event.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_Event_h
#define AsyncComm_Event_h

#include "Clock.h"
#include "CommHeader.h"

#include <Common/Error.h>
#include <Common/InetAddr.h>
#include <Common/Logger.h>
#include <Common/String.h>
#include <Common/Time.h>

#include <iostream>
#include <memory>

namespace Hypertable {

  class Event {

  public:

    enum Type { 
      CONNECTION_ESTABLISHED, 
      DISCONNECT, 
      MESSAGE,    
      ERROR,      
      TIMER       
    };

    Event(Type type_, const InetAddr &addr_, int error_=Error::OK)
      : type(type_), addr(addr_), error(error_) {
      proxy = 0;
    }

    Event(Type type_, const sockaddr_in &addr_, const String &proxy_,
          int error_=Error::OK) 
      : type(type_), addr(addr_), error(error_) {
      set_proxy(proxy_);
    }

    Event(Type type_, int error_=Error::OK) 
      : type(type_), error(error_) {
      proxy = 0;
    }

    Event(Type type_, const String &proxy_, int error_=0) 
      : type(type_), error(error_) {
      set_proxy(proxy_);
    }

    ~Event() {
      if (payload_aligned)
        free((void *)payload);
      else
        delete [] payload;
      if (proxy_buf != proxy_buf_static)
        delete [] proxy_buf;
    }

    void load_message_header(const uint8_t *buf, size_t len) {
      header.decode(&buf, &len);
      group_id = header.gid;
    }

    void set_proxy(const String &p) {
      if (p.length() == 0)
        proxy = 0;
      else {
        if (p.length() < 32)
          proxy = proxy_buf_static;
        else {
          proxy_buf = new char [ p.length() + 1 ];
          proxy = proxy_buf;
        }
        strcpy((char *)proxy, p.c_str());
      }
    }

    ClockT::time_point deadline() {
      HT_ASSERT(arrival_time.time_since_epoch().count() > 0);
      return arrival_time + std::chrono::milliseconds(header.timeout_ms);
    }

    Type type;

    InetAddr addr;

    const char *proxy {};

    char *proxy_buf {};

    char proxy_buf_static[32];

    InetAddr local_addr;

    int error {};

    CommHeader header;

    const uint8_t *payload {};

    size_t payload_len {};

    uint64_t group_id {};

    ClockT::time_point arrival_time {};

    bool payload_aligned {};

    String to_str() const;

    void display() { std::cerr << to_str() << std::endl; }
  };

  typedef std::shared_ptr<Event> EventPtr;
} // namespace Hypertable

#endif // AsyncComm_Event_h