Skip to content

ipgallery.common.cpp / Microservice

Go to a project
Commit f95791c1 by amir
Options

Change HttpMongooseImpl to work with the reactor

parent da0c3d01
Inline Side-by-side
Showing with 286 additions and 50 deletions
src/Microservice_App.cpp
...@@ -42,7 +42,7 @@ Microservice_App::Microservice_App(const char* appName) { ...@@ -42,7 +42,7 @@ Microservice_App::Microservice_App(const char* appName) {
mpc_PubSubClient = nullptr; mpc_PubSubClient = nullptr;
mpc_ServiceDiscovery = nullptr; mpc_ServiceDiscovery = nullptr;
enableMetrics = false; enableMetrics = false;
metricsFactory_ = nullptr; p_metricsFactory_ = nullptr;
mc_AppName.assign(appName); mc_AppName.assign(appName);
sp_instance = this; sp_instance = this;
} }
...@@ -272,8 +272,9 @@ Microservice_App& Microservice_App::build() { ...@@ -272,8 +272,9 @@ Microservice_App& Microservice_App::build() {
if(enableMetrics) if(enableMetrics)
{ {
metricsFactory_ = new MSIMetricsFactoryDropwisardImpl(this->mc_AppName); p_metricsFactory_ = new MSIMetricsFactoryDropwisardImpl(this->mc_AppName);
metricsFactory_->startReporting(); p_metricsFactory_->startReporting();
reactor_.withMetrics(p_metricsFactory_);
} }
mpc_Configuration->Reload(); mpc_Configuration->Reload();
/* /*
...@@ -311,7 +312,7 @@ Microservice_App& Microservice_App::build() { ...@@ -311,7 +312,7 @@ Microservice_App& Microservice_App::build() {
// specific // specific
IRestServer* p_restServer = dynamic_cast<IRestServer*>(p_server); IRestServer* p_restServer = dynamic_cast<IRestServer*>(p_server);
if (p_restServer) { if (p_restServer) {
p_restServer->build(this->mc_AppName,reactor_.HandlersMap(),mpc_Logger,mpc_PubSubClient,metricsFactory_); p_restServer->build(this->mc_AppName,reactor_.HandlersMap(),mpc_Logger,mpc_PubSubClient,p_metricsFactory_);
} }
p_server->init(); p_server->init();
} }
......
src/Microservice_App.h
...@@ -56,7 +56,7 @@ private: ...@@ -56,7 +56,7 @@ private:
IPubSub* mpc_PubSubClient; IPubSub* mpc_PubSubClient;
IConfiguration* mpc_Configuration; IConfiguration* mpc_Configuration;
cMicroservice_MonitorHandler* mpc_MonitorHandler; cMicroservice_MonitorHandler* mpc_MonitorHandler;
IMetricsFactory* metricsFactory_; IMetricsFactory* p_metricsFactory_;
// servers // servers
// cMicroservice_RestServer* mpc_RestServer; // cMicroservice_RestServer* mpc_RestServer;
// cMicroservice_RMQServer* mpc_RMQServer; // cMicroservice_RMQServer* mpc_RMQServer;
...@@ -154,7 +154,7 @@ public: ...@@ -154,7 +154,7 @@ public:
return mc_ClientMap[ms_name]; return mc_ClientMap[ms_name];
} }
std::map<std::string, cMicroservice_Client*>& GetClientMap() { return mc_ClientMap; } std::map<std::string, cMicroservice_Client*>& GetClientMap() { return mc_ClientMap; }
IMetricsFactory* GetMetricsFactory() const { return metricsFactory_; } IMetricsFactory* GetMetricsFactory() const { return p_metricsFactory_; }
}; };
......
src/Microservice_Client.cpp
...@@ -119,6 +119,7 @@ MSRetStat cMicroservice_Client::Unsubscribe(std::string &topic) { ...@@ -119,6 +119,7 @@ MSRetStat cMicroservice_Client::Unsubscribe(std::string &topic) {
} }
void cMicroservice_Client::GetMetrics(std::map<std::string, long>& metrics_map) { void cMicroservice_Client::GetMetrics(std::map<std::string, long>& metrics_map) {
if (p_commandClient_)
p_commandClient_->GetMetrics(metrics_map); p_commandClient_->GetMetrics(metrics_map);
} }
......
src/common/Microservice_Defines.h
...@@ -13,6 +13,7 @@ ...@@ -13,6 +13,7 @@
#endif #endif
#include <array> #include <array>
#include <map>
/* /*
* constants * constants
*/ */
...@@ -94,6 +95,13 @@ static char gbaa_Microservice_MethodNames[cMicroservice_Enums::eMaxMethods][nsMi ...@@ -94,6 +95,13 @@ static char gbaa_Microservice_MethodNames[cMicroservice_Enums::eMaxMethods][nsMi
"DELETE" "DELETE"
}; };
static std::map<std::string,cMicroservice_Enums::eCrudMethod> _microservice_RestCrudMap =
{
{"GET", cMicroservice_Enums::eCrudMethod::eRead},
{"POST", cMicroservice_Enums::eCrudMethod::eCreate},
{"PUT", cMicroservice_Enums::eCrudMethod::eUpdate},
{"DELETE", cMicroservice_Enums::eCrudMethod::eDelete},
};
static std::array<std::string,cMicroservice_Enums::eTrace+1> _microservice_LogLevels = static std::array<std::string,cMicroservice_Enums::eTrace+1> _microservice_LogLevels =
{ {
......
src/common/Microservice_Iface.h
...@@ -195,6 +195,7 @@ namespace nsMicroservice_Iface ...@@ -195,6 +195,7 @@ namespace nsMicroservice_Iface
virtual ITimer* createTimer(std::string& name) = 0; virtual ITimer* createTimer(std::string& name) = 0;
virtual IHistogram* createHistogram(std::string& name) = 0; virtual IHistogram* createHistogram(std::string& name) = 0;
virtual void GetMetrics(std::map<std::string,long>& metrics_map) = 0; virtual void GetMetrics(std::map<std::string,long>& metrics_map) = 0;
virtual void meterMark(std::string& name) = 0;
}; };
......
src/common/Microservice_RequestContext.h
...@@ -37,16 +37,16 @@ public: ...@@ -37,16 +37,16 @@ public:
nsMicroservice_Iface::IContainer* mpti_Container; nsMicroservice_Iface::IContainer* mpti_Container;
nsMicroservice_Iface::IResponse* mpti_Response; nsMicroservice_Iface::IResponse* mpti_Response;
nsMicroservice_Iface::IRequest* mpti_Request; nsMicroservice_Iface::IRequest* mpti_Request;
JsonStringWriter* mpc_Writer; //JsonStringWriter* mpc_Writer;
cMicroservice_RequestContext( nsMicroservice_Iface::IContainer* pti_Container, cMicroservice_RequestContext( nsMicroservice_Iface::IContainer* pti_Container,
JsonStringWriter* pc_Writer, //JsonStringWriter* pc_Writer,
nsMicroservice_Iface::IResponse* pti_Response, nsMicroservice_Iface::IResponse* pti_Response,
nsMicroservice_Iface::IRequest* pti_Request): nsMicroservice_Iface::IRequest* pti_Request):
mpti_Response(pti_Response),mpti_Request(pti_Request),crudMethod(cMicroservice_Enums::eCrudMethod::eMaxMethods) mpti_Response(pti_Response),mpti_Request(pti_Request),crudMethod(cMicroservice_Enums::eCrudMethod::eMaxMethods)
{ {
mpti_Container = pti_Container; mpti_Container = pti_Container;
mpc_Writer = pc_Writer; //mpc_Writer = pc_Writer;
if (mc_Params.capacity() < nsMicroservice_Constants::MAX_PARAMS) if (mc_Params.capacity() < nsMicroservice_Constants::MAX_PARAMS)
mc_Params.reserve(nsMicroservice_Constants::MAX_PARAMS); mc_Params.reserve(nsMicroservice_Constants::MAX_PARAMS);
} }
...@@ -68,7 +68,7 @@ public: ...@@ -68,7 +68,7 @@ public:
this->mpti_Container = requestContext.mpti_Container; this->mpti_Container = requestContext.mpti_Container;
this->mpti_Response = requestContext.mpti_Response; this->mpti_Response = requestContext.mpti_Response;
this->mpti_Request = requestContext.mpti_Request; this->mpti_Request = requestContext.mpti_Request;
this->mpc_Writer = requestContext.mpc_Writer; //this->mpc_Writer = requestContext.mpc_Writer;
} }
virtual uint32_t GetTypeHash() override { return TYPE_HASH; } virtual uint32_t GetTypeHash() override { return TYPE_HASH; }
......
src/handlers/Microservice_BaseHandler.h
...@@ -17,6 +17,7 @@ class cMicroservice_BaseHandler : public nsMicroservice_Iface::IHandler ...@@ -17,6 +17,7 @@ class cMicroservice_BaseHandler : public nsMicroservice_Iface::IHandler
{ {
protected: protected:
JsonStringWriter* mpc_Writer; JsonStringWriter* mpc_Writer;
public: public:
virtual ~cMicroservice_BaseHandler() { virtual ~cMicroservice_BaseHandler() {
// mpc_Configuration = nullptr; // mpc_Configuration = nullptr;
......
src/handlers/Microservice_MonitorHandler.cpp
...@@ -36,7 +36,7 @@ void cMicroservice_MonitorHandler::Init() { ...@@ -36,7 +36,7 @@ void cMicroservice_MonitorHandler::Init() {
void cMicroservice_MonitorHandler::DoCreate(cMicroservice_RequestContext* pc_reqCtx) { void cMicroservice_MonitorHandler::DoCreate(cMicroservice_RequestContext* pc_reqCtx) {
auto api_param = pc_reqCtx->mc_Params[0]; auto api_param = pc_reqCtx->mc_Params[0];
if (api_param.compare(LOG_LEVEL)) if (api_param.compare(LOG_LEVEL) == 0)
HandleSetLogLevel(pc_reqCtx); HandleSetLogLevel(pc_reqCtx);
} }
...@@ -55,7 +55,7 @@ void cMicroservice_MonitorHandler::DoRead(cMicroservice_RequestContext* pc_reqCt ...@@ -55,7 +55,7 @@ void cMicroservice_MonitorHandler::DoRead(cMicroservice_RequestContext* pc_reqCt
HandleReload(pc_reqCtx); HandleReload(pc_reqCtx);
else if (api_param.compare(STATS) == 0) else if (api_param.compare(STATS) == 0)
HandleStatistics(pc_reqCtx); HandleStatistics(pc_reqCtx);
else if (api_param.compare(LOG_LEVEL)) else if (api_param.compare(LOG_LEVEL) == 0)
HandleReadLogLevel(pc_reqCtx); HandleReadLogLevel(pc_reqCtx);
} }
......
src/handlers/Microservice_RMQHandler.cpp
...@@ -30,7 +30,7 @@ mpc_Handler(pc_Handler) ...@@ -30,7 +30,7 @@ mpc_Handler(pc_Handler)
mpc_Buffer = new rapidjson::StringBuffer(0,nsMicroservice_Constants::MAX_JSON_BUFFER); mpc_Buffer = new rapidjson::StringBuffer(0,nsMicroservice_Constants::MAX_JSON_BUFFER);
mpc_Writer = new JsonStringWriter(*mpc_Buffer); mpc_Writer = new JsonStringWriter(*mpc_Buffer);
mpc_RequestContext = new cMicroservice_RequestContext(this, mpc_RequestContext = new cMicroservice_RequestContext(this,
mpc_Writer, //mpc_Writer,
new cMicroservice_IResponseRMQImpl(), new cMicroservice_IResponseRMQImpl(),
new cMicroservice_IRequestRMQImpl()); new cMicroservice_IRequestRMQImpl());
this->apiContextPath = apiContextPath; this->apiContextPath = apiContextPath;
......
src/handlers/Microservice_Reactor.cpp
...@@ -9,6 +9,9 @@ MSRetStat Microservice_Reactor::Delegate(std::string& key, nsMicroservice_Iface: ...@@ -9,6 +9,9 @@ MSRetStat Microservice_Reactor::Delegate(std::string& key, nsMicroservice_Iface:
auto iter = handlersMap_.find(key); auto iter = handlersMap_.find(key);
if(iter != handlersMap_.end()) if(iter != handlersMap_.end())
{ {
if (p_metrics_factory_){
p_metrics_factory_->meterMark(key);
}
retStat = iter->second->Handle(p_Ctx); retStat = iter->second->Handle(p_Ctx);
} else{ } else{
retStat.SetError(std::string(nsMicroservice_Constants::FAILED_TO_FIND_HANDLER).append(key)); retStat.SetError(std::string(nsMicroservice_Constants::FAILED_TO_FIND_HANDLER).append(key));
...@@ -17,3 +20,7 @@ MSRetStat Microservice_Reactor::Delegate(std::string& key, nsMicroservice_Iface: ...@@ -17,3 +20,7 @@ MSRetStat Microservice_Reactor::Delegate(std::string& key, nsMicroservice_Iface:
return retStat; return retStat;
} }
void Microservice_Reactor::RegisterHandler(std::string key, nsMicroservice_Iface::IHandler *p_Handler) {
handlersMap_[key] = p_Handler;
}
src/handlers/Microservice_Reactor.h
...@@ -16,9 +16,9 @@ ...@@ -16,9 +16,9 @@
class Microservice_Reactor { class Microservice_Reactor {
public: public:
void RegisterHandler(std::string key,nsMicroservice_Iface::IHandler* p_Handler) { Microservice_Reactor() : p_metrics_factory_(nullptr){}
handlersMap_[key] = p_Handler;
} void RegisterHandler(std::string key,nsMicroservice_Iface::IHandler* p_Handler);
MSRetStat Delegate(std::string& key,nsMicroservice_Iface::IContext* p_Ctx); MSRetStat Delegate(std::string& key,nsMicroservice_Iface::IContext* p_Ctx);
...@@ -26,8 +26,14 @@ public: ...@@ -26,8 +26,14 @@ public:
return handlersMap_; return handlersMap_;
}; };
Microservice_Reactor& withMetrics(nsMicroservice_Iface::IMetricsFactory* p_metrics){
p_metrics_factory_ = p_metrics;
return *this;
}
private: private:
std::map<std::string,nsMicroservice_Iface::IHandler*> handlersMap_; std::map<std::string,nsMicroservice_Iface::IHandler*> handlersMap_;
nsMicroservice_Iface::IMetricsFactory* p_metrics_factory_;
}; };
......
src/handlers/Microservice_RestHandler.cpp
...@@ -27,7 +27,7 @@ cMicroservice_RestHandler::cMicroservice_RestHandler(std::string apiContextPath, ...@@ -27,7 +27,7 @@ cMicroservice_RestHandler::cMicroservice_RestHandler(std::string apiContextPath,
mpc_Buffer = new rapidjson::StringBuffer(0,nsMicroservice_Constants::MAX_JSON_BUFFER); mpc_Buffer = new rapidjson::StringBuffer(0,nsMicroservice_Constants::MAX_JSON_BUFFER);
mpc_Writer = new JsonStringWriter(*mpc_Buffer); mpc_Writer = new JsonStringWriter(*mpc_Buffer);
mpc_RequestContext = new cMicroservice_RequestContext(this, mpc_RequestContext = new cMicroservice_RequestContext(this,
mpc_Writer, // mpc_Writer,
new cMicroservice_IResponseRestImpl(), new cMicroservice_IResponseRestImpl(),
new cMicroservice_IRequestRestImpl()); new cMicroservice_IRequestRestImpl());
this->apiContextPath = apiContextPath; this->apiContextPath = apiContextPath;
......
src/impl/MSIMetricsFactoryDropwisardImpl.cpp
...@@ -116,7 +116,7 @@ void MSIMetricsFactoryDropwisardImpl::GetMetrics(std::map<std::string, long>& me ...@@ -116,7 +116,7 @@ void MSIMetricsFactoryDropwisardImpl::GetMetrics(std::map<std::string, long>& me
{ {
register auto meter_ptr = meter.second; register auto meter_ptr = meter.second;
str.assign("meter." + meter.first); str.assign("meter." + meter.first);
metrics_map[str + "count"] = meter_ptr->getCount(); metrics_map[str + ".count"] = meter_ptr->getCount();
metrics_map[str + ".mean_rate"] = meter_ptr->getMeanRate(); metrics_map[str + ".mean_rate"] = meter_ptr->getMeanRate();
metrics_map[str + ".1m_rate"] = meter_ptr->getOneMinuteRate(); metrics_map[str + ".1m_rate"] = meter_ptr->getOneMinuteRate();
metrics_map[str + ".5m_rate"] = meter_ptr->getFiveMinuteRate(); metrics_map[str + ".5m_rate"] = meter_ptr->getFiveMinuteRate();
...@@ -175,3 +175,7 @@ void MSIMetricsFactoryDropwisardImpl::ReportToGraphite() { ...@@ -175,3 +175,7 @@ void MSIMetricsFactoryDropwisardImpl::ReportToGraphite() {
} }
} }
} }
void MSIMetricsFactoryDropwisardImpl::meterMark(std::string &name) {
registry_->meter(name.c_str())->mark();
}
src/impl/MSIMetricsFactoryDropwisardImpl.h
...@@ -45,6 +45,8 @@ public: ...@@ -45,6 +45,8 @@ public:
void startReporting() override; void startReporting() override;
void stopReporting() override; void stopReporting() override;
virtual void meterMark(std::string &name) override;
void GetMetrics(std::map<std::string, long>& metrics_map) override; void GetMetrics(std::map<std::string, long>& metrics_map) override;
cppmetrics::core::MetricRegistryPtr GetRegistry() const { cppmetrics::core::MetricRegistryPtr GetRegistry() const {
......
src/impl/servers/Microservice_IRestServerMongooseImpl.cpp
...@@ -20,6 +20,8 @@ ...@@ -20,6 +20,8 @@
#include <signal.h> #include <signal.h>
#include <handlers/Microservice_RestHandler.h> #include <handlers/Microservice_RestHandler.h>
#include <handlers/Microservice_Reactor.h> #include <handlers/Microservice_Reactor.h>
#include <impl/Microservice_IResponseRestImpl.h>
#include <impl/Microservice_IRequestRestImpl.h>
static const int POLLING_INTERVAL = 100; // IN MILLI static const int POLLING_INTERVAL = 100; // IN MILLI
static int s_sig_num = 0; static int s_sig_num = 0;
...@@ -53,7 +55,9 @@ cMicroservice_IRestServerMongooseImpl::cMicroservice_IRestServerMongooseImpl(cMi ...@@ -53,7 +55,9 @@ cMicroservice_IRestServerMongooseImpl::cMicroservice_IRestServerMongooseImpl(cMi
{ {
serverType_.assign(getType()); serverType_.assign(getType());
mpc_Param = pc_Param; mpc_Param = pc_Param;
mc_HandlersMap.clear(); // mc_HandlersMap.clear();
p_requestRestImpl_ = new cMicroservice_IRequestRestImpl();
p_restResponseImpl_ = new cMicroservice_IResponseRestImpl();
} }
cMicroservice_IRestServerMongooseImpl::cMicroservice_IRestServerMongooseImpl(const cMicroservice_IRestServerMongooseImpl& orig) { cMicroservice_IRestServerMongooseImpl::cMicroservice_IRestServerMongooseImpl(const cMicroservice_IRestServerMongooseImpl& orig) {
...@@ -101,14 +105,14 @@ bool cMicroservice_IRestServerMongooseImpl::build(std::string& appName, ...@@ -101,14 +105,14 @@ bool cMicroservice_IRestServerMongooseImpl::build(std::string& appName,
/* /*
* creating a map of rest handlers * creating a map of rest handlers
*/ */
for (auto prfxHandler : msHandlersMap) // for (auto prfxHandler : msHandlersMap)
{ // {
cMicroservice_RestHandler* pc_RestHandler = new cMicroservice_RestHandler(prfxHandler.first,dynamic_cast<cMicroservice_BaseHandler*>(prfxHandler.second)); // cMicroservice_RestHandler* pc_RestHandler = new cMicroservice_RestHandler(prfxHandler.first,dynamic_cast<cMicroservice_BaseHandler*>(prfxHandler.second));
pc_RestHandler->withLogger(pc_Logger); // pc_RestHandler->withLogger(pc_Logger);
pc_RestHandler->withPubSub(pc_PubSub); // pc_RestHandler->withPubSub(pc_PubSub);
pc_RestHandler->withMetrics(p_metrics_factory); // pc_RestHandler->withMetrics(p_metrics_factory);
this->mc_HandlersMap[prfxHandler.first] = pc_RestHandler; // //this->mc_HandlersMap[prfxHandler.first] = pc_RestHandler;
} // }
result = true; result = true;
} }
} }
...@@ -151,22 +155,22 @@ void cMicroservice_IRestServerMongooseImpl::HandleRequest(mg_connection* conn, h ...@@ -151,22 +155,22 @@ void cMicroservice_IRestServerMongooseImpl::HandleRequest(mg_connection* conn, h
const char* pba_NextSlash = strchr(pba_Uri + 1, '/'); const char* pba_NextSlash = strchr(pba_Uri + 1, '/');
if (pba_NextSlash) if (pba_NextSlash)
{ {
std::string apiContextPath(pba_Uri,(int)(pba_NextSlash - pba_Uri));
std::string key(nsMicroservice_Iface::IRestServer::TYPE); std::string key(nsMicroservice_Iface::IRestServer::TYPE);
key.append(nsMicroservice_Constants::TYPE_PREFIX_SEPERATOR).append(pba_Uri,(int)(pba_NextSlash - pba_Uri)); key.append(nsMicroservice_Constants::TYPE_PREFIX_SEPERATOR).append(apiContextPath);
if(p_reactor_) if(p_reactor_)
HandleNewRequest(conn,msg); HandleNewRequest(conn, key, msg, apiContextPath);
else else
SendGeneralError(conn,500,"Missing Reactor body!"); SendGeneralError(conn,500,"Missing Reactor body!");
auto iter = mc_HandlersMap.find(key); // auto iter = mc_HandlersMap.find(key);
if (iter != mc_HandlersMap.end()) // if (iter != mc_HandlersMap.end())
{ // {
cMicroservice_RestHandler* pc_Handler = iter->second;//mc_HandlerIterator->second; // cMicroservice_RestHandler* pc_Handler = iter->second;//mc_HandlerIterator->second;
pc_Handler->HandleRequest(conn,msg); // pc_Handler->HandleRequest(conn,msg);
} // }
else // else
SendNotImplemented(conn); // SendNotImplemented(conn);
} }
else else
SendNotImplemented(conn); SendNotImplemented(conn);
...@@ -195,15 +199,17 @@ bool cMicroservice_IRestServerMongooseImpl::init() { ...@@ -195,15 +199,17 @@ bool cMicroservice_IRestServerMongooseImpl::init() {
return true; return true;
} }
void cMicroservice_IRestServerMongooseImpl::HandleNewRequest(mg_connection *p_connection, http_message *p_message) { void cMicroservice_IRestServerMongooseImpl::HandleNewRequest(mg_connection *p_connection, std::string key,
http_message *p_message, std::string& apiContextPath) {
MSRetStat retStat; MSRetStat retStat;
// cMicroservice_RequestContext ctx(this, cMicroservice_RequestContext ctx(this,
// p_writer_, p_restResponseImpl_,
// p_restResponseImpl_, p_requestRestImpl_);
// p_requestRestImpl_); retStat = ParseRequest(p_connection, p_message, ctx,apiContextPath);
// retStat = parser_.parse(p_message, ctx); if (retStat.IsSuccess())
// if (retStat.IsSuccess()) p_reactor_->Delegate(key, &ctx);
// p_reactor_->Delegate(serverType_, &ctx); else
SendGeneralError(p_connection,500,"Failed in parsing...yored lekafa..");
} }
...@@ -212,4 +218,174 @@ cMicroservice_IRestServerMongooseImpl::SendGeneralError(mg_connection *p_connect ...@@ -212,4 +218,174 @@ cMicroservice_IRestServerMongooseImpl::SendGeneralError(mg_connection *p_connect
mg_printf(p_connection, "HTTP/1.0 %u %s\r\nContent-Length: 0\r\n\r\n",respCode,error); mg_printf(p_connection, "HTTP/1.0 %u %s\r\nContent-Length: 0\r\n\r\n",respCode,error);
} }
void
cMicroservice_IRestServerMongooseImpl::SendErrorResp(nsMicroservice_Iface::IResponse *pti_Response, std::string error) {
/*
* create error rest response
*/
std::ostringstream c_OutputStream;
c_OutputStream << nsMicroservice_Constants::ERROR_REST_RESPONSE_TEMPLATE_PREFIX
<< error.c_str()
<< nsMicroservice_Constants::ERROR_REST_RESPONSE_TEMPLATE_SUFFIX
<< '}';
/*
* send it
*/
//pti_Response->Send(mba_ErrorBuff);
pti_Response->Send(c_OutputStream.str().c_str());
}
void cMicroservice_IRestServerMongooseImpl::WriteObjectToResponse(nsMicroservice_Iface::IResponse *pti_Response,
rapidjson::Document &t_ObjectDoc) {
std::ostringstream c_OutputStream;
if(!t_ObjectDoc.IsNull()) {
rapidjson::StringBuffer buffer;
rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
t_ObjectDoc.Accept(writer);
c_OutputStream << nsMicroservice_Constants::SUCCESS_REST_RESPONSE_TEMPLATE << buffer.GetString() << '}';
} else {
c_OutputStream << nsMicroservice_Constants::SUCCESS_NULL_REST_RESPONSE_TEMPLATE << '}';
}
pti_Response->Send(c_OutputStream.str().c_str());
}
void cMicroservice_IRestServerMongooseImpl::WriteObjectToResponse(nsMicroservice_Iface::IResponse *pti_Response,
cMicroservice_BaseRestResponse &t_BaseRestResponse) {
if(t_BaseRestResponse.IsSuccess()){
WriteObjectToResponse(pti_Response,t_BaseRestResponse.GetObjectNode());
}
else{
SendErrorResp(pti_Response,t_BaseRestResponse.GetError());
}
}
void cMicroservice_IRestServerMongooseImpl::WriteStringToResponse(nsMicroservice_Iface::IResponse *pti_Response,
const char *pba_Doc) {
std::ostringstream c_OutputStream;
c_OutputStream << nsMicroservice_Constants::SUCCESS_REST_RESPONSE_TEMPLATE << pba_Doc << '}';
pti_Response->Send(c_OutputStream.str().c_str());
}
bool cMicroservice_IRestServerMongooseImpl::ReadObjectFromRequest(nsMicroservice_Iface::IRequest *pti_Request,
rapidjson::Document &t_ObjectDoc) {
const char* pba_Content = pti_Request->GetContent();
if (pba_Content)
{
if (!t_ObjectDoc.Parse<0>(pba_Content).HasParseError())
return true;
}
return false;
}
MSRetStat
cMicroservice_IRestServerMongooseImpl::ParseRequest(mg_connection *p_conn,
http_message *p_message,
cMicroservice_RequestContext& ctx,
std::string& apiContextPath) {
/*
* get request context
*/
/*
* getting/setting request/response ifaces
*/
((cMicroservice_IRequestRestImpl*)ctx.mpti_Request)->SetMsg(p_message);
((cMicroservice_IResponseRestImpl*)ctx.mpti_Response)->setConn(p_conn);
/*
* getting params
*/
memcpy(mba_Buff,p_message->uri.p,p_message->uri.len);
mba_Buff[p_message->uri.len] = CNULL;
char* pba_ParamsStr = &mba_Buff[apiContextPath.length()];
char* pba_token = strtok(pba_ParamsStr,nsMicroservice_Constants::SLASH_SEPERATOR);
while(pba_token)
{
ctx.mc_Params.push_back(pba_token);
pba_token = strtok(NULL,nsMicroservice_Constants::SLASH_SEPERATOR);
}
/*
* getting query parameters
*/
GetQueryParams(ctx, p_message);
/*
* Log request
*/
LogRequest(p_message);
/**
* get crud method
*/
ctx.crudMethod = GetCrudMethod(p_message);
return MSRetStat();
}
void cMicroservice_IRestServerMongooseImpl::LogRequest(http_message *p_msg) {
if (mpc_Logger->getLevel() == cMicroservice_Enums::eLogLevel::eDebug) {
std::string str("Received request: ");
str.append(p_msg->method.p, p_msg->method.len);
str.append(", uri: ").append(p_msg->uri.p, p_msg->uri.len);
if (p_msg->query_string.p)
str.append(", query string: ").append(p_msg->query_string.p, p_msg->query_string.len);
mpc_Logger->debug(str);
}
}
void
cMicroservice_IRestServerMongooseImpl::GetQueryParams(cMicroservice_RequestContext &ctx, http_message *p_msg) {
/*
* getting query parameters
*/
if (!p_msg->query_string.p)
return;
DequeStringMap* pc_queryParams = &ctx.mc_QueryParameters;
memcpy(mba_Buff,p_msg->query_string.p,p_msg->query_string.len);
mba_Buff[p_msg->query_string.len] = CNULL;
//strlcpy(mba_Buff, p_msg->query_string.p,p_msg->query_string.len + 1);//nsMicroservice_Constants::MAX_URI_LENGTH);
char* pba_token = strtok(mba_Buff, nsMicroservice_Constants::AND_SEPERATOR);
while (pba_token)
{
// x=y or just x
char* pba_Equal = strchr(pba_token, '=');
if (pba_Equal)
{
*pba_Equal = CNULL;
DequeStringMap::iterator t_QueryParamIter = pc_queryParams->find(pba_token);
if (t_QueryParamIter != pc_queryParams->end())
{
// existing query key >> adding to deque
t_QueryParamIter->second.push_back(pba_Equal + 1);
}
else
{
// new one
std::deque<std::string> t_QueryDeque;
t_QueryDeque.push_back(pba_Equal + 1);
(*pc_queryParams)[pba_token] = t_QueryDeque;
}
}
else
{
// insert empty deque - cannot insert null value
std::deque<std::string> t_QueryDeque;
(*pc_queryParams)[pba_token] = t_QueryDeque;
}
pba_token = strtok(NULL, nsMicroservice_Constants::AND_SEPERATOR);
}
}
eCrudMethod cMicroservice_IRestServerMongooseImpl::GetCrudMethod(http_message *p_msg) {
auto iter = _microservice_RestCrudMap.find(std::string(p_msg->method.p,p_msg->method.len));
if (iter != _microservice_RestCrudMap.end())
return iter->second;
return eCrudMethod::eMaxMethods;
}
src/impl/servers/Microservice_IRestServerMongooseImpl.h
...@@ -15,6 +15,7 @@ ...@@ -15,6 +15,7 @@
#define MICROSERVICE_IRESTSERVERMONGOOSEIMPL_H #define MICROSERVICE_IRESTSERVERMONGOOSEIMPL_H
#include "common/Microservice_Iface.h" #include "common/Microservice_Iface.h"
#include <thread> #include <thread>
#include <common/Microservice_RequestContext.h>
#include "../../params/Microservice_Params.h" #include "../../params/Microservice_Params.h"
struct mg_connection; struct mg_connection;
...@@ -22,8 +23,10 @@ struct mg_mgr; ...@@ -22,8 +23,10 @@ struct mg_mgr;
struct http_message; struct http_message;
class cMicroservice_RestHandler; class cMicroservice_RestHandler;
class cMicroservice_IResponseRestImpl;
class cMicroservice_IRequestRestImpl;
class cMicroservice_IRestServerMongooseImpl : public nsMicroservice_Iface::IRestServer { class cMicroservice_IRestServerMongooseImpl : public nsMicroservice_Iface::IRestServer , public nsMicroservice_Iface::IContainer {
public: public:
cMicroservice_IRestServerMongooseImpl(cMicroservice_RestServerParams* pc_Param); cMicroservice_IRestServerMongooseImpl(cMicroservice_RestServerParams* pc_Param);
cMicroservice_IRestServerMongooseImpl(const cMicroservice_IRestServerMongooseImpl& orig); cMicroservice_IRestServerMongooseImpl(const cMicroservice_IRestServerMongooseImpl& orig);
...@@ -45,19 +48,45 @@ public: ...@@ -45,19 +48,45 @@ public:
void HandleRequest(mg_connection *conn,http_message *msg); void HandleRequest(mg_connection *conn,http_message *msg);
void SendNotImplemented(mg_connection* conn); void SendNotImplemented(mg_connection* conn);
virtual void SendErrorResp(nsMicroservice_Iface::IResponse *pti_Response, std::string error) override;
virtual void
WriteObjectToResponse(nsMicroservice_Iface::IResponse *pti_Response, rapidjson::Document &t_ObjectDoc) override;
virtual void WriteObjectToResponse(nsMicroservice_Iface::IResponse *pti_Response,
cMicroservice_BaseRestResponse &t_BaseRestResponse) override;
virtual void WriteStringToResponse(nsMicroservice_Iface::IResponse *pti_Response, const char *pba_Doc) override;
virtual bool
ReadObjectFromRequest(nsMicroservice_Iface::IRequest *pti_Request, rapidjson::Document &t_ObjectDoc) override;
private: private:
cMicroservice_RestServerParams* mpc_Param; cMicroservice_RestServerParams* mpc_Param;
std::map<std::string,cMicroservice_RestHandler*> mc_HandlersMap; //std::map<std::string,cMicroservice_RestHandler*> mc_HandlersMap;
std::string mc_AppName; std::string mc_AppName;
mg_mgr *mpt_ServerManager; mg_mgr *mpt_ServerManager;
char mba_UriBuff[nsMicroservice_Constants::MAX_URI_LENGTH]; char mba_UriBuff[nsMicroservice_Constants::MAX_URI_LENGTH];
std::thread* mpc_RunThread; std::thread* mpc_RunThread;
nsMicroservice_Iface::ILogger* mpc_Logger; nsMicroservice_Iface::ILogger* mpc_Logger;
std::string serverType_; std::string serverType_;
char mba_Buff[nsMicroservice_Constants::MAX_URI_LENGTH]; // should be thread safe
cMicroservice_IResponseRestImpl* p_restResponseImpl_;
cMicroservice_IRequestRestImpl* p_requestRestImpl_;
void HandleNewRequest(mg_connection *p_connection, http_message *p_message); void HandleNewRequest(mg_connection *p_connection, std::string key,
http_message *p_message, std::string& apiContextPath);
void SendGeneralError(mg_connection *p_connection, int respCode, const char *error); void SendGeneralError(mg_connection *p_connection, int respCode, const char *error);
MSRetStat ParseRequest(mg_connection *p_conn,
http_message *p_message,
cMicroservice_RequestContext& ctx,
std::string& apiContextPath);
void LogRequest(http_message* p_msg);
void GetQueryParams(cMicroservice_RequestContext &ctx, http_message *p_msg);
eCrudMethod GetCrudMethod(http_message *p_msg);
}; };
#endif /* MICROSERVICE_IRESTSERVERMONGOOSEIMPL_H */ #endif /* MICROSERVICE_IRESTSERVERMONGOOSEIMPL_H */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment