Updated hipporestrequest code to hippo 0.6.3

3 files changed, 394 insertions, 7 deletions

diff --git a/linden/indra/newview/hippoGridManager.cpp b/linden/indra/newview/hippoGridManager.cpp
index 0160233..e89e3ff 100644
--- a/linden/indra/newview/hippoGridManager.cpp
+++ b/linden/indra/newview/hippoGridManager.cpp
@@ -160,7 +160,10 @@ const std::string& HippoGridInfo::getRealCurrencySymbol() const
 void HippoGridInfo::setPlatform(Platform platform)
 {
         mPlatform = platform;
-        mCurrencySymbol = (mPlatform == PLATFORM_SECONDLIFE)? "L$": "OS$";
+        if (mPlatform == PLATFORM_SECONDLIFE)
+        {
+                mCurrencySymbol = "L$";
+        }
 }
 
 
diff --git a/linden/indra/newview/hippoRestRequest.cpp b/linden/indra/newview/hippoRestRequest.cpp
index 20e6187..ed15907 100644
--- a/linden/indra/newview/hippoRestRequest.cpp
+++ b/linden/indra/newview/hippoRestRequest.cpp
@@ -10,7 +10,303 @@
 #include <curl/curl.h>
 
 #include <stdtypes.h>
+#include <llbufferstream.h>
 #include <llerror.h>
+#include <llhttpclient.h>
+#include <llurlrequest.h>
+#include <llxmltree.h>
+
+
+// ********************************************************************
+ 
+ 
+class HippoRestComplete : public LLURLRequestComplete
+{
+        public:
+                HippoRestComplete(HippoRestHandler *handler) :
+                        mHandler(handler),
+                        mStatus(499),
+                        mReason("Request completed w/o status")
+                {
+                }
+ 
+                ~HippoRestComplete()
+                {
+                        delete mHandler;
+                }
+ 
+                // Called once for each header received, prior to httpStatus
+                void header(const std::string& header, const std::string& value)
+                {
+                        mHandler->addHeader(header, value);
+                }
+
+                // Always called on request completion, prior to complete
+                void httpStatus(U32 status, const std::string& reason)
+                {
+                        LLURLRequestComplete::httpStatus(status, reason);
+                        mStatus = status;
+                        mReason = reason;
+                }
+
+                void complete(const LLChannelDescriptors &channels, const buffer_ptr_t &buffer)
+                {
+                        mHandler->handle(mStatus, mReason, channels, buffer);
+                }
+
+        private:
+                HippoRestHandler *mHandler;
+                int mStatus;
+                std::string mReason;
+};
+
+
+// ********************************************************************
+
+
+static std::string gEmptyString;
+
+void HippoRestHandler::addHeader(const std::string &header, const std::string &content)
+{
+        mHeaders[header] = content;
+}
+
+bool HippoRestHandler::hasHeader(const std::string &header) const
+{
+        return (mHeaders.find(header) != mHeaders.end());
+}
+
+const std::string &HippoRestHandler::getHeader(const std::string &header) const
+{
+        std::map<std::string, std::string>::const_iterator it;
+        it = mHeaders.find(header);
+        if (it != mHeaders.end()) {
+                return it->second;
+        } else {
+                return gEmptyString;
+        }
+}
+
+
+// ********************************************************************
+
+
+void HippoRestHandlerRaw::handle(int status, const std::string &reason,
+                                                                 const LLChannelDescriptors &channels,
+                                                                 const boost::shared_ptr<LLBufferArray> &body)
+{
+        if (status == 200) {
+                std::string data;
+                LLBufferArray *buffer = body.get();
+                LLBufferArray::segment_iterator_t it, end = buffer->endSegment();
+                for (it=buffer->beginSegment(); it!=end; ++it)
+                        if (it->isOnChannel(channels.in()))
+                                data.append((char*)it->data(), it->size());
+                result(data);
+        } else {
+                llwarns << "Rest request error " << status << ": " << reason << llendl;
+        }
+}
+
+void HippoRestHandlerXml::handle(int status, const std::string &reason,
+                                                                 const LLChannelDescriptors &channels,
+                                                                 const boost::shared_ptr<LLBufferArray> &body)
+{
+        if (status == 200) {
+                LLXmlTree *tree = new LLXmlTree();
+                bool success = tree->parseBufferStart();
+                LLBufferArray *buffer = body.get();
+                LLBufferArray::segment_iterator_t it, end = buffer->endSegment();
+                for (it=buffer->beginSegment(); success && (it!=end); ++it)
+                        if (it->isOnChannel(channels.in()))
+                                success = success && tree->parseBuffer((char*)it->data(), it->size());
+                success = success && tree->parseBufferFinalize();
+                if (success) result(tree);
+                delete tree;
+        } else {
+                llwarns << "Rest request error " << status << ": " << reason << llendl;
+        }
+}
+
+
+// ********************************************************************
+
+
+class BodyData : public LLIOPipe
+{
+        public:
+                virtual ~BodyData() { }
+                virtual const char *getContentMimeType() const = 0;
+};
+
+class BodyDataRaw : public BodyData
+{
+        public:
+                explicit BodyDataRaw(const std::string &data) :
+                        mData(data)
+                {
+                }
+                virtual ~BodyDataRaw() { }
+ 
+                const char *getContentMimeType() const { return "application/octet-stream"; }
+ 
+                EStatus process_impl(const LLChannelDescriptors &channels,
+                                                         buffer_ptr_t &buffer, bool &eos,
+                                                         LLSD &context, LLPumpIO *pump)
+                {
+                        LLBufferStream ostream(channels, buffer.get());
+                        ostream.write(mData.data(), mData.size());
+                        eos = true;
+                        return STATUS_DONE;
+                }
+
+        private:
+                std::string mData;
+};
+
+class BodyDataXml : public BodyData
+{
+        public:
+                explicit BodyDataXml(const LLXmlTree *tree) :
+                        mTree(tree)
+                {
+                }
+
+                virtual ~BodyDataXml()
+                {
+                        if (mTree) delete mTree;
+                }
+
+                const char *getContentMimeType() const { return "application/xml"; }
+
+                EStatus process_impl(const LLChannelDescriptors &channels,
+                                                         buffer_ptr_t &buffer, bool &eos,
+                                                         LLSD &context, LLPumpIO *pump)
+                {
+                        std::string data;
+                        mTree->write(data);
+                        LLBufferStream ostream(channels, buffer.get());
+                        ostream.write(data.data(), data.size());
+                        eos = true;
+                        return STATUS_DONE;
+                }
+
+        private:
+                const LLXmlTree *mTree;
+};
+
+
+// ********************************************************************
+
+
+static void request(const std::string &url,
+                                        LLURLRequest::ERequestAction method,
+                                        BodyData *body,
+                                        HippoRestHandler *handler, float timeout);
+
+
+// static
+void HippoRestRequest::get(const std::string &url,
+                                                   HippoRestHandler *handler, float timeout)
+{
+        request(url, LLURLRequest::HTTP_GET, 0, handler, timeout);
+}
+
+// static
+void HippoRestRequest::put(const std::string &url, const std::string &body,
+                                                   HippoRestHandler *handler, float timeout)
+{
+        request(url, LLURLRequest::HTTP_PUT, new BodyDataRaw(body), handler, timeout);
+}
+
+// static
+void HippoRestRequest::put(const std::string &url, const LLXmlTree *body,
+                                                   HippoRestHandler *handler, float timeout)
+{
+        request(url, LLURLRequest::HTTP_PUT, new BodyDataXml(body), handler, timeout);
+}
+
+// static
+void HippoRestRequest::post(const std::string &url, const std::string &body,
+                                                        HippoRestHandler *handler, float timeout)
+{
+        request(url, LLURLRequest::HTTP_POST, new BodyDataRaw(body), handler, timeout);
+}
+
+// static
+void HippoRestRequest::post(const std::string &url, const LLXmlTree *body,
+                                                        HippoRestHandler *handler, float timeout)
+{
+        request(url, LLURLRequest::HTTP_POST, new BodyDataXml(body), handler, timeout);
+}
+
+
+// ********************************************************************
+
+
+static void request(const std::string &url,
+                                        LLURLRequest::ERequestAction method,
+                                        BodyData *body,
+                                        HippoRestHandler *handler, float timeout)
+{
+        if (!LLHTTPClient::hasPump())
+        {
+                // !!! responder->completed(U32_MAX, "No pump", LLSD());
+                return;
+        }
+        LLPumpIO::chain_t chain;
+
+        LLURLRequest *req = new LLURLRequest(method, url);
+        req->checkRootCertificate(true);
+
+        /*
+        // Insert custom headers if the caller sent any
+        if (headers.isMap())
+        {
+                LLSD::map_const_iterator iter = headers.beginMap();
+                LLSD::map_const_iterator end  = headers.endMap();
+ 
+                for (; iter != end; ++iter)
+                {
+                        std::ostringstream header;
+                        //if the header is "Pragma" with no value
+                        //the caller intends to force libcurl to drop
+                        //the Pragma header it so gratuitously inserts
+                        //Before inserting the header, force libcurl
+                        //to not use the proxy (read: llurlrequest.cpp)
+                        static const std::string PRAGMA("Pragma");
+                        if ((iter->first == PRAGMA) && (iter->second.asString().empty()))
+                        {
+                                req->useProxy(false);
+                        }
+                        header << iter->first << ": " << iter->second.asString() ;
+                        lldebugs << "header = " << header.str() << llendl;
+                        req->addHeader(header.str().c_str());
+                }
+        }
+        */
+
+        if ((method != LLURLRequest::HTTP_PUT) && (method != LLURLRequest::HTTP_POST)) {
+                std::string accept = "Accept: ";
+                accept += handler->getAcceptMimeType();
+                req->addHeader(accept.c_str());
+        }
+
+        req->setCallback(new HippoRestComplete(handler));
+
+        if ((method == LLURLRequest::HTTP_PUT) || (method == LLURLRequest::HTTP_POST)) {
+                std::string content = "Content-Type: ";
+                content += body->getContentMimeType();
+                req->addHeader(content.c_str());
+                chain.push_back(LLIOPipe::ptr_t(body));
+        }
+
+        chain.push_back(LLIOPipe::ptr_t(req));
+        LLHTTPClient::getPump().addChain(chain, timeout);
+}
+
+
+// ********************************************************************
 
 
 static size_t curlWrite(void *ptr, size_t size, size_t nmemb, void *userData)
@@ -22,7 +318,7 @@ static size_t curlWrite(void *ptr, size_t size, size_t nmemb, void *userData)
 }
 
 
-//static
+// static
 int HippoRestRequest::getBlocking(const std::string &url, std::string *result)
 {
         llinfos << "Requesting: " << url << llendl;
diff --git a/linden/indra/newview/hippoRestRequest.h b/linden/indra/newview/hippoRestRequest.h
index 1dcb4a0..727dbf7 100644
--- a/linden/indra/newview/hippoRestRequest.h
+++ b/linden/indra/newview/hippoRestRequest.h
@@ -1,15 +1,103 @@
-#ifndef __HIPPO_REST_REQTUEST_H__
-#define __HIPPO_REST_REQTUEST_H__
+#ifndef __HIPPO_REST_REQUEST_H__
+#define __HIPPO_REST_REQUEST_H__
 
 
+#include <map>
 #include <string>
 
+#include <boost/shared_ptr.hpp>
+
+class LLBufferArray;
+class LLChannelDescriptors;
+class LLXmlTree;
+
+
+#define HIPPO_REST_TIMEOUT 60.f
+
+
+// ********************************************************************
+ 
+
+class HippoRestHandler
+{
+        public:
+                virtual ~HippoRestHandler() { }
+ 
+                virtual const char *getAcceptMimeType() const = 0;
+
+                bool hasHeader(const std::string &header) const;
+                const std::string &getHeader(const std::string &header) const;
+
+        private:
+                // These functions are called by the request engine
+                void addHeader(const std::string &header, const std::string &content);
+                virtual void handle(int status, const std::string &reason,
+                                                        const LLChannelDescriptors &channels,
+                                                        const boost::shared_ptr<LLBufferArray> &body) = 0;
+
+                std::map<std::string, std::string> mHeaders;
+                
+                friend class HippoRestComplete;
+};
+
+ 
+class HippoRestHandlerRaw : public HippoRestHandler
+{
+        public:
+                virtual ~HippoRestHandlerRaw() { }
+
+                const char *getAcceptMimeType() const { return "application/octet-stream"; }
+
+        private:
+                // This function must be implemented to receive the content
+                // it is executed on (status == 200) only
+                virtual void result(const std::string &content) = 0;
+
+                // This function is called by the request engine
+                void handle(int status, const std::string &reason,
+                                        const LLChannelDescriptors &channels,
+                                        const boost::shared_ptr<LLBufferArray> &body);
+};
+
+
+class HippoRestHandlerXml : public HippoRestHandler
+{
+        public:
+                virtual ~HippoRestHandlerXml() { }
+
+                const char *getAcceptMimeType() const { return "application/xml"; }
+                
+        private:
+                // This function must be implemented to receive the content
+                virtual void result(LLXmlTree *content) = 0;
+
+                // This function is called by the request engine
+                void handle(int status, const std::string &reason,
+                                        const LLChannelDescriptors &channels,
+                                        const boost::shared_ptr<LLBufferArray> &body);
+};
+
+
+// ********************************************************************
+
 
 class HippoRestRequest
 {
-  public:
-    static int getBlocking(const std::string &url, std::string *result);
-        
+        public:
+                // asynchronous interface
+                static void get(const std::string &url,
+                                                HippoRestHandler *handler, float timeout=HIPPO_REST_TIMEOUT);
+                static void put(const std::string &url, const std::string &body,
+                                                HippoRestHandler *handler, float timeout=HIPPO_REST_TIMEOUT);
+                static void put(const std::string &url, const LLXmlTree *body,
+                                                HippoRestHandler *handler, float timeout=HIPPO_REST_TIMEOUT);
+                static void post(const std::string &url, const std::string &body,
+                                                 HippoRestHandler *handler, float timeout=HIPPO_REST_TIMEOUT);
+                static void post(const std::string &url, const LLXmlTree *body,
+                                                 HippoRestHandler *handler, float timeout=HIPPO_REST_TIMEOUT);
+ 
+                // synchronous interface
+                static int getBlocking(const std::string &url, std::string *result);
 };