Armazenar dados binários com MongoDB e C++

1
#include <mongocxx/client.hpp>
2
#include <bsoncxx/builder/basic/document.hpp>
3
#include <mongocxx/uri.hpp>
4
#include <mongocxx/instance.hpp>
5
6
#include <iostream>
7
#include <fstream>
8
#include <vector>
9
#include <filesystem>
10
11
#define FILE_NAME "name"
12
#define FILE_PATH "path"
13
#define FILE_DATA "data"
14
15
using bsoncxx::builder::basic::kvp; 
16
using bsoncxx::builder::basic::make_document;
17
18
// Upload a file to the collection.
19
bool upload(const std::string& filePath, mongocxx::collection& collection)
20
{
21
    // Open the binary file
22
    std::ifstream file(filePath, std::ios::binary | std::ios::ate);
23
    if (!file) 
24
    {
25
        std::cout << "Failed to open the file: " << filePath << std::endl;
26
        return false;
27
    }
28
29
    // Get the file size.
30
    std::streamsize fileSize = file.tellg();
31
    file.seekg(0, std::ios::beg);
32
33
    // Read the file content into a buffer
34
    std::vector<char> buffer(fileSize);
35
    if (!file.read(buffer.data(), fileSize)) 
36
    {
37
        std::cout << "Failed to read the file: " << filePath << std::endl;
38
        return false;
39
    }
40
41
    // Create the binary object for bsoncxx.
42
    bsoncxx::types::b_binary data{bsoncxx::binary_sub_type::k_binary, static_cast<std::uint32_t>(fileSize), reinterpret_cast<const std::uint8_t*>(buffer.data())};
43
44
    // Create a document with the file name and file content.
45
46
    auto doc = make_document(
47
        kvp(FILE_NAME, std::filesystem::path(filePath).filename()),
48
        kvp(FILE_PATH, filePath),
49
        kvp(FILE_DATA, data));
50
51
    // Insert the document into the collection.
52
    collection.insert_one(doc.view());
53
54
    std::cout << "Upload successful for: " << filePath << std::endl;
55
    return true;
56
}

1
// Download a file from a collection to a given folder.
2
bool download(const std::string& fileName, const std::string& destinationFolder, mongocxx::collection& collection)
3
{
4
    // Create a query to find the file by filename
5
    auto filter = make_document(kvp(FILE_NAME, fileName));
6
7
    // Find the document in the collection
8
    auto result = collection.find_one(filter.view());
9
10
    if (result) 
11
    {
12
        // Get the binary data from the document
13
        bsoncxx::document::view binaryDocView = result->view();
14
        auto binaryData = binaryDocView[FILE_DATA].get_binary();
15
16
        // Create a file to save the binary data
17
        std::ofstream file(destinationFolder + fileName, std::ios::binary);
18
        if (!file) 
19
        {
20
            std::cout << "Failed to create the file: " << fileName << " at " << destinationFolder << std::endl;
21
            return false;
22
        }
23
24
        // Write the binary data to the file
25
        file.write(reinterpret_cast<const char*>(binaryData.bytes), binaryData.size);
26
27
        std::cout << "Download successful for: " << fileName << " at " << destinationFolder << std::endl;
28
        return true;
29
    } 
30
    else 
31
    {
32
        std::cout << "File not found in the collection: " << fileName << std::endl;
33
        return false;
34
    }
35
}

1
int main()
2
{
3
    try
4
    {
5
        auto mongoURIStr = "<Insert MongoDB Connection String>";
6
        static const mongocxx::uri mongoURI = mongocxx::uri{ mongoURIStr };
7
        
8
        // Create an instance.
9
        mongocxx::instance inst{};
10
        
11
        mongocxx::options::client client_options;
12
        auto api = mongocxx::options::server_api{ mongocxx::options::server_api::version::k_version_1 };
13
        client_options.server_api_opts(api);
14
        mongocxx::client conn{ mongoURI, client_options};
15
        
16
        const std::string dbName = "fileStorage";
17
        const std::string collName = "files";
18
        
19
        auto fileStorageDB = conn.database(dbName);
20
        auto filesCollection = fileStorageDB.collection(collName);
21
        // Drop previous data.
22
        filesCollection.drop();
23
24
        // Upload all files in the upload folder.
25
        const std::string uploadFolder = "/Users/bishtr/repos/fileStorage/upload/";
26
        for (const auto & filePath : std::filesystem::directory_iterator(uploadFolder))
27
        {
28
            if(std::filesystem::is_directory(filePath))
29
                continue;
30
31
            if(!upload(filePath.path().string(), filesCollection))
32
            {
33
                std::cout << "Upload failed for: " << filePath.path().string() << std::endl;
34
            }
35
        }
36
37
        // Download files to the download folder.
38
        const std::string downloadFolder = "/Users/bishtr/repos/fileStorage/download/";
39
        
40
        // Search with specific filenames and download it.
41
        const std::string fileName1 = "image-15.jpg", fileName2 = "Hi Seed Shaker 120bpm On Accents.wav";
42
        for ( auto fileName : {fileName1, fileName2} )
43
        {
44
            if (!download(fileName, downloadFolder, filesCollection))
45
            {
46
                std::cout << "Download failed for: " << fileName << std::endl;
47
            } 
48
        }
49
        
50
        // Download all files in the collection.
51
        auto cursor = filesCollection.find({});
52
        for (auto&& doc : cursor) 
53
        {
54
            auto fileName = std::string(doc[FILE_NAME].get_string().value);
55
            if (!download(fileName, downloadFolder, filesCollection))
56
            {
57
                std::cout << "Download failed for: " << fileName << std::endl;
58
            } 
59
        }
60
    }
61
    catch(const std::exception& e)
62
    {
63
        std::cout << "Exception encountered: " << e.what() << std::endl;
64
    }
65
66
    return 0;
67
}