RetroShare/libresapi/src/api/ApiServer.h

104 lines
3.6 KiB
C
Raw Normal View History

#pragma once
#include <retroshare/rsplugin.h>
#include "ApiTypes.h"
#include "PeersHandler.h"
#include "IdentityHandler.h"
#include "ServiceControlHandler.h"
#include "StateTokenServer.h"
#include "FileSearchHandler.h"
#include "TransfersHandler.h"
namespace resource_api{
class ApiServerMainModules;
// main entry point for all resource_api calls
// general part of the api server
// should work with any http library or a different transport protocol (e.g. SSH)
// call chain is like this:
// HTTP server -> ApiServer -> different handlers
// or
// GUI -> ApiServer -> different handlers
// multiple clients can use the same ApiServer instance at the same time
// ALL public methods in this class are thread safe
// this allows differen threads to send requests
class ApiServer
{
public:
ApiServer();
~ApiServer();
class RequestId{
public:
RequestId(): done(false), task(0), request(0), response(0){}
bool operator ==(const RequestId& r){
const RequestId& l = *this;
return (l.done==r.done)&&(l.task==r.task)&&(l.request==r.request)&&(l.response&&r.response);
}
private:
friend class ApiServer;
bool done; // this flag will be set to true, to signal the task id is valid and the task is done
// (in case there was no ResponseTask and task was zero)
ResponseTask* task; // null when the task id is invalid or when there was no task
Request* request;
Response* response;
};
// process the requestgiven by request and return the response as json string
// blocks until the request was processed
std::string handleRequest(Request& request);
// request and response must stay valid until isRequestDone returns true
// this method may do some work but it does not block
RequestId handleRequest(Request& request, Response& response);
// ticks the request
// returns true if the request is done or the id is invalid
// this method may do some work but it does not block
bool isRequestDone(RequestId id);
// load the main api modules
void loadMainModules(const RsPlugInInterfaces& ifaces);
// allows to add more handlers
// make sure the livetime of the handlers is longer than the api server
template <class T>
void addResourceHandler(std::string name, T* instance, ResponseTask* (T::*callback)(Request& req, Response& resp));
template <class T>
void addResourceHandler(std::string name, T* instance, void (T::*callback)(Request& req, Response& resp));
StateTokenServer* getStateTokenServer(){ return &mStateTokenServer; }
private:
RsMutex mMtx;
StateTokenServer mStateTokenServer; // goes first, as others may depend on it
// is always loaded, because it has no dependencies
// only pointers here, to load/unload modules at runtime
ApiServerMainModules* mMainModules; // loaded when RS is started
ResourceRouter mRouter;
std::vector<RequestId> mRequests;
};
// implementations
template <class T>
void ApiServer::addResourceHandler(std::string name, T* instance, ResponseTask* (T::*callback)(Request& req, Response& resp))
{
RS_STACK_MUTEX(mMtx); // ********** LOCKED **********
mRouter.addResourceHandler(name, instance, callback);
}
template <class T>
void ApiServer::addResourceHandler(std::string name, T* instance, void (T::*callback)(Request& req, Response& resp))
{
RS_STACK_MUTEX(mMtx); // ********** LOCKED **********
mRouter.addResourceHandler(name, instance, callback);
}
}