Merge branch 'Feature-MongooseFree' into 'develop'

Feature mongoose free

Bye bye mongoose 😢 

See merge request !2

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 2.8.12)
 project(Microservice)
 # version stuff
 set (Microservice_VERSION_MAJOR 1)
-set (Microservice_VERSION_MINOR 1)
+set (Microservice_VERSION_MINOR 2)
 set (Microservice_VERSION_PATCH 0)
 set(Microservice_VERSION_STRING ${Microservice_VERSION_MAJOR}.${Microservice_VERSION_MINOR}.${Microservice_VERSION_PATCH})
 
@@ -28,17 +28,18 @@ include_directories(SYSTEM ../3party/cereal-1.2.1/include)
 include_directories(SYSTEM ../3party/rapidjson-cereal-1.2.1)
 #include_directories(SYSTEM ../3party/rapidjson-0.11/include/rapidjson)
 include_directories(SYSTEM ../3party/cppmetrics-0.1.1-Linux/include)
-include_directories(SYSTEM ../3party/mongoose)
+include_directories(SYSTEM ../3party/civetweb/include)
 include_directories(SYSTEM ../3party/cpprest/Release/include)
 include_directories(SYSTEM ../3party/rabbitmq)
 include_directories(SYSTEM ../internals/include/Rabbitmq)
 include_directories(SYSTEM /usr/include/hiredis)
 # recursive search files cpp files
-file(GLOB_RECURSE SOURCES "src/*.cpp")
-set (3PARTY_SOURCES ../3party/mongoose/mongoose.c )
+file(GLOB_RECURSE SOURCES "src/*.cpp" src/Microservice_BaseRestResponse.h src/common/Microservice_RestResponse.h src/common/Microservice_MsgQContext.h src/handlers/Microservice_Reactor.cpp src/handlers/Microservice_Reactor.h src/common/Microservice_PubSubContext.h src/handlers/Microservice_MsgQHandler.h src/handlers/Microservice_PubSubHandler.h src/impl/servers/Microservice_IMsgQueueServerZmqImpl.cpp src/impl/servers/Microservice_IMsgQueueServerZmqImpl.h src/impl/Microservice_IMsgArchiverCerealImpls.h src/utils/ServerFactory.cpp src/utils/ServerFactory.h src/utils/ClientFactory.cpp src/utils/ClientFactory.h src/impl/clients/MSZMQClientImpl.cpp src/impl/clients/MSZMQClientImpl.h src/impl/clients/MSIPubSubClientImpl.cpp src/impl/clients/MSIPubSubClientImpl.h)
+set (3PARTY_SOURCES ../3party/civetweb/src/civetweb.c ../3party/civetweb/src/CivetServer.cpp ../3party/civetweb/src/md5.inl ../3party/civetweb/src/handle_form.inl)
+
 
 #Generate the shared library from the sources
-add_library(Microservice SHARED ${SOURCES} ${3PARTY_SOURCES} src/common/Microservice_RestResponse.h src/common/Microservice_MsgQContext.h src/handlers/Microservice_Reactor.cpp src/handlers/Microservice_Reactor.h src/common/Microservice_PubSubContext.h src/handlers/Microservice_MsgQHandler.h src/handlers/Microservice_PubSubHandler.h src/impl/servers/Microservice_IMsgQueueServerZmqImpl.cpp src/impl/servers/Microservice_IMsgQueueServerZmqImpl.h src/impl/Microservice_IMsgArchiverCerealImpls.h src/utils/ServerFactory.cpp src/utils/ServerFactory.h src/utils/ClientFactory.cpp src/utils/ClientFactory.h src/impl/clients/MSZMQClientImpl.cpp src/impl/clients/MSZMQClientImpl.h src/impl/clients/MSIPubSubClientImpl.cpp src/impl/clients/MSIPubSubClientImpl.h)
+add_library(Microservice SHARED ${SOURCES} ${3PARTY_SOURCES} )
 target_link_libraries(Microservice ${PROJECT_LINK_LIBS} )
 set_target_properties(Microservice PROPERTIES VERSION ${Microservice_VERSION_STRING}
                                           SOVERSION ${Microservice_VERSION_MAJOR})

README.md

 ## C++ Microservice Framework
 
 ## VERSIONS:
+# 1.2.0
+- replace mongoose with civet
 # 1.1.0
 - Add bin serializer
 

doc/todo.txt

@@ -4,3 +4,5 @@
   the server receives the msg with the source(client pull channel) address to reply to,
   checks in the hash for already connected and uses this channel to send a reply.
   we can use zmqpp::socket::send_more to send source address and then the actual msg
+
+- Test FlatBuffer as serializer for rest over zmq
\ No newline at end of file

src/Microservice_App.cpp

@@ -9,7 +9,6 @@
 #include <Microservice_App.h>
 #include <params/Microservice_Params.h>
 #include <handlers/Microservice_BaseHandler.h>
-#include <handlers/Microservice_RestHandler.h>
 #include <handlers/Microservice_MonitorHandler.h>
 #include <algorithm>
 #include <Microservice_Client.h>

src/common/Microservice_Iface.h

@@ -273,8 +273,6 @@ namespace nsMicroservice_Iface
 						   ILogger* pc_Logger,
 						   IPubSub* pc_PubSub,
 						   IMetricsFactory* p_metrics_factory) = 0;
-//		virtual void run() = 0;
-//		virtual void stop() = 0;
 		virtual void registerService(IServiceDiscovery* pc_ServiceDiscovery, std::string& id) = 0;
         virtual const char* getType() final { return TYPE;  }
 	};

src/handlers/Microservice_RMQHandler.cpp

@@ -10,7 +10,8 @@
 #include <stringbuffer.h>
 #include <map>
 #include <deque>
-#include <mongoose.h>
+//#include <mongoose.h>
+#include <civetweb.h>
 #include <stdlib.h>
 
 #include <stringbuffer.h> //rapidjson string

src/handlers/Microservice_RestHandler.h

-/*
- * Microservice_RestHandler.h
- *
- *  Created on: Mar 23, 2015
- *      Author: amir
- */
-
-#ifndef MICROSERVICE_RESTHANDLER_H_
-#define MICROSERVICE_RESTHANDLER_H_
-#include <common/Microservice_Defines.h>
-#include <common/Microservice_Iface.h>
-#include <stddef.h>
-#include <writer.h>
-#include <stringbuffer.h>
-#include <handlers/Microservice_BaseHandler.h>
-#include <Microservice_BaseRestResponse.h>
-
-struct mg_connection;
-struct http_message;
-class cMicroservice_RequestContext;
-
-
-class cMicroservice_RestHandler : public nsMicroservice_Iface::IContainer
-{
-private:
-  JsonStringWriter *mpc_Writer;
-  rapidjson::StringBuffer* mpc_Buffer;
-  std::string apiContextPath;
-  cMicroservice_BaseHandler* mpc_Handler;
-  nsMicroservice_Iface::ILogger* mpc_Logger;
-  nsMicroservice_Iface::IPubSub* mpc_PubSub;
-    std::map<std::string,cMicroservice_Enums::eCrudMethod> crudMethodMap_;
-
-  cMicroservice_RequestContext* mpc_RequestContext;
-  char mba_Buff[nsMicroservice_Constants::MAX_URI_LENGTH];
-  char mba_ErrorBuff[nsMicroservice_Constants::MAX_ERROR_BUFF_URI_LENGTH];
-  nsMicroservice_Iface::IMetricsFactory* p_metrics_factory_;
-  // metrics
-  nsMicroservice_Iface::IMetricsFactory::IMeter* p_get_meter_;
-  nsMicroservice_Iface::IMetricsFactory::IMeter* p_post_meter_;
-  nsMicroservice_Iface::IMetricsFactory::IMeter* p_put_meter_;
-  nsMicroservice_Iface::IMetricsFactory::IMeter* p_delete_meter_;
-  nsMicroservice_Iface::IMetricsFactory::ITimer* p_get_timer_;
-  nsMicroservice_Iface::IMetricsFactory::ITimer* p_post_timer_;
-  
-  
-  cMicroservice_Enums::eMethod GetMethod(http_message *msg);
-
-  // inlines
-  void DoGet(cMicroservice_RequestContext* pc_ReqCtx) { mpc_Handler->DoRead(pc_ReqCtx); }
-  void DoPost(cMicroservice_RequestContext* pc_ReqCtx){ mpc_Handler->DoCreate(pc_ReqCtx); }
-  void DoPut(cMicroservice_RequestContext* pc_ReqCtx) { mpc_Handler->DoUpdate(pc_ReqCtx); }
-  void DoDelete(cMicroservice_RequestContext* pc_ReqCtx){ mpc_Handler->DoDelete(pc_ReqCtx); }
-  /**
-   * prepare the request context
-   * @param mg_connection
-   * @return
-   */
-  void SetRequestContext(mg_connection *conn,http_message *msg);
-  void GetQueryParams(http_message *msg);
-  void LogRequest(http_message *msg);
-  void CreateMetrics();
-  void PreHandleMetrics(cMicroservice_Enums::eMethod e_Method);
-  void PostHandleMetrics(cMicroservice_Enums::eMethod e_Method);
-  
-public:
-  cMicroservice_RestHandler(std::string apiContextPath,cMicroservice_BaseHandler* pc_Handler);
-    
-    void withMetrics(nsMicroservice_Iface::IMetricsFactory* p_metrics_factory) { 
-        this->p_metrics_factory_ = p_metrics_factory;
-        CreateMetrics();
-    }
-    void withLogger(nsMicroservice_Iface::ILogger* pc_Logger) { this->mpc_Logger = pc_Logger;  }
-    void withPubSub(nsMicroservice_Iface::IPubSub* pc_PubSub) { this->mpc_PubSub = pc_PubSub; }
-
-  void HandleRequest(mg_connection* conn,http_message *msg);
-
-
-  void SendErrorResp(nsMicroservice_Iface::IResponse* pti_Response,std::string error);
-  void WriteObjectToResponse(nsMicroservice_Iface::IResponse* pti_Response,rapidjson::Document& t_ObjectDoc);
-  void WriteObjectToResponse(nsMicroservice_Iface::IResponse* pti_Response,cMicroservice_BaseRestResponse& t_BaseRestResponse);
-  void WriteStringToResponse(nsMicroservice_Iface::IResponse* pti_Response,const char* pba_Doc);
-  bool ReadObjectFromRequest(nsMicroservice_Iface::IRequest* pti_Request,rapidjson::Document& t_ObjectDoc);
-  
-//  void Publish(std::string& t_Topic, std::string& t_Message) {}
-//  void Subscribe(std::string& t_Topic, nsMicroservice_Iface::INotifyCallback& t_NotifyHandler) {}
-//  void Unsubscribe(std::string& t_Topic) {}
-
-
-    eCrudMethod GetCrudMethod(http_message *pMessage);
-};
-
-
-
-#endif /* MICROSERVICE_RESTHANDLER_H_ */

src/impl/Microservice_IRequestRestImpl.cpp

@@ -6,12 +6,13 @@
  */
 
 #include <impl/Microservice_IRequestRestImpl.h>
-#include <mongoose.h>
+//#include <mongoose.h>
+#include <civetweb.h>
 #include <stdlib.h>
 
 
 cMicroservice_IRequestRestImpl::cMicroservice_IRequestRestImpl():
-mpt_MgMsg(nullptr),mba_BodyBuffer(nullptr)
+p_reqInfo_(nullptr),mba_BodyBuffer(nullptr)
 {
   // TODO Auto-generated constructor stub
 
@@ -24,39 +25,36 @@ cMicroservice_IRequestRestImpl::~cMicroservice_IRequestRestImpl() {
 }
 
 void cMicroservice_IRequestRestImpl::Reset() {
-    mpt_MgMsg = nullptr;
+    p_reqInfo_ = nullptr;
 }
 
 const char* cMicroservice_IRequestRestImpl::GetQueryString()
 {
-  if (mpt_MgMsg)
-    return mpt_MgMsg->query_string.p;
-  return NULL;
+  if (p_reqInfo_)
+    return p_reqInfo_->query_string;
+  return nullptr;
 }
 
 
 const char* cMicroservice_IRequestRestImpl::GetRelativePath()
 {
-  if (mpt_MgMsg)
-    return mpt_MgMsg->uri.p;
-  return NULL;
+  if (p_reqInfo_)
+    return p_reqInfo_->local_uri;
+  return nullptr;
 }
 
 const char* cMicroservice_IRequestRestImpl::GetContent()
 {
-  if (mpt_MgMsg)
+  if (p_reqInfo_)
   {
-      register auto len = mpt_MgMsg->body.len;
+      register auto len = p_reqInfo_->content_length;
       if(len > 0)
       {
           mba_BodyBuffer = (char*)realloc(mba_BodyBuffer,len + 1);
-        memcpy(mba_BodyBuffer,mpt_MgMsg->body.p,len);
+          len = mg_read((mg_connection *) p_conn_, mba_BodyBuffer, len);
             *(mba_BodyBuffer + len) = CNULL;
         return (const char*)mba_BodyBuffer;
       }
-      
-//    mpt_MgMsg->body.p[mpt_MgMsg->body.len] = CNULL;
-    //return mpt_MgMsg->body.p;
   }
   return NULL;
 }

src/impl/Microservice_IRequestRestImpl.h

@@ -8,6 +8,7 @@
 #ifndef MICROSERVICE_IREQUESTRESTIMPL_H_
 #define MICROSERVICE_IREQUESTRESTIMPL_H_
 #include <common/Microservice_Iface.h>
+#include <civetweb.h>
 
 struct mg_connection;
 struct http_message;
@@ -15,7 +16,8 @@ struct http_message;
 class cMicroservice_IRequestRestImpl: public nsMicroservice_Iface::IRequest
 {
   //mg_connection *mpt_MgConn;
-  http_message  *mpt_MgMsg;
+    const mg_request_info *p_reqInfo_;
+    const mg_connection* p_conn_;
   char          *mba_BodyBuffer;
 public:
   cMicroservice_IRequestRestImpl();
@@ -28,7 +30,10 @@ public:
   void  Reset();
 
   //void setConn(mg_connection* pt_conn) { this->mpt_MgConn = pt_conn;}
-  void SetMsg(http_message* mpt_MgMsg) { this->mpt_MgMsg = mpt_MgMsg; }
+  void SetParams(const mg_connection* p_conn,const mg_request_info *mpt_MgMsg) {
+    p_conn_ = p_conn;
+    p_reqInfo_ = mpt_MgMsg;
+  }
 
 };
 

src/impl/Microservice_IResponseRestImpl.cpp

@@ -5,8 +5,8 @@
  *      Author: amir
  */
 #include <impl/Microservice_IResponseRestImpl.h>
-#include <mongoose.h>
-
+//#include <mongoose.h>
+#include <civetweb.h>
 
 cMicroservice_IResponseRestImpl::cMicroservice_IResponseRestImpl():
 mpt_MgConn(NULL)

src/impl/servers/Microservice_IRestServerMongooseImpl.h → src/impl/servers/Microservice_IRestServerCivetWebImpl.h

@@ -13,24 +13,28 @@
 
 #ifndef MICROSERVICE_IRESTSERVERMONGOOSEIMPL_H
 #define MICROSERVICE_IRESTSERVERMONGOOSEIMPL_H
+static const char *const HTTP_1_1 = "1.1";
+
 #include "common/Microservice_Iface.h"
 #include <thread>
 #include <common/Microservice_RequestContext.h>
 #include "../../params/Microservice_Params.h"
 
 struct mg_connection;
-struct mg_mgr;
-struct http_message;
+//struct mg_mgr;
+//struct http_message;
+struct mg_context;
+struct mg_request_info;
 
-class cMicroservice_RestHandler;
+//class cMicroservice_RestHandler;
 class cMicroservice_IResponseRestImpl;
 class cMicroservice_IRequestRestImpl;
 
-class cMicroservice_IRestServerMongooseImpl : public nsMicroservice_Iface::IRestServer , public nsMicroservice_Iface::IContainer {
+class cMicroservice_IRestServerCivetWebImpl : public nsMicroservice_Iface::IRestServer , public nsMicroservice_Iface::IContainer {
 public:
-    cMicroservice_IRestServerMongooseImpl(cMicroservice_RestServerParams* pc_Param);
-    cMicroservice_IRestServerMongooseImpl(const cMicroservice_IRestServerMongooseImpl& orig);
-    virtual ~cMicroservice_IRestServerMongooseImpl();
+    cMicroservice_IRestServerCivetWebImpl(cMicroservice_RestServerParams* pc_Param);
+    cMicroservice_IRestServerCivetWebImpl(const cMicroservice_IRestServerCivetWebImpl& orig);
+    virtual ~cMicroservice_IRestServerCivetWebImpl();
 
     bool build(std::string& appName, const std::map<std::string,nsMicroservice_Iface::IHandler*>& msHandlersMap,
                nsMicroservice_Iface::ILogger* pc_Logger,
@@ -45,7 +49,7 @@ public:
 
     virtual bool init() override;
 
-    void HandleRequest(mg_connection *conn,http_message *msg);
+    void HandleRequest(mg_connection *conn,const mg_request_info *req_info);
     void SendNotImplemented(mg_connection* conn);
 
     virtual void SendErrorResp(nsMicroservice_Iface::IResponse *pti_Response, std::string error) override;
@@ -63,9 +67,9 @@ public:
 
 private:
     cMicroservice_RestServerParams* mpc_Param;
-    //std::map<std::string,cMicroservice_RestHandler*> mc_HandlersMap;
+    struct mg_context *p_ctx_;
     std::string mc_AppName;
-    mg_mgr    *mpt_ServerManager;
+//    mg_mgr    *mpt_ServerManager;
     char mba_UriBuff[nsMicroservice_Constants::MAX_URI_LENGTH];
     std::thread* mpc_RunThread;
     nsMicroservice_Iface::ILogger* mpc_Logger;
@@ -75,18 +79,18 @@ private:
     cMicroservice_IRequestRestImpl* p_requestRestImpl_;
 
     void HandleNewRequest(mg_connection *p_connection, std::string key,
-                              http_message *p_message, std::string& apiContextPath);
+                          const mg_request_info *req_info, std::string& apiContextPath);
     void SendGeneralError(mg_connection *p_connection, int respCode, const char *error);
 
     MSRetStat ParseRequest(mg_connection *p_conn,
-                           http_message *p_message,
+                           const mg_request_info *p_reqInfo,
                            cMicroservice_RequestContext& ctx,
                            std::string& apiContextPath);
-    void LogRequest(http_message* p_msg);
+    void LogRequest(const mg_request_info *p_reqInfo);
 
-    void GetQueryParams(cMicroservice_RequestContext &ctx, http_message *p_msg);
+    void GetQueryParams(cMicroservice_RequestContext &ctx, const mg_request_info *p_reqInfo);
 
-    eCrudMethod GetCrudMethod(http_message *p_msg);
+    eCrudMethod GetCrudMethod(const mg_request_info *p_reqInfo);
 };
 
 #endif /* MICROSERVICE_IRESTSERVERMONGOOSEIMPL_H */

src/utils/CommonUtils.cpp

+//
+// Created by amir on 28/03/17.
+//
+
+#include "CommonUtils.h"

src/utils/CommonUtils.h

+//
+// Created by amir on 28/03/17.
+//
+
+#ifndef MICROSERVICE_COMMONUTILS_H
+#define MICROSERVICE_COMMONUTILS_H
+
+
+#include <chrono>
+#include <utility>
+#include <string.h>
+#include <unistd.h>
+
+/**
+ * common utils
+ */
+class CommonUtils {
+
+public:
+
+    /**
+     * measuring execution of a function
+     * @tparam TimeT time unit (default milliseconds)
+     * @param func function
+     * @param args function args
+     * @return
+     */
+    template<typename TimeT = std::chrono::milliseconds,typename F, typename ...Args>
+    static typename TimeT::rep measureFunc(F&& func, Args&&... args)
+    {
+        auto start = std::chrono::steady_clock::now();
+        std::forward<decltype(func)>(func)(std::forward<Args>(args)...);
+        auto duration = std::chrono::duration_cast< TimeT>
+                (std::chrono::steady_clock::now() - start);
+        return duration.count();
+    }
+
+    static int strcmp(const char *str1, const char *str2) {
+        size_t n2 = strlen(str2), n1 = strlen(str1);
+        int r = memcmp(str1, str2, (n1 < n2) ? n1 : n2);
+        if (r == 0) {
+            return n1 - n2;
+        }
+        return r;
+    }
+
+    static int numofcpu(){
+        size_t cpunum = sysconf(_SC_NPROCESSORS_ONLN);
+        if (cpunum == 0)
+            cpunum = 1;
+        return (int)cpunum;
+    }
+};
+
+
+#endif //MICROSERVICE_COMMONUTILS_H

src/utils/ServerFactory.cpp

@@ -3,13 +3,13 @@
 //
 
 #include "ServerFactory.h"
-#include <impl/servers/Microservice_IRestServerMongooseImpl.h>
+#include <impl/servers/Microservice_IRestServerCivetWebImpl.h>
 #include <impl/servers/Microservice_IMsgQueueServerZmqImpl.h>
 #include <impl/servers/Microservice_IRestServerRMQImpl.h>
 
-cMicroservice_IRestServerMongooseImpl *
-ServerFactory::createIRestServerMongooseImpl(std::string host, int port, int workerThreadsNum) {
-    return new cMicroservice_IRestServerMongooseImpl(new cMicroservice_RestServerParams(port,host,workerThreadsNum));
+cMicroservice_IRestServerCivetWebImpl *
+ServerFactory::createIRestServerCivetWebImpl(std::string host, int port, int workerThreadsNum) {
+    return new cMicroservice_IRestServerCivetWebImpl(new cMicroservice_RestServerParams(port,host,workerThreadsNum));
 }
 
 Microservice_IMsgQueueServerZmqImpl *

src/utils/ServerFactory.h

@@ -8,7 +8,7 @@
 #include <string>
 #include <params/Microservice_Params.h>
 
-class cMicroservice_IRestServerMongooseImpl;
+class cMicroservice_IRestServerCivetWebImpl;
 class Microservice_IMsgQueueServerZmqImpl;
 class cMicroservice_IRestServerRMQImpl;
 
@@ -18,7 +18,7 @@ class cMicroservice_IRestServerRMQImpl;
 class ServerFactory {
 
 public:
-    static cMicroservice_IRestServerMongooseImpl* createIRestServerMongooseImpl(std::string host,
+    static cMicroservice_IRestServerCivetWebImpl* createIRestServerCivetWebImpl(std::string host,
                                                                                 int port,
                                                                                 int workerThreadsNum);
     static Microservice_IMsgQueueServerZmqImpl* createIMsgQueueServerZmqImpl(std::string host,

test/Microservice_ClientTest.cpp

@@ -11,7 +11,7 @@
 #include <Microservice_Client.h>
 #include <params/Microservice_Params.h>
 #include <document.h> //rapidjson
-#include <impl/servers/Microservice_IRestServerMongooseImpl.h>
+#include <impl/servers/Microservice_IRestServerCivetWebImpl.h>
 #include <impl/servers/Microservice_IRestServerRMQImpl.h>
 #include <impl/Microservice_ICacheClientRedisImpl.h>
 #include <impl/clients/MSICommandClientHttpImpl.h>
@@ -24,6 +24,7 @@
 
 #include "impl/Microservices_ILoggerLog4cppImpl.h"
 #include <utils/ClientFactory.h>
+#include <utils/CommonUtils.h>
 
 static const char *const PUBSUBHOST = "zmqpubsub";
 
@@ -197,21 +198,67 @@ using json = nlohmann::json;
 static const int ITERATIONS = 1000000;
 
 
+static const char *const JSON_CONTENT = "{\n"
+                "  \"success\": true,\n"
+                "  \"error\": null,\n"
+                "  \"objectNode\": {\n"
+                "    \"success\": true,\n"
+                "    \"error\": null,\n"
+                "    \"objectNode\": {\n"
+                "      \"num_results\": 6,\n"
+                "      \"query\": \"base\",\n"
+                "      \"results\": [\n"
+                "        {\n"
+                "          \"description\": null,\n"
+                "          \"name\": \"amir/base-server-no-db\"\n"
+                "        },\n"
+                "        {\n"
+                "          \"description\": null,\n"
+                "          \"name\": \"amir/base-server-ui\"\n"
+                "        },\n"
+                "        {\n"
+                "          \"description\": null,\n"
+                "          \"name\": \"amir/base-server-db\"\n"
+                "        },\n"
+                "        {\n"
+                "          \"description\": \"\",\n"
+                "          \"name\": \"ipgallery/base-ims\"\n"
+                "        },\n"
+                "        {\n"
+                "          \"description\": \"\",\n"
+                "          \"name\": \"ipgallery/base-resin\"\n"
+                "        },\n"
+                "        {\n"
+                "          \"description\": \"\",\n"
+                "          \"name\": \"ipgallery/base-microservice-java\"\n"
+                "        }\n"
+                "      ]\n"
+                "    }\n"
+                "  }\n"
+                "}";
+
+static const char *const SOURCE_CHANNEL = "ipc:///tmp/some-file.ipc";
+
+static const char *const URI = "/xxx/resource/subResource";
+
+static const char *const QUERY_STRING = "a=b&c=d&abba=sabba";
+
 void testRapidJson() {
     for (int i = 0; i < ITERATIONS; i++) {
         std::string json;
         rapidjson::Document rpj_Doc; // Null
         rapidjson::Document::AllocatorType &rpj_Alloc = rpj_Doc.GetAllocator();
         rpj_Doc.SetObject();
-        rpj_Doc.AddMember(rapidjson::StringRef("hello"), rapidjson::StringRef("world"), rpj_Alloc);
-        rpj_Doc.AddMember(rapidjson::StringRef("number"), rapidjson::Value(i), rpj_Alloc);
-        rpj_Doc.AddMember(rapidjson::StringRef("status"), true, rpj_Alloc);
-        rpj_Doc.AddMember(rapidjson::StringRef("hello1"), rapidjson::StringRef("world"), rpj_Alloc);
-        rpj_Doc.AddMember(rapidjson::StringRef("number1"), rapidjson::Value(i), rpj_Alloc);
-        rpj_Doc.AddMember(rapidjson::StringRef("status1"), true, rpj_Alloc);
-        rpj_Doc.AddMember(rapidjson::StringRef("hello2"), rapidjson::StringRef("world"), rpj_Alloc);
-        rpj_Doc.AddMember(rapidjson::StringRef("number2"), rapidjson::Value(i), rpj_Alloc);
-        rpj_Doc.AddMember(rapidjson::StringRef("status2"), true, rpj_Alloc);
+        rpj_Doc.AddMember(rapidjson::StringRef("source"), rapidjson::StringRef(SOURCE_CHANNEL), rpj_Alloc);
+        //rpj_Doc.AddMember(rapidjson::StringRef("uri"), rapidjson::Value(i), rpj_Alloc);
+        //rpj_Doc.AddMember(rapidjson::StringRef("status"), true, rpj_Alloc);
+        rpj_Doc.AddMember(rapidjson::StringRef("uri"), rapidjson::StringRef(URI), rpj_Alloc);
+        //rpj_Doc.AddMember(rapidjson::StringRef("number1"), rapidjson::Value(i), rpj_Alloc);
+        //rpj_Doc.AddMember(rapidjson::StringRef("status1"), true, rpj_Alloc);
+        rpj_Doc.AddMember(rapidjson::StringRef("queryString"), rapidjson::StringRef(QUERY_STRING), rpj_Alloc);
+        rpj_Doc.AddMember(rapidjson::StringRef("content"), rapidjson::StringRef(JSON_CONTENT), rpj_Alloc);
+//        rpj_Doc.AddMember(rapidjson::StringRef("number2"), rapidjson::Value(i), rpj_Alloc);
+//        rpj_Doc.AddMember(rapidjson::StringRef("status2"), true, rpj_Alloc);
         rapidjson::StringBuffer buffer;
         rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
         rpj_Doc.Accept(writer);
@@ -223,31 +270,53 @@ void testNlohmanJson() {
     for (int i = 0; i < ITERATIONS; i++) {
         std::string jsonStr;
         json j;
-        j.emplace("hello","world");
-        j.emplace("number", i);
-        j.emplace("status",true);
-        j["hello1"] = "world";
-        j["number1"] =  i;
-        j["status1"] = true;
-        j.emplace("hello2","world");
-        j.emplace("number2", i);
-        j.emplace("status2",true);
+        j.emplace("source",SOURCE_CHANNEL);
+        j.emplace("uri", URI);
+        j.emplace("queryString",QUERY_STRING);
+        j["content"] = JSON_CONTENT;
         jsonStr = j.dump();
     }
 }
 
+#define MAKE_STRING_PAIR(s1,s2) std::make_pair<std::string,std::string>(s1,s2)
+
+void testSerializations() {
+
+    using ParamsMap = std::map<std::string, std::string>;
+
+    ParamsMap paramsMap;
+    const char* strBuff;
+    for (int i = 0; i < ITERATIONS; i++) {
+        paramsMap.emplace(MAKE_STRING_PAIR("source",SOURCE_CHANNEL));
+        paramsMap.emplace(MAKE_STRING_PAIR("uri",URI));
+        paramsMap.emplace(MAKE_STRING_PAIR("queryString",QUERY_STRING));
+        paramsMap.emplace(MAKE_STRING_PAIR("content",JSON_CONTENT));
+        rapidjson::Document doc; // Null
+        rapidjson::Document::AllocatorType &allocator = doc.GetAllocator();
+        doc.SetObject();
+        for (auto& pair : paramsMap)
+            doc.AddMember(
+                    rapidjson::StringRef(pair.first.c_str()),
+                    rapidjson::StringRef(pair.second.c_str()),
+                    allocator);
+        rapidjson::StringBuffer buffer;
+        rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+        doc.Accept(writer);
+        strBuff = buffer.GetString();
+
+    }
+}
+
+
 void testJsons()
 {
-    std::time_t now = std::time(nullptr);
-    testRapidJson();
-    std::cout <<" Testing " << ITERATIONS << " with rapid json took: " << std::time(nullptr) - now << "msec" << '\n';
+    std::cout <<" Testing " << ITERATIONS << " with map serialization json took: " << CommonUtils::measureFunc<>(testSerializations) << "msec" << '\n';
+
+    std::cout <<" Testing " << ITERATIONS << " with rapid json took: " << CommonUtils::measureFunc<>(testRapidJson) << "msec" << '\n';
     if( false or not true){
 
     }
-    // test json-nlohman
-    now = std::time(nullptr);
-    testNlohmanJson();
-    std::cout <<" Testing " << ITERATIONS << " with nlohman json took: " << std::time(nullptr) - now << "msec" << '\n';
+    std::cout <<" Testing " << ITERATIONS << " with nlohman json took: " << CommonUtils::measureFunc<>(testNlohmanJson) << "msec" << '\n';
 
 }
 

test/Microservice_Test.cpp

@@ -11,7 +11,7 @@
 #include <Microservice_Client.h>
 #include <params/Microservice_Params.h>
 #include <document.h> //rapidjson
-#include <impl/servers/Microservice_IRestServerMongooseImpl.h>
+#include <impl/servers/Microservice_IRestServerCivetWebImpl.h>
 #include <impl/servers/Microservice_IMsgQueueServerZmqImpl.h>
 #include <impl/servers/Microservice_IRestServerRMQImpl.h>
 #include <impl/Microservice_ICacheClientRedisImpl.h>
@@ -101,8 +101,8 @@ public:
                 rpj_Doc.AddMember(rapidjson::StringRef(it->first.c_str()),rapidjson::StringRef(dequeIt->c_str()),rpj_Alloc);
             }
         }
-        ReadSync(pc_reqCtx);
-        //ReadAsync2(pc_reqCtx);
+      //  ReadSync(pc_reqCtx);
+        ReadAsync2(pc_reqCtx);
         //this->WriteObjectToResponse(pc_reqCtx,rpj_Doc);
         // add metric
         long value = rand() % 1000 + 1;
@@ -302,7 +302,7 @@ void runNewMS(){
             .addClient(ClientFactory::createHttpImplMsClient("other-service", "localhost", 32010, true, 10, false,"localhost:6379")) //new cMicroservice_Client(new MSICommandClientHttpImpl(),&clientParams))
             .addClient(ClientFactory::createZmqMsgQImp("zmq-service", msApp.name(), 0,
                                                        Microservice_ZMQServerParams::eProtocol::eIpc))
-            .addServer(ServerFactory::createIRestServerMongooseImpl("", 50010, 1))// .addRestServer(new cMicroservice_IRestServerMongooseImpl(new cMicroservice_RestServerParams(50010,"",1)))
+            .addServer(ServerFactory::createIRestServerCivetWebImpl("", 50010, 1))// .addRestServer(new cMicroservice_IRestServerCivetWebImpl(new cMicroservice_RestServerParams(50010,"",1)))
             .addServer(ServerFactory::createIMsgQueueServerZmqImpl(msApp.name(), 0, Microservice_ZMQServerParams::eProtocol::eIpc))
             .addHandler("/xxx",(cMicroservice_BaseHandler*)new cMicroserviceHandler("hello"))
             .addHandler("/zmq",new MSMsgQHandler())

test/Microservice_ZMQTest.cpp

@@ -8,6 +8,7 @@
 #include <iostream>
 #include <common/Microservice_MsgQContext.h>
 #include <thread>
+#include <utils/CommonUtils.h>
 
 static const char *const IPC_FILE1 = "/tmp/service-name1.ipc";
 static const char *const IPC_FILE2 = "/tmp/service-name2.ipc";
@@ -239,7 +240,9 @@ void test_pubsub(zmqpp::context &context) {
 int main(int argc, char *argv[]) {
 
     zmqpp::context context;
-    std::cout << "testing of " << ITERATIONS << " iterations took: " << measure<>::execution(testRequestResponse,context) << " msec" << std::endl;
+//    std::cout << "testing of " << ITERATIONS << " iterations took: " << measure<>::execution(testRequestResponse,context) << " msec" << std::endl;
+    std::cout << "testing of " << ITERATIONS << " iterations took: " << CommonUtils::measureFunc<>(testRequestResponse,context) << " msec" << std::endl;
+
     //testRequestResponse(context);
     //test_pubsub(context);
     //test_Cereal();