Total Knowledge

SelfSoft, Inc.

[Home] [Site Map] [Services] [Open Source / Projects] [About the Company] [Help] [Contact] [Portfolio]

CPPSERV

[CPPSERV] [Documentation] [Download] [Contact] [Bug tracker] [News] [RSS Feed] [gitweb]

App.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 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.             *
 ***************************************************************************/

#include <App.h>
#include <requesthandler.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <sptk3/CBase64.h>
#include <servlet/IllegalArgumentException.h>
#include <serverconfig.h>

namespace container
{
ServletConfigImpl* App::addServlet(const std::string& path, const std::string& name, const std::string& dso, bool hidden)
{
        void* dsoHandle=dlopen(dso.c_str(),RTLD_LAZY);
        if(!dsoHandle) {
                std::cerr<<dlerror()<<std::endl;
                return 0;
        }
        servletcreatefunc_t createFunc=(servletcreatefunc_t)dlsym(dsoHandle,(name + "_createServlet").c_str());
        if(!createFunc) {
                std::cerr<<"Could not locate servlet "<<name<<" in the library "<<dso<<": "<<dlerror()<<std::endl;
                return 0;
        }
        ServletConfigImpl* config=new ServletConfigImpl(this, name);
        ServletDesc* desc=new ServletDesc(createFunc(), config, dsoHandle, path);
        addServlet(path, desc);
        if(!hidden)
                RequestHandler::addServlet(path,getServletContainer(path));
        return config;
}

bool App::addServlet(const std::string& path,ServletDesc* d)
{
        maptop[path] = d;
        return true;
}

App::ServletDesc* App::getDesc(const std::string& path)
{
        return maptop.getServletDesc(path);
}

void App::delServlet(const std::string& path)
{
        maptop.removeDesc(path);
}

ServletContainer* App::getServletContainer(const std::string& path)
{
        ServletDesc* desc = getDesc(path);
        if(!desc)
                return 0;
        return &(desc->cont);
}

void* App::getDso(const std::string& path)
{
        ServletDesc* desc = getDesc(path);
        if(!desc)
                return 0;
        return desc->h;
}

void App::splitServPath(const std::string& path, std::string& dir, std::string& name)
{
        std::string::size_type slash = path.rfind('/');
        if(slash == std::string::npos) {
                dir = "/";
                name = path;
        } else {
                dir.assign(path.substr(0, slash));
                name.assign(path.substr(slash + 1));
        }
}

void App::initServlet(const std::string& path)
{
        ServletContainer* cont=getServletContainer(path);
        cont->init();
}

void App::destroyServlet(const std::string& path)
{
        ServletContainer* cont=getServletContainer(path);
        cont->destroy();
}

void App::unloadServlet(const std::string& path)
{
        ServletContainer* cont=getServletContainer(path);
        servlet::ServletConfig* conf=cont->getConfig();
        ServletDesc* d=getDesc(path);
        void* dsoHandle=d->h;
        delServlet(path);
        delete d; // this will delete ServletContainer, which will in turn delete servlet object
        delete conf;
        dlclose(dsoHandle);
}

class RHServletRemover
{
public:
        void operator()(const std::string& path)
        {
                RequestHandler::removeServlet(path);
        }
};

template<class T>
 class SMFunctor
{
private:
        T* inst;
        typedef void (T::*F)(const std::string&);
        F f;
public:
        SMFunctor(T* inst, F f): inst(inst), f(f){}
        void operator()(const std::string& path)
        {
                (inst->*f)(path);
        }
};

App::~App()
{
        cleaner->stop();
        delete cleaner;
        killAllSessions();
        std::string empty;
        destroyServlets(); // Calls destroy() on all servlets, before unloading them
        RHServletRemover rh;
        SMFunctor<App> unl(this, &App::unloadServlet);
        // This will block till all requests being processed by this servlet
        // are done. Alternatively we may want to kill all processes that are
        // in this servlet. Maybe there should be some timeout
        maptop.forEachServletPath(rh, empty);
        maptop.forEachServletPath(unl, empty);
}

void App::initServlets()
{
        std::string empty;
        SMFunctor<App> init(this, &App::initServlet);
        maptop.forEachServletPath(init, empty);
}

void App::destroyServlets()
{
        std::string empty;
        SMFunctor<App> destroy(this, &App::destroyServlet);
        maptop.forEachServletPath(destroy, empty);
}


App::App(ServerConfig& cfg, time_t sessionTimeout, const std::string& name, const std::string& fileSaveDir, const std::string& uribase)
        : servlet::ServletContext()
        , cfg(cfg)
        , sessionCookieName(makeSName(name))
        , sessionTimeout(sessionTimeout)
        , fileSaveTemplate(fileSaveDir+'/'+"cppserv.tmpXXXXXX")
        , name(name)
        , m_uribase(uribase)
{
        cleaner=new SessionCleaner(this,sessionTimeout/2+1); // +1, so that it doesn't become 0...
        cleaner->run();
}

container::HttpSessionImpl* App::getSession(const std::string& sid, bool create)
{
        sessionLock.lock();
        if(sid.empty()) {
                container::HttpSessionImpl *s = 0;
                if(create) s = newSession();
                sessionLock.unlock();
                return s;
        }
        sessionlist_t::iterator s=sessions.find(sid);
        //FIXME: should we perhaps return an invalid session in this case?
        if(s==sessions.end()||!s->second->validP()){
                HttpSessionImpl* s = 0;
                if(create) s = newSession();
                //s->invalidate();
                sessionLock.unlock();
                return s;
        }
        s->second->notNew();
        sessionLock.unlock();
        return s->second;
}


container::HttpSessionImpl* App::newSession()
{
        std::string sid=container::util::getRandomString(10);
        HttpSessionImpl* s=new HttpSessionImpl(*this,sid,sessionTimeout);
        sessions[sid]=s;
        return s;
}


void App::killSession(const std::string& sid)
{
        sessionlist_t::iterator s=sessions.find(sid);
        if(s==sessions.end()){
                return;
        }
        delete s->second;
        sessions.erase(sid);
}


void App::cleanSessions()
{
        sessionLock.lock();
        sessionlist_t::iterator cur=sessions.begin();
        while(cur!=sessions.end()){
                if(!cur->second->validP()){
                        killSession(cur->first);
                        // killSession modifies the map, so we have
                        // to restart our search from scratch.
                        // Another option would be to leave this alone,
                        // In hopes that we'll get to every expired session
                        // sooner or later - Harder on RAM, easier on CPU
                        cur=sessions.begin();
                } else {
                        cur++;
                }
        }
        sessionLock.unlock();
}
App::SessionCleaner::SessionCleaner(App* ctx,int freq)
        : sptk::CThread("",true)
        , running(true)
        , freq(freq)
        , ctx(ctx)
{
        if(pipe(trigger)==-1) {
                std::cerr<<"Error setting up session cleaner trigger: "<<strerror(errno)<<std::endl;
                ::exit(1);
        }
        if(fcntl(trigger[0],F_SETFL,O_NONBLOCK)<0) {
                std::cerr<<"Error setting trigger reader to non-blocking mode: "
                        <<strerror(errno)<<std::endl;
                exit(1);
        }
}
App::SessionCleaner::~SessionCleaner()
{
        close(trigger[0]);
        close(trigger[1]);
}
void App::SessionCleaner::threadFunction()
{
        while(running) {
                ctx->cleanSessions();
                struct timeval timeout={freq,0};
                fd_set rfd;
                FD_ZERO(&rfd);
                FD_SET(trigger[0],&rfd);
                int r=select(trigger[0]+1,&rfd,0,0,&timeout);
                if(r){
                        char buf[4];
                        while(::read(trigger[0],buf,sizeof(buf))>0);
                }
        }
}
void App::SessionCleaner::stop()
{
        running=false;
        this->wakeUp();
        this->terminate();
}

bool App::isSessionValid(const std::string& sid)
{
        sessionlist_t::iterator s=sessions.find(sid);
        return s!=sessions.end()&&s->second->validP();
}


void App::addInitParam(const std::string& name, const std::string& value)
{
        m_params[name]=value;
}

std::string App::getServletContextName() const
{
        return name;
}

void App::log(const std::string& msg) const
{
        std::cerr<<msg<<std::endl;
}

void App::log(const std::string& message, const std::exception& e) const 
{
        log(message);
        std::cerr<<e.what()<<std::endl;
}


void App::SessionCleaner::wakeUp()
{
        char c='1';
        ::write(trigger[1],&c,1);
}


void App::killAllSessions()
{
        sessionLock.lock();
        sessionlist_t::iterator cur=sessions.begin();
        while(cur!=sessions.end()){
                delete cur->second;
                cur++;
        }
        sessions.clear();
        sessionLock.unlock();
}

std::string App::makeSName(const std::string& name)
{
        sptk::CBuffer in(name.c_str());
        sptk::CBuffer out(name.length()+5);
        sptk::CBase64::encode(out,in);
        std::string ret="CPPSERV";
        ret+=out.data();
        std::transform(ret.begin(),ret.end(),ret.begin(),container::util::TrEq());
        return ret;
}


servlet::ServletContext* App::getContext(const std::string& uripath)
{
        std::string uribase = getUriBase();
        if(uripath.find(uribase) != 0)
                return 0;
        std::string contextName = uripath.substr(uribase.length());
        return cfg.getApp(contextName);
}
int App::getMajorVersion()
{
        return VERSION_MAJOR;
}
int App::getMinorVersion()
{
        return VERSION_MINOR;
}
std::string App::getMimeType(const std::string& /*file*/)
{
        //FIXME: should we do something here? Talk to web server?
        //FIXME: Call file?
        return "";
}
std::auto_ptr< std::set<std::string> > App::getResourcePaths(const std::string& path)
{
        std::auto_ptr< std::set<std::string> > ret(new std::set<std::string>);
        // For now we can only return list of available Servlets
        // Which means our implementation is not really complete
        servletmap_t* sp = maptop.getPath(path, false);
        if(!sp)
                return ret;
        std::insert_iterator<std::set<std::string> > ii(*ret, ret->begin());
        std::transform(sp->getSubpaths().begin(), sp->getSubpaths().end(), ii, __gnu_cxx::select1st<std::pair<std::string, ServletMap<ServletDesc>*> >());
        std::transform(sp->getServlets().begin(), sp->getServlets().end(), ii, __gnu_cxx::select1st<std::pair<std::string, ServletDesc*> >());
        return ret;
}
std::string App::getResource(const std::string& /*path*/)
{
        //throw servlet::ServletException("Method unimplemented");
        return "";
}
std::istream& App::getResourceAsStream(const std::string& /*path*/)
{
        throw servlet::ServletException("Method unimplemented");
}
servlet::RequestDispatcher* App::getRequestDispatcher(const std::string& path)
{
        if(path[0]!='/')
                throw servlet::IllegalArgumentException();
        std::string name(path.substr(1));
        return getServletContainer(name);
}
servlet::RequestDispatcher* App::getNamedDispatcher(const std::string& name)
{
        return getServletContainer(name);
}
std::string App::getRealPath(const std::string& /*path*/)
{
        return "";
}
std::string App::getServerInfo()
{
        return "CPPSERV/" CPPSERV_VERSION;
}
std::string App::getInitParameter(const std::string& name)
{
        param_t::const_iterator iRet = m_params.find(name);
        if(iRet == m_params.end())
            return "";
        else
            return iRet->second;
}
std::auto_ptr< std::vector<std::string> > App::getInitParameterNames()
{
        return util::getMapKeyNames(m_params);
}
boost::shared_ptr<void> App::getAttribute(const std::string& name)
{
        attr_t::const_iterator iRet = m_attrs.find(name);
        if(iRet == m_attrs.end())
            return boost::shared_ptr<void>();
        else
            return iRet->second;
}
std::auto_ptr< std::vector<std::string> > App::getAttributeNames()
{
        return util::getMapKeyNames(m_attrs);
}
void App::setAttribute(const std::string& name, boost::shared_ptr<void> object)
{
        m_attrs[name] = object;
}
void App::removeAttribute(const std::string& name)
{
        attr_t::iterator it=m_attrs.find(name);
        if(it!=m_attrs.end())
            m_attrs.erase(it);
}
bool App::hasAttribute(const std::string& name) const
{
        attr_t::const_iterator it=m_attrs.find(name);
        return it!=m_attrs.end();
}

}

[Home] [Site Map] [Services] [Open Source / Projects] [About the Company] [Help] [Contact] [Portfolio]

Authoright © Total Knowledge: 2001-2004