connection.h

Go to the documentation of this file.

#ifndef CONNECTION_CLASS
#define CONNECTION_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : connection                                                        *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    A structure that represents the state of a communication pathway between *
*  two transports.  This header should never appear in another header; it is  *
*  heavyweight and intended for code files (*.cpp) only.                      *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$now By Author.  This program 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 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "connections_dll.h"

#include <mechanisms/heartbeat.h>
#include <mechanisms/time_stamp.h>
#include <nodes/catalogable.h>
#include <sockets/address.h>
#include <sockets/definitions_sockets.h>

class CONNECTIONS_CLASS_STYLE connection : public nodes::catalogable
{
public:
  connection();
  ~connection() {}

  // these are the various connection states.
  enum states {
    DISCONNECTED,       // not connected or totally finished disconnecting.
    AWAITING_A_CLIENT,  // a server awaiting a connection from a client.
    REACHING_SERVER,    // client is awaiting a connection to the server.
    WHO_IS_CLIENT,      // server doesn't know who connection is from yet.
    HELLO_TO_SERVER,    // client not connected yet, but working on it.
    CONNECTED,          // finished with connection process.
    SENDING_CLOSE,      // working on disconnecting the connection.
    SENDING_CLOSE_ACK,  // tells other side that their disconnect was okay.
    DONE_CLOSING        // finished disconnecting.
  };

  static const char *connection_state_name(states state);
    // provides a textual form for the "state".


  // ugly public data.  perhaps encapsulate as a class.

  // used for the low-level ids.
  #define PRIMARY_ID 0
  #define SECONDARY_ID 1

  // these are known after first bits are added to the table:
  transport_id local_transport_id;  // the linked transport on our side.
  transport_id real_transport_id;  // the real transport on our side.

  // these are known at the time of connection for everyone, we hope:
  network_address remote_host;  // the name of the machine we're talking to.
  int low_level[2];
    // connection id at the communication medium level.  either it's identical
    // to the remote_transport_id or based on low-level medium details.

  // these are known after connection intros exchanged:
  transport_id remote_transport_id;  // the transport id on the other side.
  connection_id remote_connection_id;  // the other side's name for us.

  // these are just connection table bookkeeping info:
  bool alive;  // reports if this connection entry is still alive or not.
  heartbeat liveness;  // state of other side's healthiness.


  connection_id conn_id() const { return connection_id(id().raw_id()); }
    // returns the unique identifier for this connection.

  // allows the connection id to be modified.
  void conn_id(const connection_id &new_id);

  istring catalogable_name() const;
    // returns our name as a catalogable object.

  istring text_form() const;
    // returns a textual form for this connection.

  bool connected() const;
    // reports if this connection is actually considered alive.

  time_stamp connected_since() const;
    // returns the time that this connection has been in a connected state.
    // this is only valid if the current state is CONNECTED.

  states state() const;
    // returns the current connection state.
  void state(states to_set);
    // makes "to_set" the current state for this connection.  this also updates
    // the time stamp of last_state_change() regardless of the new state.
    // in addition, if the previous state was not CONNECTED and "to_set" is
    // CONNECTED, then the connected_since() time_stamp is reset.

  time_stamp last_state_change() const;
    // returns the last time that the state changed.
  
private:
  states _the_state;
    // describes the current state of the connection.
  time_stamp _state_change_time;
    // the last time the state of the connection was modified.
  time_stamp _connected_since;
    // tracks how long the current connection has lasted.  this is only valid
    // if the current state is CONNECTED.
};

#endif

---