common/mastercont.cc

Go to the documentation of this file.

// -*- C++ -*-
// vim:ts=8 sts=4 sw=4:

// ***** 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):
// Geoff Adams
// 
// 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 <iostream>

#include "mastercont.h"
#include "bidirconn.h"
#include "udslistener.h"
#include "history.h"
#include "logfile.h"
#include "incoming.h"
#include "sockconn.h"
#include "userttyconn.h"
#include "ipsockaddr.h"
#include "udssockaddr.h"
#include "guard.h"


//
// Construction/destruction
//
MasterController::MasterController(ConfigP &inConfig, bool inServer)
    : config(inConfig), server(inServer)
{
}

MasterController::~MasterController(void)
{

    // XXX - For now, just iterate the recipients, and for any
    // Connection*'s, delete them.

}

// Initialize our static singleton instance member.
MasterController*       MasterController::single_instance = NULL;

//
// Functionality methods
//

// Our "static main" method. This method will be running for essentially
// the entire execution of the program. It instantiates a new MasterController
// object, starts a thread to sit around waiting for Unix signals, and then
// starts setting up Connections and Listeners. After that, it just manages
// those Connections and Listeners, which really means receiving and responding
// to messages from them.
void
MasterController::run(ConfigP &config, bool server)
{
    // There can only be one MasterController [running]...
    if (single_instance)
        throw(CMUnsupported("Unable to run a second MasterController"));

    // Create our singleton instance
    single_instance = new MasterController(config, server);

    // Block signals [before starting up child threads]
    try {
        single_instance->block_signals();
    } catch (...) {
        std::cerr << "Failed to block signals before starting threads, bailing..."
             << std::endl;
        exit(4);
    }

    // And start the signal-handler thread.
    pthread_t tid_signals;
    int ret = pthread_create(&tid_signals, NULL,
        MasterController::signal_handler_thread, single_instance);
    PTHREAD_CHECK_AND_THROW(ret, "pthread_create(signal_handler_thread)");

    // Now, do our main work; managing our Connections and Listeners.
    // it will return when it's time to exit.
    single_instance->manage_connections();

    // Cancel the signal-handling thread; we're done.
    pthread_cancel(tid_signals);
    // And then join it, to make sure it's gone away. Is this necessary, or
    // a good idea?
    pthread_join(tid_signals, NULL);
    
    // OK. All done. Delete our instance and exit.
    // Note: NOT THREAD SAFE! However, I suspect we'll be able to get away
    // with this for the forseeable future, since we'll have terminated all
    // of our threads by this point.
    delete single_instance;
    single_instance = NULL;
}

MasterController *
MasterController::get_instance()
{
    if (!single_instance) {
        // XXX - Throw an exception! We need to have one running for this
        // method to return anything!
    }

    return single_instance;
}

void
MasterController::manage_connections()
{
    clog << "MasterController thread starting, thread id " << pthread_self()
         << endl;
    // XXX - Uhm, do stuff.

    try {
        start_connections();
    } catch (CMFailure &f) {
        cerr << f.what() << endl;
        return;
    }

    do {
        // Now, wait, looking for incoming messages.
        MessageP msg = get_message();
        Message::MsgType        mtype = msg->type();
        
        // XXX - Should handle each kind of message.  But, for now, we're
        // mostly just doing this to wait for something.
        clog << "master thread got a message of type " << msg->name();
        if (mtype == Message::M_Command)
            clog << "(" << msg->code() << ")";
        clog << std::endl;
        
        clog << "Looking for C_Exit" << endl;
        if (mtype == Message::M_Command) {
            if (msg->code() == Message::C_Exit)
                break;
            if (msg->code() == Message::C_Disconnected) {
                if (!server) {
                    // A client getting a disconnect means the server
                    // went away.  Dropping out here and letting the user
                    // figure things out makes sense [for now].
                    break;
                }
                clog << "Eep!  Got a disconnect message, but don't yet know how to remove whoever it was from other childrens' lists." << endl;
                // XXX - Need to remove this from all children's recipients
                // lists...  But, how do we know who sent it?  Need to 
                // encode that in the C_Disconnected message, I guess?
            }
        }
        // XXX - Should see if it's a disconnect we want to issue a reconnect for...
        clog << "Ignoring message, waiting again." << endl;
    } while (1);
    
    // delete the Connections and Listeners we've started. Actually, probably
    // just iterate over the MessageableList, perhaps send them shutdown
    // messages, and then delete them.
    
    //send_exit_messages(); // Messager
    try {
        destroy_children();
    } catch (CMException &e) {
        cerr << e.what() << endl;
    } catch (...) {
        throw;
    }
clog << "MasterController::master_thread() exiting..." << endl;
    return;
}


void
MasterController::start_connections()
{
    if (server) {
        //
        // "server" connection start-up
        //

        BiDirConn       *serv = NULL;
        Incoming        *client = NULL;
        
        // XXX - First, how do we figure out if we're a ttysrv or a tcpsrv?
        // This code ripped from tcpsrv.cc
        try {
            struct sockaddr     *sa = build_addr(*config);
            SocketAddressP      tcp_addr(new IPSocketAddress(sa));
            ConnectorP          conn(new SocketConnector(tcp_addr));

            serv = new BiDirConn(conn);
            delete sa;
        } catch (std::exception &e) {
            cerr << "Exception trying to create a TCP BiDirConn: " << e.what()
                 << std::endl;
            throw;
        }
        clog << "TCP connection started..." << endl;

        // Construct and connect the LogFile object
        if (config->find("logfile") != config->end()) {
            try {
                // XXX - Must be dynamically allocated to not be destroyed
                // at the end of scope, right?
clog << "Creating a LogFile" << endl;
                ConnectorP      log(new LogFile((*config)["logfile"]));
                Outlet          *log_out = new Outlet(log);
clog << "LogFile created (file is '" << (*config)["logfile"] << "') at "
     << log_out << endl;

clog << "Adding to serv's recipients" << endl;
                serv->add_recipient(log_out);
clog << "Added to serv's recipients" << endl;
                add_recipient(log_out);
            } catch (CMInvalidParameter &e) {
                cerr << "Cannot open logfile " << (*config)["logfile"]
                     << ", continuing without logging." << endl;
            } catch (std::exception &e) {
                cerr << "Exception trying to open the logfile: " << e.what()
                     << endl;
                /* XXX - Crash here? */
            }
        }

#if     defined(HISTORY) && (HISTORY > 0)
        // Build the History object
        // XXX - should history [size] be in the configuration?
        try {
clog << "Creating a History" << endl;
            ConnectorP          hist(new History(50));
            Outlet              *hist_out = new Outlet(hist);
clog << "History created (" << HISTORY << " lines) at " << hist_out << endl;

clog << "Adding to serv's recipients" << endl;
            serv->add_recipient(hist_out);
clog << "Added to serv's recipients" << endl;
            add_recipient(hist_out);
        } catch (CMInvalidParameter &e) {
            cerr << "Cannot construct history (" << HISTORY << " lines)"
                 << ", continuing without history." << endl;
        } catch (std::exception &e) {
            cerr << "Exception trying to construct history: " << e.what()
                 << endl;
            /* XXX - Crash here? */
        }
#endif  /* defined(HISTORY) && (HISTORY > 0) */

        // Figure out where we're supposed to open the local socket.
        if (config->find("local_socket") == config->end()) {
            cerr << "No 'local_socket' parameter defined in the configuration; "
                 << "cannot proceed." << std::endl;
            throw(fireball(18,"Cannot start a server without a local_socket"));
        }

        SocketAddressP          socket_path(new UDSSocketAddress((*config)["local_socket"]));
        try {
            ListenerP   base(new UDSListener(socket_path));

            // Construct the Incoming that will take care of these...
            client = new Incoming(base, CONNECT_TO_ONE(serv));
        } catch (CMFailure &f) {
            /* This is an utter failure in this case.  With nothing to
             * listen on, we don't have anything useful to do [we think].
             * throw this back up, and presumedly exit. */
            throw;
        } catch (std::exception &e) {
            cerr << "Exception caught: " << e.what() << endl;
            throw;
        }

        // Keep track of both new Connections so we can notify them of
        // important events in the future.
        add_recipient(serv);
        clog << recipients.size() << " recipients in MasterControllers list" << endl;
        clog << "client is " << client << endl;
        if (client)
            clog << "(" << client->get_id() << ")" << endl;
        add_recipient(client);
    } else {
        //
        // "client" connection start-up.  This code came from console.cc.
        //

        // Then, look in the configuration.  If there's a "local_socket"
        // configured, then connect to that (using a Connector with a
        // UDSSocketAddress).  If not, and there are both "host" and "port"
        // are configured, connect to that via a Connector with a
        // IPSocketAddress.

        BiDirConn       *serv = NULL;   // The Connection to the server process
        BiDirConn       *tty = NULL;    // The Connection to the user

        try {
            // Create a Connector object for the connection.
            if (config->find("local_socket") != config->end()) {
                SocketAddressP  usp(new UDSSocketAddress((*config)["local_socket"]));
                ConnectorP      conn(new SocketConnector(usp));

                serv = new BiDirConn(conn);
            } else if ((config->find("host") != config->end()) &&
                (config->find("port") != config->end())) {
                try {
                    /* Retain the result from build_addr() so it can be freed */
                    struct sockaddr     *sa = build_addr(*config);
                    SocketAddressP      addr(new IPSocketAddress(sa));
                    ConnectorP          conn(new SocketConnector(addr));

                    serv = new BiDirConn(conn);
                    delete sa;
                } catch (CMException &e) {
                    std::cerr << "CM exception: " << e.what() << std::endl;
                    /* Probabaly want to think about this... */
                    throw;
                } catch (std::exception &e) {
                    std::cerr << "Standard exception: " << e.what()
                              << std::endl;
                    throw;
                }
            } else {
                std::cerr << "Unable to find server to connect to in specified "
                     << "configuration.  Please check the config file(s)."
                     << std::endl;
                exit(3);
            }

            clog << "Set server to " << serv->get_id() << std::endl;

        } CATCH_STR_OR_DIE(3) {
            std::cerr << "** Uncaught exception while initializing and/or connecting "
                 << "to the server **" << std::endl;
            exit(3);
        }

        try {
            // And, start up the TTY management thread(s)...
            //UserTTYConn               conn(STDIN_FILENO, STDOUT_FILENO);
            ConnectorP          user(new UserTTYConn(STDIN_FILENO, STDOUT_FILENO));
            tty = new BiDirConn(user);

            // Lastly, add them to each others recipient lists...
            serv->add_recipient(tty);
            tty->add_recipient(serv);
        } CATCH_OR_DIE(5) {
            clog << "Error!  Dunno what, but an exception happened." << std::endl;
            throw;
        }

        // Keep track of both new Connections so we can notify them of
        // important events in the future.
        add_recipient(serv);
        add_recipient(tty);
    }
}

void
MasterController::destroy_children(void)
{
    Guard       locker(&recip_mutex);
    
    clog << "MasterController::destroy_children: iterating " << recipients.size()
         << " children" << endl;
    for (recipient_const_iterator ri = recipients.begin() ;
         ri != recipients.end() ; ++ri) {
        if (dynamic_cast<Connection*>(*ri)) {
            clog << "Stopping " << (*ri)->get_id() << endl;
            dynamic_cast<Connection*>(*ri)->shutdown();
        }
        clog << "Deleting " << (*ri)->get_id() << endl;
        delete *ri;
    }
    return;
}


/*
 * These methods implement the signal handling for the MasterController.
 */

void *
MasterController::signal_handler_thread(void *instance)
{
    MasterController *mc = (MasterController*) instance;

    clog << "MasterController signal-handling thread starting, thread id "
        << pthread_self() << endl;

    mc->handle_signals();       /* Doesn't return! */

    return NULL;
}

void
MasterController::block_signals()
{
    if (sigfillset(&all) != 0)
        throw;
    sigprocmask(SIG_BLOCK, &all, &prev);
}

/* XXX - should I verify that block_signals() has been called? */
int
MasterController::wait_for_signal()
{
    int         ret;
# if    NO_SIGTIMEDWAIT
    int         signo;
#  define       SIGNO   signo
# else
    // Information returned from sigtimedwait(3)...
    siginfo_t   si;
    timespec    timer = { 5, 0 };       // 5 seconds
#  define       SIGNO   si.si_signo
# endif /* NO_SIGTIMEDWAIT */

    // Wait on the signals we know what to do with...
    sigemptyset(&all);
    sigaddset(&all, SIGHUP);
    sigaddset(&all, SIGINT);
    sigaddset(&all, SIGTERM);
# if    NO_SIGTIMEDWAIT
    ret = sigwait(&all, &signo);
# else
    ret = sigtimedwait(&all, &si, &timer);
    if ((ret < 0) && (errno == EAGAIN)) {
        clog << "Timeout from sigtimedwait(), waiting again..." << std::endl;
        SIGNO = 0;
    } else
# endif /* NO_SIGTIMEDWAIT */
    if (ret < 0) {
        /* Running in GDB causes EINTR to occur.  Gloss over this for now... */
        if (errno != EINTR)
            err(6, "sigwait()/sigtimedwait() failure");
        SIGNO = 0;
    }

    return(SIGNO);
#undef SIGNO
}

/*
 * Handles Unix signals. Does not return, so you should run this from a
 * thread that you can pthread_cancel.
 *
 * XXX - should I verify that block_signals() has been called?
 */
void
MasterController::handle_signals()
{
    clog << "MasterController::handle_signals (thread id " << pthread_self()
         << ") running and waiting for signals" << endl;
    do {
        int sig = wait_for_signal();
        switch (sig) {
          case 0:
            break;
          case SIGHUP:
            {
                // If we're a client, HUP means "go away now".  As a server,
                // it might mean something else, but we haven't decided that
                // yet.
                if (server) {
                    clog << "Got a HUP; doing nothing for now." << std::endl;
                } else {
                    MessageP    msg(new Message(Message::C_Exit));
                    
                    clog << "Got a " << strsignal(sig) << ", queueing a message"
                         << std::endl;
                    // Let ourself know shutdown has been requested.
                    clog << "Sending shutdown message to MasterController"
                         << std::endl;
                    queue_message(msg);
                }
            }
            break;
          case SIGINT:
          case SIGTERM:
            {
                clog << "Got a " << strsignal(sig) << ", queueing a message" << std::endl;
                MessageP        msg(new Message(Message::C_Exit));
                // Let ourself know shutdown has been requested.
                clog << "Sending shutdown message to MasterController"
                    << std::endl;
                queue_message(msg);
            }
            break;
          default:
            std::cerr << "Got an unexpected signal (" << sig << "; "
                 << strsignal(sig) << ") - exiting suddenly." << std::endl;
            exit(50 + sig);
            /* NOTREACHED */
        }
    } while (true);
}

std::string
MasterController::get_id(void) const
{
    std::string         id("MasterController");
    
    // XXX - What should we return here?
    if (server)
        id += "(server)";
    else
        id += "(client)";
    
    return(id);
}

---