llsdrpcclient.h

Go to the documentation of this file.

#ifndef LL_LLSDRPCCLIENT_H
#define LL_LLSDRPCCLIENT_H

#include "llchainio.h"
#include "llfiltersd2xmlrpc.h"
#include "lliopipe.h"
#include "llurlrequest.h"

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

        bool extractResponse(const LLSD& sd);

protected:
        virtual bool response(LLPumpIO* pump) = 0;

        virtual bool fault(LLPumpIO* pump) = 0;

        virtual bool error(LLPumpIO* pump) = 0;

protected:
        /* @name LLIOPipe virtual implementations
         */

        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);
        
protected:
        LLSD mReturnValue;
        bool mIsError;
        bool mIsFault;
};

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

        enum EPassBackQueue
        {
                EPBQ_PROCESS,
                EPBQ_CALLBACK,
        };

        bool call(
                const std::string& uri,
                const std::string& method,
                const LLSD& parameter,
                LLSDRPCResponse* response,
                EPassBackQueue queue);

        bool call(
                const std::string& uri,
                const std::string& method,
                const std::string& parameter,
                LLSDRPCResponse* response,
                EPassBackQueue queue);

protected:
        enum EState
        {
                STATE_NONE,
                STATE_READY,
                STATE_WAITING_FOR_RESPONSE,
                STATE_DONE
        };
        
        /* @name LLIOPipe virtual implementations
         */

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

protected:
        EState mState;
        std::string mURI;
        std::string mRequest;
        EPassBackQueue mQueue;
        LLIOPipe::ptr_t mResponse;
};

template<class Client>
class LLSDRPCClientFactory : public LLChainIOFactory
{
public:
        LLSDRPCClientFactory() {}
        LLSDRPCClientFactory(const std::string& fixed_url) : mURL(fixed_url) {}
        virtual bool build(LLPumpIO::chain_t& chain, LLSD context) const
        {
                lldebugs << "LLSDRPCClientFactory::build" << llendl;
                LLIOPipe::ptr_t service(new Client);
                chain.push_back(service);
                LLURLRequest* http(new LLURLRequest(LLURLRequest::HTTP_POST));
                LLIOPipe::ptr_t http_pipe(http);
                http->addHeader("Content-Type: text/llsd");
                if(mURL.empty())
                {
                        chain.push_back(LLIOPipe::ptr_t(new LLContextURLExtractor(http)));
                }
                else
                {
                        http->setURL(mURL);
                }
                chain.push_back(http_pipe);
                chain.push_back(service);
                return true;
        }
protected:
        std::string mURL;
};

template<class Client>
class LLXMLSDRPCClientFactory : public LLChainIOFactory
{
public:
        LLXMLSDRPCClientFactory() {}
        LLXMLSDRPCClientFactory(const std::string& fixed_url) : mURL(fixed_url) {}
        virtual bool build(LLPumpIO::chain_t& chain, LLSD context) const
        {
                lldebugs << "LLXMLSDRPCClientFactory::build" << llendl;
                LLIOPipe::ptr_t service(new Client);
                chain.push_back(service);
                LLURLRequest* http(new LLURLRequest(LLURLRequest::HTTP_POST));
                LLIOPipe::ptr_t http_pipe(http);
                http->addHeader("Content-Type: text/xml");
                if(mURL.empty())
                {
                        chain.push_back(LLIOPipe::ptr_t(new LLContextURLExtractor(http)));
                }
                else
                {
                        http->setURL(mURL);
                }
                chain.push_back(LLIOPipe::ptr_t(new LLFilterSD2XMLRPCRequest(NULL)));
                chain.push_back(http_pipe);
                chain.push_back(LLIOPipe::ptr_t(new LLFilterXMLRPCResponse2LLSD));
                chain.push_back(service);
                return true;
        }
protected:
        std::string mURL;
};

#endif // LL_LLSDRPCCLIENT_H

---