serviceapplication.cxx

SIP（Session Initiation Protocol）是由IETF定义

/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact [e-mail].
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF ,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 */


static const char* const ServiceApplication_cxx_Version = 
    "$Id: ServiceApplication.cxx,v 1.9 2002/03/16 04:55:32 icahoon Exp $";


#include "global.h"
#include "ServiceApplication.hxx"
#include "Config.hxx"
#include "Daemon.hxx"
#include "Random.hxx"
#include "Thread.hxx"
#include "MTServiceManager.hxx"
#include "STServiceManager.hxx"
#include "SignalHandler.hxx"
#include "SignalAction.hxx"
#include "PollFifo.hxx"
#include "VLog.hxx"
#include <cassert>
#include <csignal>


using namespace Vocal;
using Vocal::Services::ServiceApplication;
using Vocal::Configuration::Config;
using Vocal::Services::ServiceManager;
using Vocal::Services::MTServiceManager;
using Vocal::Services::STServiceManager;
using Vocal::Services::Event;
using Vocal::Threads::Thread;
using Vocal::Signals::SignalHandler;
using Vocal::Signals::SignalSet;
using Vocal::Signals::SignalAction;
using Vocal::Logging::VLog;


ServiceApplication::ServiceApplication(bool singleThreaded)
    :	myConfig(0),
    	myTerminateSignals(0),
    	myTerminateAction(0),
    	myFifo(0),
    	myServiceMgr(0),
        mySingleThreaded(singleThreaded)
{
}


ServiceApplication::~ServiceApplication()
{
}


ReturnCode
ServiceApplication::init(int argc, char ** argv, char **)
{
    myConfig = createConfig();
    assert( myConfig != 0 );
    
    int     fatalError = 1;
    
    if  (   myConfig->load(argc, argv) != SUCCESS 
        ||  postConfig() != SUCCESS
        )
    {
        return ( fatalError );
    }

    if ( myConfig->asDaemon() == true )
    {
        if ( Daemon(myConfig->daemonRedirectOutput()) != SUCCESS )
        {
    	    cerr << "Cannot start as daemon." << endl;
	    return ( fatalError );
        }

        // Update the pid.
        //
        myConfig->newPid();
    }

    Thread::init();
    SignalHandler::init();
    VLog::init(myConfig->logLevel(), logFile().c_str());

    const string    fn("ServiceApplication::init");
    VLog    	    log(fn);

    // Report to both the log and cout, since both have proved useful.
    //
    VNOTICE(log) << "\n" << *myConfig << VNOTICE_END(log);
    cout << *myConfig << endl;

    // Initialize random.
    //
    Random::init();
    
    // Set up signal handling.
    //
    const vector<int> &  termSignals = terminateSignals();

    myTerminateSignals = new SignalSet(termSignals);
	
    Thread::self()->signalHandler().block(*myTerminateSignals);

    myTerminateAction = new SignalAction(*myTerminateSignals);
    
    Thread::self()->signalHandler().add(*myTerminateAction);


    // Create the message fifo.
    //
    if ( !mySingleThreaded )
    {
	myFifo = new PollFifo< Sptr<Event> >;
    }

    // Create service manager
    //
    if ( mySingleThreaded )
    {
        myServiceMgr = new STServiceManager(myTerminateAction);
    }
    else
    {
        myServiceMgr = new MTServiceManager(*myFifo, myTerminateAction);
    }

    // Give the use a chance to initialize.
    //
    ReturnCode rc = userInit();    

    // Double check userInit didn't do anything too strange.
    //
    assert( myConfig != 0 );
    assert( myTerminateSignals != 0 );
    assert( myTerminateAction != 0 );
    assert( myServiceMgr != 0 );
    
    if ( rc == SUCCESS )
    {
        // Report initialization complete.
        //
        VINFO(log) << fn << ": Program initialized." << VINFO_END(log);
    }
    else
    {
        VWARN(log) << fn << ": Exiting, rc = " << rc << VWARN_END(log);
    }    		    
    return ( rc );
}


void	    	    
ServiceApplication::uninit()
{
    userUninit();
    
    delete myServiceMgr;        myServiceMgr = 0;
    delete myFifo;              myFifo = 0;
    delete myTerminateAction;   myTerminateAction = 0;
    delete myTerminateSignals;  myTerminateSignals = 0;
    delete myConfig;            myConfig = 0;

    {
        VLog	log;
    	VINFO(log) << "ServiceApplication::uninit: Program uninitialized." 
	    	   << VINFO_END(log);
    }

    VLog::uninit();
    SignalHandler::uninit();
    Thread::uninit();
}


ReturnCode  	    
ServiceApplication::run()
{
    const string    fn("ServiceApplication::run");
    VLog    	    log(fn);
    
    ReturnCode	    rc = SUCCESS;
    
    VINFO(log) << fn << ": Program start." << VINFO_END(log);

    rc = myServiceMgr->start();

    if	( rc == SUCCESS )
    {
        VINFO(log) << fn << ": Services started." << VINFO_END(log);

        rc = myServiceMgr->run();
        
        if ( rc == SUCCESS )
        {
    	    myServiceMgr->stop();

            VINFO(log) << fn << ": Services stopped." << VINFO_END(log);
        }
    }
    
    myServiceMgr->shutdown();

    VINFO(log) << fn << ": Services shutdown." << VINFO_END(log);
    VINFO(log) << fn << ": Program shutdown." << VINFO_END(log);

    return ( rc );
}


Config *    
ServiceApplication::createConfig()
{
    return ( new Config );
}
        

ReturnCode
ServiceApplication::postConfig()
{
    return ( SUCCESS );
}

        
const vector<int> & 
ServiceApplication::terminateSignals() const
{
    static  vector<int>     signals;

    #if !defined(WIN32)
    if ( signals.size() == 0 )
    {
        signals.push_back(SIGHUP);
        signals.push_back(SIGTERM);
        signals.push_back(SIGINT);
    }
    #endif // !defined(WIN32)

    return ( signals );
}


string
ServiceApplication::logFile() const
{
    assert( myConfig != 0 );
    string filename = myConfig->applicationName() + string(".log");
    return ( filename );
}


ReturnCode
ServiceApplication::userInit()
{
    return ( SUCCESS );
}


void        
ServiceApplication::userUninit()
{
}


Config &                    
ServiceApplication::config()
{
    assert(myConfig);

    return ( *myConfig );
}


const Config &                    
ServiceApplication::config() const
{
    assert(myConfig);

    return ( *myConfig );
}


SignalAction &
ServiceApplication::signalAction()
{
    assert(myTerminateAction);

    return ( *myTerminateAction );
}


FifoBase< Sptr<Event> > &   
ServiceApplication::fifo()
{
    assert(myFifo);

    return ( *myFifo );
}
        
        
ServiceManager &            
ServiceApplication::serviceManager()
{
    assert(myServiceMgr);

    return ( *myServiceMgr );
}