流媒体/Mpeg4/MP4

开发平台：
C/C++

ServiceApplication.cxx：源码内容
							/* ====================================================================
 * 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 vocal@vovida.org.
 *
 * 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.4 2001/05/24 11:01:38 icahoon Exp $";
#include "ServiceApplication.hxx"
#include "Config.hxx"
#include "Daemon.hxx"
#include "Random.hxx"
#include "Thread.hxx"
#include "ServiceManager.hxx"
#include "SignalHandler.hxx"
#include "SignalAction.hxx"
#include "Fifo.h"
#include "PollFifo.hxx"
#include "VLog.hxx"
#include <cassert>
#include <csignal>
using Vocal::Application;
using Vocal::Services::ServiceApplication;
using Vocal::Configuration::Config;
using Vocal::Services::ServiceManager;
using Vocal::Services::Event;
using Vocal::Threads::Thread;
using Vocal::Signals::SignalHandler;
using Vocal::Signals::SignalSet;
using Vocal::Signals::SignalAction;
using Vocal::Logging::VLog;
using Vocal::Random;
using Vocal::ReturnCode;
ServiceApplication::ServiceApplication()
    :	myConfig(0),
    	myTerminateSignals(0),
    	myTerminateAction(0),
    	myFifo(0),
    	myServiceMgr(0)
{
}
ServiceApplication::~ServiceApplication()
{
}
ReturnCode
ServiceApplication::init(int argc, char ** argv, char **)
{
    myConfig = createConfig();
    assert( myConfig != 0 );
    
    int     fatalError = 1;
    
    if ( myConfig->load(argc, argv) != SUCCESS )
    {
        return ( fatalError );
    }
    if ( myConfig->asDaemon() == true )
    {
        if ( Daemon() != SUCCESS )
        {
    	    cerr << "Cannot start as daemon." << endl;
	    return ( fatalError );
        }
        // Update the pid.
        //
        myConfig->pid();
    }
    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);
    assert( myTerminateAction != 0 );
    
    Thread::self()->signalHandler().add(*myTerminateAction);
    // Create the message fifo.
    //
    if ( myConfig->underDebugger() )
    {
    	myFifo = new Fifo< Sptr<Event> >;
    }
    else
    {
    	myFifo = new PollFifo< Sptr<Event> >;
    }
    // Create service manager
    //
    myServiceMgr = new ServiceManager(*myFifo, myTerminateAction);
    // Give the use a chance to initialize.
    //
    userInit();    
    // Double check userInit didn't do anything too strange.
    //
    assert( myConfig != 0 );
    assert( myTerminateSignals != 0 );
    assert( myTerminateAction != 0 );
    assert( myFifo != 0 );
    assert( myServiceMgr != 0 );
    
    // Report initialization complete.
    //
    VINFO(log) << fn << ": Program initialized." << VINFO_END(log);
    		    
    return ( 0 );
}
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() const
{
    return ( new Config );
}
        
        
const vector<int> & 
ServiceApplication::terminateSignals() const
{
    static  vector<int>     signals;
    if ( signals.size() == 0 )
    {
        signals.push_back(SIGHUP);
        signals.push_back(SIGTERM);
        signals.push_back(SIGINT);
    }
    return ( signals );
}
string
ServiceApplication::logFile() const
{
    assert( myConfig != 0 );
    string filename = myConfig->applicationName() + string(".log");
    return ( filename );
}
void        
ServiceApplication::userInit()
{
}
void        
ServiceApplication::userUninit()
{
}
Config &                    
ServiceApplication::config()
{
    return ( *myConfig );
}
const Config &                    
ServiceApplication::config() const
{
    return ( *myConfig );
}
FifoBase< Sptr<Event> > &   
ServiceApplication::fifo()
{
    return ( *myFifo );
}
        
        
ServiceManager &            
ServiceApplication::serviceManager()
{
    return ( *myServiceMgr );
}

						