Parse JSON string in HTTP request body

Author: varunsh-xilinx

src/proteus/clients/http_internal.cpp

@@ -543,53 +543,54 @@ drogon::HttpResponsePtr errorHttpResponse(const std::string &error,
   return resp;
 }
 
-DrogonHttp::DrogonHttp(const drogon::HttpRequestPtr &req,
-                       DrogonCallback callback) {
-  this->req_ = req;
-  this->callback_ = std::move(callback);
-  this->type_ = InterfaceType::kDrogonHttp;
-  this->json_ = nullptr;
-}
-
-void DrogonHttp::setJson() {
+std::shared_ptr<Json::Value> parseJson(const drogon::HttpRequest *req) {
 #ifdef PROTEUS_ENABLE_LOGGING
-  const auto &logger = this->getLogger();
+  Logger logger{Loggers::kServer};
 #endif
-  const auto &json_raw = this->req_->getJsonObject();
-
-  // if we fail to get the JSON object, return
-  if (json_raw == nullptr) {
-    auto root = std::make_shared<Json::Value>();
-    std::string errors;
-    Json::CharReaderBuilder builder;
-    Json::CharReader *reader = builder.newCharReader();
-    auto body = this->req_->getBody();
-    auto body_parsed = z_decompress(body.data(), body.length());
-    if (body_parsed.empty()) {
-      this->callback_(errorHttpResponse("Failed attempt to inflate request",
-                                        HttpStatusCode::k400BadRequest));
-      return;
-    }
-    bool parsingSuccessful =
-      reader->parse(body_parsed.data(), body_parsed.data() + body_parsed.size(),
-                    root.get(), &errors);
-    if (!parsingSuccessful) {
-      this->callback_(errorHttpResponse("Failed to parse JSON request",
-                                        HttpStatusCode::k400BadRequest));
-      return;
-    }
-    PROTEUS_LOG_INFO(logger, "Successfully inflated request");
-    this->json_ = std::move(root);
-  } else {
-    this->json_ = json_raw;
+
+  // attempt to get the JSON object directly first
+  const auto &json_obj = req->getJsonObject();
+  if (json_obj != nullptr) {
+    return json_obj;
   }
-}
 
-size_t DrogonHttp::getInputSize() {
-  if (this->json_ == nullptr) {
-    this->setJson();
+  PROTEUS_LOG_DEBUG(logger, "Failed to get JSON data directly");
+
+  // if it's not valid, then we need to attempt to parse the body
+  auto root = std::make_shared<Json::Value>();
+
+  std::string errors;
+  Json::CharReaderBuilder builder;
+  Json::CharReader *reader = builder.newCharReader();
+  auto body = req->getBody();
+  bool success =
+    reader->parse(body.data(), body.data() + body.size(), root.get(), &errors);
+  if (success) {
+    return root;
+  }
+
+  PROTEUS_LOG_DEBUG(logger, "Failed to interpret body as JSON data");
+
+  // if it's still not valid, attempt to uncompress the body and convert to JSON
+  auto body_decompress = z_decompress(body.data(), body.length());
+  success = reader->parse(body_decompress.data(),
+                          body_decompress.data() + body_decompress.size(),
+                          root.get(), &errors);
+  if (success) {
+    return root;
   }
 
+  throw std::invalid_argument("Failed to interpret request body as JSON");
+}
+
+DrogonHttp::DrogonHttp(const drogon::HttpRequestPtr &req,
+                       DrogonCallback callback)
+  : req_(req), callback_(std::move(callback)) {
+  this->type_ = InterfaceType::kDrogonHttp;
+  this->json_ = parseJson(req.get());
+}
+
+size_t DrogonHttp::getInputSize() {
   if (!this->json_->isMember("inputs")) {
     throw std::invalid_argument("No 'inputs' key present in request");
   }

src/proteus/clients/http_internal.hpp

@@ -106,9 +106,6 @@ class DrogonHttp : public Interface {
   void errorHandler(const std::invalid_argument &e) override;
 
  private:
-  /// parse the request's JSON payload and save it for future use
-  void setJson();
-
   drogon::HttpRequestPtr req_;
   DrogonCallback callback_;
   std::shared_ptr<Json::Value> json_;

src/proteus/servers/http_server.cpp

@@ -258,7 +258,18 @@ void v2::ProteusHttpServer::inferModel(
     return;
   }
 
-  auto request = std::make_unique<DrogonHttp>(req, std::move(callback));
+  std::unique_ptr<DrogonHttp> request;
+  try {
+    request = std::make_unique<DrogonHttp>(req, std::move(callback));
+  } catch (const std::invalid_argument &e) {
+    PROTEUS_LOG_INFO(logger_, e.what());
+    auto resp = errorHttpResponse(e.what(), HttpStatusCode::k400BadRequest);
+#ifdef PROTEUS_ENABLE_TRACING
+    auto context = trace->propagate();
+    propagate(resp.get(), context);
+#endif
+    callback(resp);
+  }
 #ifdef PROTEUS_ENABLE_METRICS
   request->set_time(now);
 #endif