/home/vlg/develop/libASSA/libassa/assa/GenServer.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                             GenServer.h
//------------------------------------------------------------------------------
//  Copyright (c) 1999-2005 by Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
#ifndef GENSERVER_H
#define GENSERVER_H

extern "C" {
#include <stdio.h>              /* printf, sprintf         */
#include <unistd.h>
#include <stdlib.h>             /* getopt()                */
#include <string.h>             /* strlen                  */
#include <errno.h>              /* errno                   */
#include <signal.h>             /* kill                    */
#include <sys/types.h>          /* open                    */
#include <sys/stat.h>           /* open                    */
#include <fcntl.h>              /* open                    */
#include <limits.h>             /* PATH_MAX                */
#include <assert.h>

#if !defined(WIN32)
#    include <sys/resource.h>       /* getrlimit               */
#    include <syslog.h>
#endif
}

#include <iostream>
#include <sstream>  
#include <string>
#include <vector>

using std::string;
using std::vector;

#include "assa/Assure.h"
#include "assa/Handlers.h"
#include "assa/SigHandlers.h"
#include "assa/Fork.h"
#include "assa/Reactor.h"
#include "assa/CmdLineOpts.h"
#include "assa/PidFileLock.h"

namespace ASSA {

class GenServer : 
    public virtual EventHandler, 
    public CmdLineOpts
{
public:
    enum LogFlag { 
        KEEPLOG,                
        RMLOG                   
    };

public:
    GenServer ();

    virtual ~GenServer() {}

    virtual void init (int* argc, char* argv[], const char* help_info);

    virtual int fini (void) { return 0; }
    
    virtual int suspend (void) { return 0; }

    virtual int resume (void) { return 0; }

    virtual void init_service () =0;

    virtual void process_events () =0;

    virtual void fatal_signal_hook () { /*--- empty ---*/ }

    int handle_signal (int signum_);

    bool service_is_active () { return (!m_graceful_quit); }

    void stop_service ();

    void set_version (const string& release_, int revision_);

    string get_version ();

    void set_author (const string& author_);

    void set_flags (LogFlag logf_) { m_log_flag = logf_; }

    virtual void display_help ();

    string get_proc_name () { return m_proc_name; }

    void set_proc_name (string proc_name_) { m_proc_name = proc_name_; }

    string get_cmdline_name () { return m_cmdline_name; }

    string get_default_config_file () { return m_default_config_file; }
        
    string get_config_file () { return m_config_file; }

    string get_port () { return m_port; }

    void set_port (string port_) { m_port = port_; }

#if !defined(WIN32)

    SigHandlers& get_sig_manager () { return m_sig_dispatcher; }
#endif
    
    Reactor* get_reactor () { return &m_reactor; }

    static bool become_daemon ();

    int get_exit_value () const  { return m_exit_value; }

protected:
    void set_exit_value (int v_) { m_exit_value = v_; }

protected:
    string   m_proc_name;            

    string   m_cmdline_name;         

    string   m_port;

    string   m_default_config_file;

    string   m_config_file;
    
    u_int    m_log_size;
    
    int      m_instance;
    
    string   m_log_file;

    string   m_with_log_server;

    string   m_log_server;

    long     m_mask;

    bool     m_graceful_quit;

#if !defined(WIN32)

    SigHandlers m_sig_dispatcher;

    SIGPOLLHandler m_sig_poll;
#endif

    Reactor m_reactor;

    string m_version;
    
    int m_revision;

    string m_author;

    const char* m_help_msg;
    
    LogFlag m_log_flag;

    string m_log_stdout;
    
    string m_daemon;

    string m_ommit_pidfile;

    int m_log_level;

    PidFileLock m_pidfile_lock;

    string m_pidfile;

    bool m_help_flag;

    bool m_version_flag;

    int m_exit_value;

private:
    GenServer (const GenServer&);
    GenServer& operator=(const GenServer&);

    void init_internals ();
};


inline void
GenServer::
stop_service ()
{
    m_graceful_quit = true; 
    m_reactor.deactivate ();
}

inline void
GenServer::
set_version (const string& release_, int revision_)
{
    m_version = release_;
    m_revision = revision_;
}

inline void
GenServer::
set_author (const string& author_)
{
    m_author = author_;
}

inline string
GenServer::
get_version ()
{
    std::ostringstream v;
    v << "Version: " <<  m_version << " Revision: " << m_revision << std::ends;
    return (v.str ());
}

inline void 
GenServer::
display_help ()
{
    std::cout << m_help_msg << '\n' 
              << "Written by " << m_author << "\n" << std::endl;
}

} // The end of namespase ASSA


#endif /* GENSERVER_H */

---