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

@@ -3,4 +3,6 @@
   Using 2 channels push and pull . client send on push and in another thread waits on pull
   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
\ No newline at end of file
+  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);
-        *(mba_BodyBuffer + len) = CNULL;
+          mba_BodyBuffer = (char*)realloc(mba_BodyBuffer,len + 1);
+          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();