258 lines
10 KiB
C++
258 lines
10 KiB
C++
#include <filesystem>
|
|
#include <fstream>
|
|
|
|
#include "controllers/controllers.h"
|
|
#include "dto/dto.h"
|
|
|
|
char windows_invalid_chars[] = "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F<>:\"/\\|";
|
|
|
|
namespace api {
|
|
uint64_t fs::next_temp_id = 0;
|
|
std::unordered_map<std::string, std::string> fs::zip_to_temp_map;
|
|
std::unordered_map<std::string, std::tuple<std::string, uint64_t, uint64_t>> fs::in_progress_zips;
|
|
|
|
std::optional<db::INode> fs::get_node(uint64_t node) {
|
|
db::MapperInode inode_mapper(drogon::app().getDbClient());
|
|
try {
|
|
return inode_mapper.findByPrimaryKey(node);
|
|
} catch (const std::exception&) {
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
std::optional<db::INode> fs::get_node_and_validate(const db::User &user, uint64_t node) {
|
|
auto inode = get_node(node);
|
|
if (!inode.has_value()) return std::nullopt;
|
|
if (inode->getValueOfOwnerId() != user.getValueOfId()) return std::nullopt;
|
|
return inode;
|
|
}
|
|
|
|
std::vector<db::INode> fs::get_children(const db::INode& parent) {
|
|
db::MapperInode inode_mapper(drogon::app().getDbClient());
|
|
return inode_mapper.findBy(db::Criteria(db::INode::Cols::_parent_id, db::CompareOps::EQ, parent.getValueOfId()));
|
|
}
|
|
|
|
std::variant<db::INode, fs::create_node_error, std::tuple<bool, uint64_t>>
|
|
fs::create_node(std::string name, const db::User& owner, bool file, const std::optional<uint64_t> &parent, bool force) {
|
|
// Stolen from https://github.com/boostorg/filesystem/blob/develop/src/portability.cpp
|
|
if (!force)
|
|
if (name.empty() || name[0] == ' ' || name.find_first_of(windows_invalid_chars, 0, sizeof(windows_invalid_chars)) != std::string::npos || *(name.end() - 1) == ' ' || *(name.end() - 1) == '.' || name == "." || name == "..")
|
|
return {create_node_error::INVALID_NAME};
|
|
|
|
db::INode node;
|
|
node.setIsFile(file ? 1 : 0);
|
|
node.setName(name);
|
|
node.setOwnerId(owner.getValueOfId());
|
|
node.setHasPreview(0);
|
|
if (parent.has_value()) {
|
|
auto parent_node = get_node_and_validate(owner, *parent);
|
|
if (!parent_node.has_value())
|
|
return {create_node_error::INVALID_PARENT};
|
|
if (parent_node->getValueOfIsFile() != 0)
|
|
return {create_node_error::FILE_PARENT};
|
|
auto children = get_children(*parent_node);
|
|
for (const auto& child : children)
|
|
if (child.getValueOfName() == name)
|
|
return {std::make_tuple(
|
|
child.getValueOfIsFile() != 0,
|
|
child.getValueOfId()
|
|
)};
|
|
node.setParentId(*parent);
|
|
}
|
|
db::MapperInode inode_mapper(drogon::app().getDbClient());
|
|
inode_mapper.insert(node);
|
|
return {node};
|
|
}
|
|
|
|
void fs::delete_node(db::INode node, msd::channel<std::string>& chan, bool allow_root) {
|
|
if (node.getValueOfParentId() == 0 && (!allow_root)) return;
|
|
|
|
db::MapperInode inode_mapper(drogon::app().getDbClient());
|
|
|
|
const auto delete_file = [&chan, &inode_mapper](const db::INode& node) {
|
|
std::string entry = "Deleting ";
|
|
generate_path(node, entry);
|
|
entry >> chan;
|
|
std::filesystem::path p("./files");
|
|
p /= std::to_string(node.getValueOfId());
|
|
std::filesystem::remove(p);
|
|
if (node.getValueOfHasPreview() != 0)
|
|
std::filesystem::remove(p.string() + "_preview.png");
|
|
inode_mapper.deleteOne(node);
|
|
std::string(" Done\n") >> chan;
|
|
};
|
|
|
|
std::stack<db::INode> queue, files, folders;
|
|
|
|
if (node.getValueOfIsFile() == 0) queue.push(node);
|
|
else files.push(node);
|
|
|
|
while (!queue.empty()) {
|
|
while (!files.empty()) {
|
|
delete_file(files.top());
|
|
files.pop();
|
|
}
|
|
std::string entry = "Deleting ";
|
|
generate_path(queue.top(), entry);
|
|
entry += "\n";
|
|
entry >> chan;
|
|
auto children = get_children(queue.top());
|
|
folders.push(queue.top());
|
|
queue.pop();
|
|
for (const auto& child : children) {
|
|
if (child.getValueOfIsFile() == 0) queue.push(child);
|
|
else files.push(child);
|
|
}
|
|
}
|
|
|
|
while (!files.empty()) {
|
|
delete_file(files.top());
|
|
files.pop();
|
|
}
|
|
|
|
while (!folders.empty()) {
|
|
inode_mapper.deleteOne(folders.top());
|
|
folders.pop();
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<std::shared_mutex> fs::get_user_mutex(uint64_t user_id) {
|
|
static std::unordered_map<uint64_t, std::shared_ptr<std::shared_mutex>> mutexes;
|
|
static std::mutex mutexes_mutex;
|
|
std::lock_guard guard(mutexes_mutex);
|
|
return (*mutexes.try_emplace(user_id, std::make_shared<std::shared_mutex>()).first).second;
|
|
}
|
|
|
|
trantor::EventLoop* fs::get_zip_loop() {
|
|
static bool init_done = false;
|
|
static trantor::EventLoopThread loop("ZipEventLoop");
|
|
if (!init_done) {
|
|
init_done = true;
|
|
loop.run();
|
|
loop.getLoop()->runEvery(30*60, []{
|
|
for (const auto& entry : std::filesystem::directory_iterator("./temp")) {
|
|
if (!entry.is_regular_file()) continue;
|
|
const std::string file_name = "./temp/" + entry.path().filename().string();
|
|
const auto& progress_pos = std::find_if(in_progress_zips.begin(), in_progress_zips.end(),
|
|
[&file_name](const std::pair<std::string, std::tuple<std::string, uint64_t, uint64_t>>& entry) {
|
|
return std::get<0>(entry.second) == file_name;
|
|
}
|
|
);
|
|
if (progress_pos != in_progress_zips.end()) return;
|
|
const auto& zip_map_pos = std::find_if(zip_to_temp_map.begin(), zip_to_temp_map.end(),
|
|
[&file_name](const std::pair<std::string, std::string>& entry){
|
|
return entry.second == file_name;
|
|
}
|
|
);
|
|
if (zip_map_pos != zip_to_temp_map.end()) return;
|
|
std::filesystem::remove(entry.path());
|
|
}
|
|
});
|
|
}
|
|
return loop.getLoop();
|
|
}
|
|
|
|
trantor::EventLoop* fs::get_delete_loop() {
|
|
static bool init_done = false;
|
|
static trantor::EventLoopThread loop("DeleteEventLoop");
|
|
if (!init_done) {
|
|
init_done = true;
|
|
loop.run();
|
|
}
|
|
return loop.getLoop();
|
|
}
|
|
|
|
void fs::generate_path(db::INode node, std::string& str) {
|
|
db::MapperInode inode_mapper(drogon::app().getDbClient());
|
|
std::stack<db::INode> path;
|
|
path.push(node);
|
|
while (node.getParentId() != nullptr) {
|
|
node = inode_mapper.findByPrimaryKey(node.getValueOfParentId());
|
|
path.push(node);
|
|
}
|
|
while (!path.empty()) {
|
|
const db::INode& seg = path.top();
|
|
str += seg.getValueOfName();
|
|
if (seg.getValueOfIsFile() == 0) str += "/";
|
|
path.pop();
|
|
}
|
|
}
|
|
|
|
Json::Value fs::generate_path(db::INode node) {
|
|
Json::Value segments = Json::Value(Json::ValueType::arrayValue);
|
|
db::MapperInode inode_mapper(drogon::app().getDbClient());
|
|
std::stack<db::INode> path;
|
|
path.push(node);
|
|
while (node.getParentId() != nullptr) {
|
|
node = inode_mapper.findByPrimaryKey(node.getValueOfParentId());
|
|
path.push(node);
|
|
}
|
|
while (!path.empty()) {
|
|
const db::INode& seg = path.top();
|
|
if (seg.getParentId() == nullptr) {
|
|
Json::Value json_seg;
|
|
json_seg["path"] = "/";
|
|
json_seg["node"] = seg.getValueOfId();
|
|
segments.append(json_seg);
|
|
} else {
|
|
Json::Value json_seg;
|
|
json_seg["path"] = seg.getValueOfName();
|
|
json_seg["node"] = seg.getValueOfId();
|
|
segments.append(json_seg);
|
|
if (seg.getValueOfIsFile() == 0) {
|
|
json_seg.removeMember("node");
|
|
json_seg["path"] = "/";
|
|
segments.append(json_seg);
|
|
}
|
|
}
|
|
path.pop();
|
|
}
|
|
Json::Value resp;
|
|
resp["segments"] = segments;
|
|
return resp;
|
|
}
|
|
|
|
uint64_t fs::calc_total_size(const db::INode& base) {
|
|
uint64_t size = 0;
|
|
std::stack<db::INode> queue;
|
|
queue.push(base);
|
|
while (!queue.empty()) {
|
|
const db::INode& node = queue.top();
|
|
if (node.getValueOfIsFile() == 0) {
|
|
auto children = api::fs::get_children(node);
|
|
queue.pop();
|
|
for (const auto& child : children) {
|
|
if (child.getValueOfIsFile() == 0) queue.push(child);
|
|
else if (child.getSize()) size += child.getValueOfSize();
|
|
}
|
|
} else {
|
|
size += node.getValueOfSize();
|
|
queue.pop();
|
|
}
|
|
}
|
|
return size;
|
|
}
|
|
|
|
void fs::add_to_zip(struct zip_t* zip, const std::string& key, const db::INode& node, const std::string& path) {
|
|
if (node.getValueOfIsFile() == 0) {
|
|
std::string new_path = path + node.getValueOfName() + "/";
|
|
zip_entry_opencasesensitive(zip, new_path.c_str());
|
|
zip_entry_close(zip);
|
|
auto children = api::fs::get_children(node);
|
|
for (const auto& child : children)
|
|
add_to_zip(zip, key, child, new_path);
|
|
} else {
|
|
zip_entry_opencasesensitive(zip, (path + node.getValueOfName()).c_str());
|
|
std::ifstream file("./files/" + std::to_string(node.getValueOfId()), std::ifstream::binary);
|
|
std::vector<char> buffer(64*1024);
|
|
while (!file.eof()) {
|
|
file.read(buffer.data(), (std::streamsize)buffer.size());
|
|
auto read = file.gcount();
|
|
zip_entry_write(zip, buffer.data(), read);
|
|
std::get<1>(in_progress_zips[key]) += read;
|
|
}
|
|
zip_entry_close(zip);
|
|
}
|
|
}
|
|
}
|