appcontext.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Ilya A. Volynets-Evenbakh                       *
 *   ilya@total-knowledge.com                                              *
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 *   This program 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 this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef _SERVERCONFIG_APPCONTEXT_H_
#define _SERVERCONFIG_APPCONTEXT_H_

#include "context.h"
#include "contextregistry.h"
#include "paramregistry.h"
#include "globalcontext.h"
#include "../ServletMap.h"
#include <servlet/ServletContext.h>
#include <servlet/Servlet.h>
#include <ServletConfigImpl.h>
#include <servletcontainer.h>
#include <sptk4/CThread.h>

#ifdef HAVE_LIBMAGIC
#include <magic.h>
#endif

namespace container {
namespace serverconfig {
class GlobalContext;

class AppContext:
    public Context, public servlet::ServletContext
{
    static ContextRegistry m_contextregistry;
    static ParamRegistry<AppContext> m_paramregistry;
    time_t m_sessionTimeout;
    std::string m_uploadDir;
    util::pairlist_t m_init_params;
private:
    static void registerParams(ParamRegistry<AppContext>&);
    static void registerContexts(ContextRegistry&);
protected:
    virtual bool onSetParam(const ConfigNode&);
    virtual Context* getContext(const ConfigNode& node)
    { return m_contextregistry.getContext(node, this); }
    virtual bool onPreComplete();
    virtual bool onPostComplete();
    bool setSessionTimeout(const ConfigNode&);
    bool setUploadDir(const ConfigNode&);
    bool addInitParam(const ConfigNode&);
    bool setPhysBase(const ConfigNode&);
    bool setDefaultMimeType(const ConfigNode&);
    bool setDefaultCharacterEncoding(const ConfigNode&);
    bool setUriBase(const ConfigNode&);
private:
    AppContext(const ConfigNode& node, Context* parent);
public:
    ~AppContext();
    static Context* contextCreator(const ConfigNode& node, Context* parent)
    { return new AppContext(node, parent); }
    GlobalContext* getGlobalContext()
    { return static_cast<GlobalContext*>(getParent()); }

private:
    typedef servlet::Servlet* (*servletcreatefunc_t)();
    struct ServletDesc
    {
        ServletDesc(servlet::Servlet* serv,container::ServletConfigImpl* conf,void* handle, const std::string& path, size_t maxRequestSize, size_t maxFileSize, const std::string& mime, const std::string& enc, bool cache)
            : m_cont(serv,conf,path, maxRequestSize, maxFileSize, mime, enc, cache)
            , m_h(handle)
        {}
        ServletContainer m_cont;
        void* m_h;
    };
public:
    typedef ServletMap<ServletDesc> servletmap_t;
private:
    servletmap_t m_maptop;

    static void splitServPath(const std::string& path, std::string& dir, std::string& name);
    void unloadServlet(const std::string& path);
    ServletDesc* getDesc(const std::string& path);
    void initServlet(const std::string& path);
    void destroyServlet(const std::string& path);
public:
    ServletConfigImpl* addServlet(const std::string& path, const std::string& name, const std::string& dso, bool hidden, size_t maxRequestSize, size_t maxFileSize);
    void delServlet(const std::string& path);
    ServletContainer* getServletContainer(const std::string& path);
    void initServlets();
    void destroyServlets();

private:
    class SessionCleaner: public sptk::CThread
    {
    private:
        bool m_running;
        int m_freq;
        AppContext* m_ctx;
        int m_trigger[2];
    public:
        SessionCleaner(AppContext* ctx,int freq);
        ~SessionCleaner();
        void stop();
        virtual void threadFunction();
        void wakeUp();
    };
    SessionCleaner *m_cleaner;
private:
    typedef std::map<std::string, HttpSessionImpl*> sessionlist_t;
    sessionlist_t m_sessions;
    std::string m_sessionCookieName;
    std::string m_fileSaveTemplate;
    sptk::CWaiter m_sessionLock; //Used for locking session list for modification
    typedef std::map<std::string,boost::shared_ptr<void> > attr_t;
    attr_t m_attrs;
    typedef std::map<std::string,std::string> param_t;
    param_t m_params;
    std::string m_uribase;
    std::string m_physbase;
    std::string m_mime;
    std::string m_enc;
    bool m_cache; 
#ifdef HAVE_LIBMAGIC
    magic_t m_mime_cookie;
#endif

public:
    HttpSessionImpl* getSession(const std::string& sid, bool create);

    const std::string& getSessionCookieName()
    {
        return m_sessionCookieName;
    }
    void killSession(const std::string& sid);
    void cleanSessions();
    bool isSessionValid(const std::string& sid);
    void addInitParam(const std::string& name, const std::string& value);

    void killAllSessions();
    const std::string& getFileSaveTemplate() const {return m_fileSaveTemplate;}
    const std::string& getUriBase() const { return m_uribase;}
public:
    virtual servlet::ServletContext* getContext(const std::string& uripath);
    virtual int  getMajorVersion();
    virtual int  getMinorVersion();
    virtual std::string  getMimeType(const std::string& file);
    virtual std::auto_ptr< std::set<std::string> >  getResourcePaths(const std::string& path);
    virtual std::string getResource(const std::string& path);
    virtual std::istream& getResourceAsStream(const std::string& path);
    virtual servlet::RequestDispatcher* getRequestDispatcher(const std::string& path);
    virtual servlet::RequestDispatcher* getNamedDispatcher(const std::string& name);
    virtual void  log(const std::string& msg) const ;
    virtual void  log(const std::string& message, const std::exception& e) const ;
    virtual std::string  getRealPath(const std::string& path);
    virtual std::string  getServerInfo();
    virtual std::string  getInitParameter(const std::string& name);
    virtual std::auto_ptr< std::vector<std::string> > getInitParameterNames();
    virtual boost::shared_ptr<void> getAttribute(const std::string& name);
    virtual std::auto_ptr< std::vector<std::string> > getAttributeNames();
    virtual void setAttribute(const std::string& name, boost::shared_ptr<void> object);
    virtual void  removeAttribute(const std::string& name);
    virtual bool hasAttribute(const std::string& name) const;
    virtual std::string  getServletContextName() const;

private:
    HttpSessionImpl* newSession();
    static std::string makeSName(const std::string& name);
};

}
}
#endif // _SERVERCONFIG_APPCONTEXT_H_