common/connection.cc

Go to the documentation of this file.

//
// connection.cc - This is the new superclass that accurately describes the
// purpose of its subclasses.  It's a connection, whether that be write-only
// or read-write.
//
// ***** BEGIN LICENSE BLOCK *****
// Version: MPL 1.1/GPL 2.0/LGPL 2.1
// 
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License at
// http://www.mozilla.org/MPL/
// 
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
// the License for the specific language governing rights and limitations
// under the License.
// 
// The Original Code is the consmgr network/serial-line monitoring package.
// 
// The Initial Developer of the Original Code is Chris P. Ross.
// Portions created by the Initial Developer are Copyright (C) 2000-2008
// the Initial Developer.  All Rights Reserved.
// 
// Contributor(s):
// 
// Alternatively, the contents of this file may be used under the terms of
// either the GNU General Public License Version 2 or later (the "GPL"), or
// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
// in which case the provisions of the GPL or the LGPL are applicable instead
// of those above. If you wish to allow use of your version of this file only
// under the terms of either the GPL or the LGPL, and not to allow others to
// use your version of this file under the terms of the MPL, indicate your
// decision by deleting the provisions above and replace them with the notice
// and other provisions required by the GPL or the LGPL. If you do not delete
// the provisions above, a recipient may use your version of this file under
// the terms of any one of the MPL, the GPL or the LGPL.
// 
// ***** END LICENSE BLOCK *****

#include <typeinfo>

#include "consmgr.h"
#include "mastercont.h"
#include "connection.h"
#include "outlet.h"
#include "guard.h"

//
// Constructor/destructor
//
Connection::Connection(ConnectorP &c) : base(c), please_exit(false)
{
    int         ret;

    // Initialize the mutex
    ret = pthread_mutex_init(&mutex, NULL);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_init(mutex)");

#if MAY_NOT_WANT_THIS
    // Initialize the conditioned wait element
    ret = pthread_cond_init(&state_change, NULL);
    PTHREAD_CHECK_AND_THROW(ret, "cond_init(state_change)");
#endif
    // Spawn a thread to manage this connection for the rest of time.
    ret = pthread_create(&tid_manager, NULL, manager_thread, this);
    PTHREAD_CHECK_AND_THROW(ret, "pthread_create(manager)");

    return;
}

Connection::~Connection(void) throw()
{
    int         ret;

    // Destroy the mutexes and condition variables
    ret = pthread_mutex_destroy(&mutex);
    if (ret != 0)
        cerr << "Error destroying Connection::mutex (" << &mutex << "): "
             << strerror(ret) << endl;
#if MAY_NOT_WANT_THIS
    ret = pthread_cond_destroy(&state_change);
    if (ret != 0)
        cerr << "Error destroying Connection::state_change (" << &state_change
             << "): " << strerror(ret) << endl;
#endif
    return;
}


//
// pthread library C-name-binding wrappers for the identically-named
// methods of Connection and/or its subclasses.
//
void *
Connection::manager_thread(void *instance)
{
    Connection  *me = reinterpret_cast<Connection*>(instance);
    me->manager();
    return(NULL);
}



//
// Real functionality
//

void
Connection::manager(void)
{
    clog << "Connection::manager() starting: thread id " << pthread_self()
         << endl;
    if (! base->connected()) {
        clog << base->get_id() << " not connected in "
             << "Connection::manager().  Unexpected!" << endl;
        throw(fireball(32, base->get_id() + " not connected!"));
    }

    /* Since this thread is [currently] started from Connection's
     * constructor, the relevant subclasses may not've finished
     * construction.  Can we use RTTI to investigate?  This test
     * will validate that at least *one* more level of construction
     * has happened, but may still not have completed all of them
     */
    while (this->class_name().compare("Connection") == 0)
        usleep(1000);

    clog << "Connection::manager() running" << endl;

    /* Start up the processing engine(s) */
    /* I'm 99% sure this can't be done before calling mamager(),
     * because it can't be called from the constructor when it's
     * still a pure-virtual function.  So, it has to be called
     * after construction completes, and right now this seems to
     * be the only place that's known. */
    start_engine();
    
manage_top:
    try {
        MUTEX_LOG("locking " << &mutex << " with Guard");
        Guard   locker(&mutex);

        // Set the initial state
        clog << "Our base object (" << typeid(*base).name() << " at "
             << base.GetPointer(base) << ") is: " << endl;
        clog << "\t" << base->get_id() << ", and it is ";
        clog << (base->connected() ? "" : "NOT ") << "connected." << endl;
#if MAY_NOT_WANT_THIS
        conn_state = base->connected();
        clog << "Our connection state is " << conn_state << endl;
#endif
        // Now, wait for something.  Messages?  Disconnect/state-change?
        // Call Messageable::get_message and wait for a message.
        while (!please_exit) {
            MessageP    msg = get_message();
            // Now, handle the message.  This will return a Data* if we
            // have data we need to do something with.
            // XXX - Okay.  I need to decide how handle_message() works.
            // if it returns data to be written, I'll need to package that
            // data as a new MessageP object and pass it to queue_data...
            Data        *data = handle_message(msg);
            if (data) {
                // XXX - This assumes handle_message will've dynamically allocated
                // a Data object and returned a pointer to it...
                MessageP        msg2(data);
                if ((dynamic_cast<Outlet*>(this)))
                    dynamic_cast<Outlet*>(this)->queue_data(msg2);
            }
        }
#ifdef SHOULD_NOT_BE_HERE
        int     ret;
        while (connected()) {
            MUTEX_LOG("cond_wait'ing with " << &mutex);
            ret = pthread_cond_wait(&state_change, &mutex);
            PTHREAD_CHECK_AND_THROW(ret, "cond_wait(state_change)");

            if (base->connected()) {
                // Still connected?  Must mean we have control-message(s).
                clog << "(still connected)" << endl;

                // Do stuff.  Is this how we should get here, or should
                // the receipt of the message be handled internal to the
                // code in Messageable?
                clog << "Connection::manager: got a control message?!?" << endl;
            } else {
                conn_state = base->connected();
                // XXX - Should we restart it?  We should check for a
                // shutdown message and restart if not present, prolly...
                clog << "Connection::manager() needs to know how to restart the connection!" << endl;
            }

        }
#endif
    } catch (CMStateChange &e) {
        clog << "Got a state change exception" << endl;
#if MAY_NOT_WANT_THIS
        Guard   locker(&mutex);
        conn_state = base->connected();
        if (!conn_state) {
#else
        if (!base->connected()) {
#endif
            clog << "Our Connector is disconnected, shutting down and noting the disconnect" << endl;
            stop_engine();
            note_disconnect();
        }
        goto manage_top;
    } catch (CMException &e) {
        cerr << "Got a consmgr exception: " << e.what() << endl;
    } catch (std::exception &e) {
        cerr << "Standard exception: " << e.what() << endl;
    } catch (...) {
        cerr << "Caught an unknown thing in Connection::manager(), rethrowing" << endl;
        throw;
    }

#ifdef  SHOULD_NOT_BE_HERE
    try {
        while (is_connected(true)) {
            // It seems that if we're in pthread_cond_wait(), and we're
            // canceled, we may leave the mutex locked, and be exited.
            // XXX - the right solution is likely to avoid any need of
            // ever pthread_cancel()ing anything, but.....
            pthread_cleanup_push(cleanup_unlock, &state_mutex);

            MUTEX_LOG("cond_wait'ing with " << &state_mutex);
            ret = pthread_cond_wait(&state_change, &state_mutex);
            PTHREAD_CHECK_AND_THROW(ret, "cond_wait(state_change)");

            clog << "Connection::manager(" << get_id()
                 << "): State has changed ";
            pthread_cleanup_pop(0);

            if (is_connected(true)) {
                // Still connected?  Must mean we have control-message(s).
                clog << "(still connected)" << endl;

                // Do stuff.
                clog << "Connection::manager: got a control message?!?" << endl;
            } else {
                // XXX - Should we restart it?  We should check for a
                // shutdown message and restart if not present, prolly...
                clog << "Connection::manage() needs to know how to restart the connection!" << endl;
            }
        }
    } catch (...) {
        // XXX - Might the pthread_cleanup already have unlocked it?
        MUTEX_LOG("Unlocking " << &state_mutex << "; and re-throwing");
        pthread_mutex_unlock(&state_mutex);
        throw;
    }

    clog << "(disconnected; nuking threads)" << endl;

    // Destroy each of the child threads (reader & writer), and
    // detach them so that their resources can be recycled...
    try {
        MUTEX_LOG("Unlocking " << &state_mutex << " at end of Connection::manage");
        ret = pthread_mutex_unlock(&state_mutex);
        PTHREAD_CHECK_AND_THROW(ret, "mutex_unlock(state_mutex)");

        shutdown();
    } CATCH_STR_OR_DIE(72) {
        cerr << "Umm, unknown exception at " << __FILE__ << ":"
             << (__LINE__ - 2) << endl;
        exit(74);
    }
#endif  /* SHOULD_NOT_BE_HERE */

    clog << "exiting Connection::manager(); should I be?" << endl;

    // Return [and exit the thread]
    return;
}

#if MAY_NOT_WANT_THIS

bool
Connection::connected()
{
    Guard       locker(&mutex);

    return(this->conn_state);
}
#endif

void
Connection::note_disconnect(void)
{
    MasterController    *mc = MasterController::get_instance();
    MessageP            msg(new Message(Message::C_Disconnected));
    
    mc->queue_message(msg);
    return;
}

#ifdef  SHOULD_NOT_BE_HERE
// Set the connected state of a Connection.  After this, and any subclass
// necessary initialization (of fd's?), it will be ready to be
// Connection::manage'd...
void
Connection::set_connected(bool isconn)
{
    int         ret;

    // Lock the [state] mutex
    MUTEX_LOG("Connection::set_connected() locking " << &state_mutex);
    ret = pthread_mutex_lock(&state_mutex);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_lock(state_mutex)");

    // Check the current state and if it has changed, signal that to
    // anyone watching...
    try {
        bool    old_state = this->connected;

        // If the state changed, broadcast that...
        if (old_state != isconn) {
            this->connected = isconn;

            clog << "Connection::set_connected() broadcasting "
                 << "on state_change" << endl;
            ret = pthread_cond_broadcast(&state_change);
            PTHREAD_CHECK_AND_THROW(ret, "cond_broadcast(state_change)");
#if MAYBE_A_BAD_IDEA
            // XXX - What the hell is id_cache?
            if (! id_cache.empty())
                id_cache.erase();
#endif
        }
    } catch (...) {
        (void)pthread_mutex_unlock(&state_mutex);
        throw;
    }

    // Unlock the mutex
    MUTEX_LOG("Connected::set_connected() unlocking " << &state_mutex);
    ret = pthread_mutex_unlock(&state_mutex);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_unlock(state_mutex)");

    return;
}
#endif  /* SHOULD_NOT_BE_HERE */

#ifdef  SHOULD_NOT_BE_HERE
void
Connection::initiate_connection(void)
{
    // XXX - This reasonable?
    if (is_connected())
        throw(fireball(32, "Tried to initiate an already connected connection!"));

    try {
        // First, perform the underlying connection of whatever type
        this->connect();

        // XXX - does connect() set the state, or do we?
        set_connected(true);

        // Start the processing engine threads.  Our subclasses will have to
        // provide this method, even if it does nothing.
        clog << "*8* Starting the processing engine..." << endl;
        this->start_engine();
    } CATCH_OR_DIE(114) {
        // This will likely just kill us, but...
        throw;
    }

    return;
}
#endif  /* SHOULD_NOT_BE_HERE */

void
Connection::shutdown(void)
{
    try {
        // Shut down any threads that may've been started up to
        // manage this connection
        clog << "*8* Calling engine shutdown from Connection::shutdown()..."
             << endl;
        clog << "*8* We are a '" << typeid(this).name() << "' (" << this->get_id() << endl;
        stop_engine();
    } CATCH_OR_DIE(115) {
        // This will likely just kill us, but...
        throw;
    }

    // XXX - Set please_exit to make the manager exit, and send
    // it a no-op message presuming it's in get_message().
    this->please_exit = true;
    MessageP    noop(new Message(Message::C_None));
    queue_message(noop);
    
    return;
}

---