Added option to create UploadFile from data in memory (#2484)

Author: betsch85

lib/inc/drogon/UploadFile.h

@@ -56,6 +56,27 @@ class UploadFile
         }
     }
 
+    /// Constructor
+    /**
+     * @param data Pointer to the data
+     * @param len Data length in bytes
+     * @param fileName The file name provided to the server.
+     * @param itemName The item name on the browser form.
+     * @param contentType The Mime content type for the part
+     */
+    explicit UploadFile(const void *data,
+                        const size_t len,
+                        const std::string &fileName = "memory.bin",
+                        const std::string &itemName = "file",
+                        ContentType contentType = CT_APPLICATION_OCTET_STREAM)
+        : data_(data),
+          len_(len),
+          fileName_(fileName),
+          itemName_(itemName),
+          contentType_(contentType)
+    {
+    }
+
     const std::string &path() const
     {
         return path_;
@@ -76,7 +97,19 @@ class UploadFile
         return contentType_;
     }
 
+    const void *data() const
+    {
+        return data_;
+    }
+
+    const size_t dataLength() const
+    {
+        return len_;
+    }
+
   private:
+    const void *data_ = nullptr;
+    size_t len_ = 0;
     std::string path_;
     std::string fileName_;
     std::string itemName_;

lib/src/HttpRequestImpl.cc

@@ -323,21 +323,31 @@ void HttpRequestImpl::appendToBuffer(trantor::MsgBuffer *output) const
                     content.append(type.data(), type.length());
                 }
                 content.append("\r\n\r\n");
-                std::ifstream infile(utils::toNativePath(file.path()),
-                                     std::ifstream::binary);
-                if (!infile)
+
+                if (file.data() && file.dataLength() > 0)
                 {
-                    LOG_ERROR << file.path() << " not found";
+                    content.append((const char *)file.data(),
+                                   file.dataLength());
                 }
                 else
                 {
-                    std::streambuf *pbuf = infile.rdbuf();
-                    std::streamsize filesize = pbuf->pubseekoff(0, infile.end);
-                    pbuf->pubseekoff(0, infile.beg);  // rewind
-                    std::string str;
-                    str.resize(filesize);
-                    pbuf->sgetn(&str[0], filesize);
-                    content.append(std::move(str));
+                    std::ifstream infile(utils::toNativePath(file.path()),
+                                         std::ifstream::binary);
+                    if (!infile)
+                    {
+                        LOG_ERROR << file.path() << " not found";
+                    }
+                    else
+                    {
+                        std::streambuf *pbuf = infile.rdbuf();
+                        std::streamsize filesize =
+                            pbuf->pubseekoff(0, infile.end);
+                        pbuf->pubseekoff(0, infile.beg);  // rewind
+                        std::string str;
+                        str.resize(filesize);
+                        pbuf->sgetn(&str[0], filesize);
+                        content.append(std::move(str));
+                    }
                 }
                 content.append("\r\n");
             }

lib/tests/integration_test/client/main.cc

@@ -728,6 +728,23 @@ void doTest(const HttpClientPtr &client, std::shared_ptr<test::Case> TEST_CTX)
                             CHECK((*json)["P2"] == "test");
                         });
 
+    // Test file upload from memory
+    auto hello = std::make_shared<std::string>("hello world!");
+    UploadFile memfile(hello->data(),
+                       hello->length(),
+                       "hello_world.txt",
+                       "hellofile",
+                       ContentType::CT_TEXT_PLAIN);
+    req = HttpRequest::newFileUploadRequest({memfile});
+    req->setPath("/api/attachment/uploadMemory");
+    client->sendRequest(req,
+                        [req, TEST_CTX, hello](ReqResult result,
+                                               const HttpResponsePtr &resp) {
+                            REQUIRE(result == ReqResult::Ok);
+                            REQUIRE(resp->contentType() == CT_TEXT_PLAIN);
+                            CHECK(resp->getBody() == *hello);
+                        });
+
     // Test newFileResponse
     req = HttpRequest::newHttpRequest();
     req->setPath("/RangeTestController/");

lib/tests/integration_test/server/api_Attachment.cc

@@ -103,6 +103,32 @@ void Attachment::uploadImage(
     callback(resp);
 }
 
+void Attachment::uploadMemory(
+    const HttpRequestPtr &req,
+    std::function<void(const HttpResponsePtr &)> &&callback)
+{
+    MultiPartParser fileUpload;
+
+    if (fileUpload.parse(req) == 0 && fileUpload.getFiles().size() == 1)
+    {
+        auto &file = fileUpload.getFiles()[0];
+        if (file.getItemName() == "hellofile")
+        {
+            auto resp = HttpResponse::newHttpResponse();
+            resp->setStatusCode(HttpStatusCode::k200OK);
+            resp->setContentTypeCode(ContentType::CT_TEXT_PLAIN);
+            std::string hello = std::string(file.fileData(), file.fileLength());
+            resp->setBody(std::move(hello));
+            callback(resp);
+            return;
+        }
+    }
+    LOG_DEBUG << "upload text from memory error!";
+    auto resp = HttpResponse::newHttpResponse();
+    resp->setStatusCode(HttpStatusCode::k400BadRequest);
+    callback(resp);
+}
+
 void Attachment::download(
     const HttpRequestPtr &req,
     std::function<void(const HttpResponsePtr &)> &&callback)

lib/tests/integration_test/server/api_Attachment.h

@@ -12,6 +12,7 @@ class Attachment : public drogon::HttpController<Attachment>
     METHOD_ADD(Attachment::get, "", Get);  // Path is '/api/attachment'
     METHOD_ADD(Attachment::upload, "/upload", Post);
     METHOD_ADD(Attachment::uploadImage, "/uploadImage", Post);
+    METHOD_ADD(Attachment::uploadMemory, "/uploadMemory", Post);
     METHOD_ADD(Attachment::download, "/download", Get);
     METHOD_LIST_END
     // your declaration of processing function maybe like this:
@@ -21,6 +22,8 @@ class Attachment : public drogon::HttpController<Attachment>
                 std::function<void(const HttpResponsePtr &)> &&callback);
     void uploadImage(const HttpRequestPtr &req,
                      std::function<void(const HttpResponsePtr &)> &&callback);
+    void uploadMemory(const HttpRequestPtr &req,
+                      std::function<void(const HttpResponsePtr &)> &&callback);
     void download(const HttpRequestPtr &req,
                   std::function<void(const HttpResponsePtr &)> &&callback);
 };