XmlRpcDaemon.h

Go to the documentation of this file.

/*------------------------------------------------------------------------------
 
    Copyright (c) 2004 Media Development Loan Fund
  
    This file is part of the Campcaster project.
    https://www.campware.org/
    To report bugs, send an e-mail to [email protected]
  
    Campcaster 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.
   
    Campcaster is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
  
    You should have received a copy of the GNU General Public License
    along with Campcaster; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
  
    Author   : $Author: fgerlits $
    Version  : $Revision: 2329 $
    Location : $URL: svn://code.campware.org/campcaster/trunk/campcaster/src/products/scheduler/src/XmlRpcDaemon.h $
 
------------------------------------------------------------------------------*/
#ifndef XmlRpcDaemon_h
 #define XmlRpcDaemon_h
 
#ifndef __cplusplus
 #error This is a C++ include file
 #endif
 

/* ============================================================ include files */

#ifdef HAVE_CONFIG_H
 #include "configure.h"
#endif
 
#if HAVE_SYS_TYPES_H
 #include <sys/types.h>
#else
 #error "Need sys/types.h"
 #endif
 
#if HAVE_UNISTD_H
 #include <unistd.h>
#else
 #error "Need unistd.h"
 #endif
 
#include <string>
#include <stdexcept>
#include <libxml++/libxml++.h>
#include <XmlRpc.h>

#include "LiveSupport/Core/Ptr.h"


namespace LiveSupport {
namespace Scheduler {

using namespace XmlRpc;
using namespace LiveSupport::Core;

/* ================================================================ constants */


/* =================================================================== macros */


/* =============================================================== data types */

class XmlRpcDaemon
{
    private:
        static const std::string    configElementNameStr;

        std::string             xmlRpcHost;

        unsigned int            xmlRpcPort;

        std::string             pidFileName;

        bool                    configured;

        bool                    background;

        Ptr<XmlRpcServer>::Ref xmlRpcServer;

        bool
        daemonize(void)                         throw (std::runtime_error);

        void
        savePid(void)                                   throw();

        pid_t
        loadPid(void)                                   throw();

    protected:
        XmlRpcDaemon (void)                             throw ()
        {
            background = true;
            configured = false;
            xmlRpcServer.reset(new XmlRpcServer());
        }

        virtual
        ~XmlRpcDaemon(void)                             throw ()
        {
        }

        void
        checkForConfiguration(void) const       throw (std::logic_error)
        {
            if (!configured) {
                throw std::logic_error("not yet configured");
            }
        }

        void
        configureXmlRpcDaemon(const xmlpp::Element    & element)
                                                throw (std::invalid_argument,
                                                       std::logic_error);


        virtual void
        registerXmlRpcFunctions(Ptr<XmlRpcServer>::Ref  xmlRpcServer)
                                                    throw (std::logic_error)
                                                                          = 0;

        virtual void
        startup (void)                              throw (std::logic_error);


    public:
        static const std::string
        getConfigElementName(void)                      throw ()
        {
            return configElementNameStr;
        }

        const bool
        isConfigured(void) const                        throw ()
        {
            return configured;
        }

        void
        setBackground(const bool    background)         throw ()
        {
            this->background = background;
        }

        const bool
        getBackground(void) const                       throw ()
        {
            return background;
        }

        virtual void
        configure(const xmlpp::Element    & element)
                                                throw (std::invalid_argument,
                                                       std::logic_error)
                                                                          = 0;

        const std::string
        getXmlRpcHost(void) const                       throw (std::logic_error)
        {
            checkForConfiguration();
            return xmlRpcHost;
        }

        const unsigned int
        getXmlRpcPort(void) const                       throw (std::logic_error)
        {
            checkForConfiguration();
            return xmlRpcPort;
        }

        const std::string
        getPidFileName(void) const                      throw (std::logic_error)
        {
            checkForConfiguration();
            return pidFileName;
        }

        void
        start (void)                                throw (std::logic_error);

        bool
        isRunning (void)                            throw (std::logic_error);

        void
        stop (void)                                 throw (std::logic_error);

        virtual void
        shutdown (void)                             throw (std::logic_error);
};


/* ================================================= external data structures */


/* ====================================================== function prototypes */


} // namespace Scheduler
} // namespace LiveSupport

#endif // XmlRpcDaemon_h
 

---