JSONRPCBackend.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_JSONRPCBACKEND_H_
#define _MIRA_JSONRPCBACKEND_H_

#ifndef Q_MOC_RUN
#include <boost/thread/future.hpp>
#include <boost/algorithm/string.hpp>
#endif

#include <serialization/JSONSerializer.h>
#include <rpc/RPCError.h>
#include <rpc/JSONRPCResponse.h>
#include <utils/ToString.h>

#include <thread/Atomic.h>

namespace mira {



template <typename R>
inline bool jsonRPChasExceptionHelper(boost::promise<R>& promise, json::Value& value)
{
    auto it = value.get_obj().find("error");
    if(it!=value.get_obj().end()) {
        auto& obj = it->second;
        auto messageit = obj.get_obj().find("message");
        if(messageit==obj.get_obj().end()) {
            promise.set_exception(boost::copy_exception(
                XRPC("RPC client response has invalid error format: message missing")));
            return true;
        }

        XRPC ex(messageit->second.get_str());

        auto stackit = obj.get_obj().find("callstack");
        if(stackit==obj.get_obj().end()) {
            promise.set_exception(boost::copy_exception(ex));
            return true;
        }

        auto threadit = obj.get_obj().find("thread");
        if(threadit==obj.get_obj().end()) {
            ex.addInfo("RPC client response has invalid error format: callstack without thread id");
        }

        CallStack stack;
        ThreadID thread;

        try {
            JSONDeserializer js(stackit->second);
            js.deserialize(stack);
        }
        catch(XIO&) {
            ex.addInfo("RPC client response has invalid error format: callstack unreadable");
            // do not expect remaining entries to be readable
            promise.set_exception(boost::copy_exception(ex));
            return true;
        }

        if(threadit!=obj.get_obj().end()) {
            try {
                thread = threadit->second.get_uint64();
            }
            catch(std::runtime_error&) {
                ex.addInfo("RPC client response has invalid error format: thread id unreadable");
            }
        }

        // at least the stack was read, thread might be uninitialized, but the exception informs about it
        ex.addExternalStackInfo<XRPC>(stack, thread);

        // try to deserialize and add the original exception
        auto excit = obj.get_obj().find("exception");
        if(excit!=obj.get_obj().end()) {
            try {
                SerializableException* origEx;
                JSONDeserializer js(excit->second);
                js.deserialize(origEx);
                ex.setOrigException(origEx);
            }
            catch(...) {} // ignore errors, it could e.g. be an unknown exception type
        }

        promise.set_exception(boost::copy_exception(ex));
        return true;
    }

    it = value.get_obj().find("result");
    if(it==value.get_obj().end()) {
        promise.set_exception(boost::copy_exception(
            XRPC("RPC client response has invalid result format")));
        return true;
    }
    return false;
}

template <typename R>
inline void jsonRPCreturnHelper(boost::promise<R>& promise, json::Value& value)
{
    if (jsonRPChasExceptionHelper(promise, value))
        return;
    auto it = value.get_obj().find("result");
    R ret;
    JSONDeserializer d(it->second);
    d.deserialize(ret);
    promise.set_value(std::move(ret));
}

template <>
inline void jsonRPCreturnHelper(boost::promise<JSONRPCResponse>& promise, json::Value& value)
{
    promise.set_value(JSONRPCResponse(value));
}

template <>
inline void jsonRPCreturnHelper(boost::promise<void>& promise, json::Value& value)
{
    if (jsonRPChasExceptionHelper(promise, value))
        return;
    promise.set_value();
}


class JSONRPCBackend
{
public:

    enum ErrorCode
    {
        ParseError = -32700,
        InvalidRequest = -32600,
        MethodNotFound = -32601,
        InvalidParams = -32602,
        InternalError = -32603,
        ServerError = -32099,
    };

    typedef json::Value ContainerType;

    class ClientResponse
    {
    public:

        ClientResponse(json::Value* value) :
            mValue(value) {}

        void getHeader(std::string& oCallId) const
        {
            auto it = mValue->get_obj().find("id");
            if(it== mValue->get_obj().end())
                MIRA_THROW(XRPC, "Server response is missing an 'id'. Response = " 
                           << json::write(*mValue));
            oCallId = json::write(it->second);
        }

        template<typename R>
        void getReturn(boost::promise<R>& promise) const
        {
            jsonRPCreturnHelper(promise, *mValue);
        }

    private:
        json::Value* mValue;
    };

    class ClientRequest
    {
    public:

        ClientRequest(json::Value* value) :
            mValue(value),
            mParams(NULL)
        {
            *mValue = json::Object();
            mValue->get_obj()["jsonrpc"] = json::Value("2.0");
        }

        std::string generateCallID() {
            static uint32 sID = 0;
            json::Value v(std::string("JSONCR") + toString(atomic::inc(&sID)));
            return json::write(v, false);
        }

        void setHeader(const std::string& callId, const std::string& service,
                       const RPCSignature& signature)
        {
            std::string method = service + "." + signature.name;
            mValue->get_obj()["method"] = json::Value(method);
            json::Value id;
            json::read(callId, id);
            mValue->get_obj()["id"] = id;
        }

        template <typename P>
        void setParameter(const P& param)
        {
            // if no params inserted yet do so
            if (mParams == NULL)
            {
                mValue->get_obj()["params"] = json::Array();
                mParams = &mValue->get_obj()["params"];
            }
            mParams->get_array().push_back(mOut.serialize(param));
        }

    private:
        json::Value* mValue;
        json::Value* mParams;
        JSONSerializer mOut;
    };

    class ServerResponse
    {
    public:

        ServerResponse(json::Value* value) :
            mValue(value)
        {
            *mValue = json::Object();
            mValue->get_obj()["jsonrpc"] = json::Value("2.0");
        }

        void setHeader(const std::string& callId)
        {
            json::Value id;
            json::read(callId, id);
            mValue->get_obj()["id"] = id;
        }

        void returnException(RPCError reason, const std::string& message)
        {
            json::Object o;
            ErrorCode code;
            switch (reason)
            {
                case RPC_INVALID_REQUEST : code = InvalidRequest; break;
                case RPC_METHOD_NOT_FOUND : code = MethodNotFound; break;
                case RPC_INVALID_PARAMS : code = InvalidParams; break;
                case RPC_EXCEPTION_IN_CALL : code = InternalError; break;
                default : code = ServerError; break;
            }
            o["code"] = json::Value(code);
            o["message"] = json::Value(message);
            mValue->get_obj()["error"] = o;
        }

        void returnException(RPCError reason, const std::string& message,
                             const CallStack& callstack)
        {
            json::Object o;
            ErrorCode code;
            switch (reason)
            {
                case RPC_INVALID_REQUEST : code = InvalidRequest; break;
                case RPC_METHOD_NOT_FOUND : code = MethodNotFound; break;
                case RPC_INVALID_PARAMS : code = InvalidParams; break;
                case RPC_EXCEPTION_IN_CALL : code = InternalError; break;
                default : code = ServerError; break;
            }
            o["code"] = json::Value(code);
            o["message"] = json::Value(message);
            o["callstack"] = mOut.serialize(callstack);
            o["thread"] = json::Value((boost::uint64_t)getCurrentThreadID());
            mValue->get_obj()["error"] = o;
        }

        void returnException(RPCError reason, SerializableException& ex)
        {
            json::Object o;
            ErrorCode code;
            switch (reason)
            {
                case RPC_INVALID_REQUEST : code = InvalidRequest; break;
                case RPC_METHOD_NOT_FOUND : code = MethodNotFound; break;
                case RPC_INVALID_PARAMS : code = InvalidParams; break;
                case RPC_EXCEPTION_IN_CALL : code = InternalError; break;
                default : code = ServerError; break;
            }
            o["code"] = json::Value(code);
            o["message"] = json::Value(ex.what());
            o["callstack"] = mOut.serialize(ex.callStack());
            o["thread"] = json::Value((boost::uint64_t)getCurrentThreadID());
            o["exception"] = mOut.serialize(&ex);
            mValue->get_obj()["error"] = o;
        }

        template<typename R>
        void returnResult(const R& res)
        {
            mValue->get_obj()["result"] = mOut.serialize(res);
        }

        void returnVoid()
        {
            mValue->get_obj()["result"] = json::Value();
        }

    private:
        json::Value* mValue;
        JSONSerializer mOut;
    };

    class ServerRequest
    {
    public:

        ServerRequest(const json::Value* value) :
            mValue(value),
            mParams(NULL),
            mIndex(0)
        {}

    public:
        static std::string getCallId(const json::Value* request)
        {
            auto it = request->get_obj().find("id");
            if(it==request->get_obj().end())
                MIRA_THROW(XRPC,"The JSON request is missing an 'id'. Request = "
                           << json::write(*request));
            return json::write(it->second);
        }

        static void getServiceMethod(const json::Value* request, std::string& oService, std::string& oMethod)
        {
            auto it = request->get_obj().find("method");
            if(it==request->get_obj().end())
                MIRA_THROW(XRPC,"The JSON request is missing a 'method'. Request = "
                           << json::write(*request));

            std::string method = it->second.get_str();
            if(method.empty())
                MIRA_THROW(XRPC,"The JSON request has an empty 'method'. Request = "
                           << json::write(*request));

            std::vector<std::string> strs;
            boost::split(strs, method, boost::is_from_range('.','.'));
            oService = *strs.begin();
            oMethod = *strs.rbegin();
        }

        void getHeader(std::string& oCallId, std::string& oService)
        {
            oCallId = getCallId(mValue);
            getServiceMethod(mValue, oService, mSignature.name);

            auto it = mValue->get_obj().find("params");
            // method has no parameters
            if(it==mValue->get_obj().end())
                return;
            mParams = &it->second;

            for(std::size_t i=0;i<mParams->get_array().size(); ++i)
            {
                const json::Value& v = mParams->get_array()[i];
                std::string type;

                switch(v.type()) {
                case json_spirit::obj_type:   type="object"; break;
                case json_spirit::array_type: type="array"; break;
                case json_spirit::str_type:   type="string"; break;
                case json_spirit::bool_type:  type="bool"; break;
                case json_spirit::int_type:   type="int"; break;
                case json_spirit::real_type:  type="float"; break;
                default: break;
                }

                mSignature.parameterTypes.push_back(type);
            }
        }

        bool checkSignature(const RPCSignature& signature)
        {
            return signature.name == mSignature.name &&
                   signature.parameterTypes.size() == mSignature.parameterTypes.size();
        }

        const RPCSignature& getSignature()
        {
            return mSignature;
        }

        template <typename P>
        void getParameter(P& oParam)
        {
            try
            {
                if (mParams != NULL)
                {
                    assert(mIndex < (uint32)mParams->get_array().size());
                    const json::Value& v = mParams->get_array()[mIndex++];
                    JSONDeserializer d(v);
                    // no need to do type check here, since it is done by JSONDeserializer
                    d.deserialize(oParam);
                }
            }
            catch(std::exception& ex)
            {
                MIRA_THROW(XRPC,"Parameter must be a valid object of type '" << typeName<P>()
                             << "'. " << ex.what());
            }
            catch(...)
            {
                MIRA_THROW(XRPC,"Parameter must be a valid object of type '" << typeName<P>() << "'");
            }
        }

    private:
        const json::Value* mValue;
        const json::Value* mParams;
        uint32 mIndex;
        RPCSignature mSignature;
    };

};

} // namespace

#endif