llsdrpcserver.h

Go to the documentation of this file.

#ifndef LL_LLSDRPCSERVER_H
#define LL_LLSDRPCSERVER_H

#include <map>
#include "lliopipe.h"
#include "lliohttpserver.h"
#include "llfiltersd2xmlrpc.h"

class LLSD;

enum ESDRPCSStatus
{
        // The call went ok, but the response is not yet ready. The
        // method will arrange for the clearLock() call to be made at
        // a later date, after which, once the chain is being pumped
        // again, deferredResponse() will be called to gather the result
        ESDRPCS_DEFERRED,

        // The LLSDRPCServer would like to handle the method on the
        // callback queue of the pump.
        ESDRPCS_CALLBACK,

        // The method call finished and generated output.
        ESDRPCS_DONE,

        // Method failed for some unspecified reason - you should avoid
        // this. A generic fault will be sent to the output.
        ESDRPCS_ERROR,

        ESDRPCS_COUNT,
};

class LLSDRPCMethodCallBase
{
public:
        LLSDRPCMethodCallBase() {}
        virtual ~LLSDRPCMethodCallBase() {}

        virtual ESDRPCSStatus call(
                const LLSD& params,
                const LLChannelDescriptors& channels,
                LLBufferArray* response) = 0;
protected:
};

template<class Server>
class LLSDRPCMethodCall : public LLSDRPCMethodCallBase
{
public:
        typedef ESDRPCSStatus (Server::*mem_fn)(
                const LLSD& params,
                const LLChannelDescriptors& channels,
                LLBufferArray* data);
        LLSDRPCMethodCall(Server* s, mem_fn fn) :
                mServer(s),
                mMemFn(fn)
        {
        }
        virtual ~LLSDRPCMethodCall() {}
        virtual ESDRPCSStatus call(
                const LLSD& params,
                const LLChannelDescriptors& channels,
                LLBufferArray* data)
        {
                return (*mServer.*mMemFn)(params, channels, data);
        }

protected:
        Server* mServer;
        mem_fn mMemFn;
        //bool (Server::*mMemFn)(const LLSD& params, LLBufferArray& data);
};


class LLSDRPCServer : public LLIOPipe
{
public:
        LLSDRPCServer();
        virtual ~LLSDRPCServer();

        enum
        {
                FAULT_BAD_REQUEST = 2000,
                FAULT_NO_RESPONSE = 2001,
        };

        static void buildFault(
                const LLChannelDescriptors& channels,
                LLBufferArray* data,
                S32 code,
                const std::string& msg);

        static void buildResponse(
                const LLChannelDescriptors& channels,
                LLBufferArray* data,
                const LLSD& response);

protected:
        /* @name LLIOPipe virtual implementations
         */

        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);

protected:

        enum EState
        {
                STATE_NONE,
                STATE_CALLBACK,
                STATE_DEFERRED,
                STATE_DONE
        };

        virtual ESDRPCSStatus callMethod(
                const std::string& method,
                const LLSD& params,
                const LLChannelDescriptors& channels,
                LLBufferArray* data);

        virtual ESDRPCSStatus callbackMethod(
                const std::string& method,
                const LLSD& params,
                const LLChannelDescriptors& channels,
                LLBufferArray* data);

        virtual ESDRPCSStatus deferredResponse(
                const LLChannelDescriptors& channels,
                LLBufferArray* data);

        // donovan put this public here 7/27/06
public:
        void clearLock();

protected:
        EState mState;
        LLSD mRequest;
        LLPumpIO* mPump;
        S32 mLock;
        typedef std::map<std::string, LLSDRPCMethodCallBase*> method_map_t;
        method_map_t mMethods;
        method_map_t mCallbackMethods;
};


template<class Server>
class LLSDRPCServerFactory : public LLChainIOFactory
{
public:
        virtual bool build(LLPumpIO::chain_t& chain, LLSD context) const
        {
                lldebugs << "LLXMLSDRPCServerFactory::build" << llendl;
                chain.push_back(LLIOPipe::ptr_t(new Server));
                return true;
        }
};

template<class Server>
class LLSDRPCNode : public LLHTTPNodeForFactory<
                                                                LLSDRPCServerFactory<Server> >
{
};

template<class Server>
class LLXMLRPCServerFactory : public LLChainIOFactory
{
public:
        virtual bool build(LLPumpIO::chain_t& chain, LLSD context) const
        {
                lldebugs << "LLXMLSDRPCServerFactory::build" << llendl;
                chain.push_back(LLIOPipe::ptr_t(new LLFilterXMLRPCRequest2LLSD));
                chain.push_back(LLIOPipe::ptr_t(new Server));
                chain.push_back(LLIOPipe::ptr_t(new LLFilterSD2XMLRPCResponse));
                return true;
        }
};

template<class Server>
class LLXMLRPCNode : public LLHTTPNodeForFactory<
                                                                LLXMLRPCServerFactory<Server> >
{
};


#endif // LL_LLSDRPCSERVER_H

---