17455418213

Committed 04 Sep 2025 06:31AM UTC coverage: 56.582% (+0.4%) from 56.202%

Build # 17455418213

Build Type

Pull #8

github

Committed by

web-flow

Commit Message

Merge f5b79205b into 8bb319120

Pull Request Pull Request #8: add snapshot

Coverage Stats

1423 of 3382 branches covered (42.08%)

Branch coverage included in aggregate %.

53 of 79 new or added lines in 9 files covered. (67.09%)

3 existing lines in 2 files now uncovered.

1689 of 2118 relevant lines covered (79.75%)

434.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

54.25

/src/deva/deva.cc

#include "deva/deva.h"
#include <pain/base/plog.h>
#include <pain/base/uuid.h>
#include "deva/macro.h"

#define DEVA_METHOD(name)                                                                                              \
    Status Deva::name([[maybe_unused]] int32_t version,                                                                \
                      [[maybe_unused]] const pain::proto::deva::store::name##Request* request,                         \
                      [[maybe_unused]] pain::proto::deva::store::name##Response* response,                             \
                      [[maybe_unused]] int64_t index)

namespace pain::deva {

Status Deva::create(const std::string& path, const UUID& id, FileType type) {
    SPAN(span);
    PLOG_DEBUG(("desc", "create")("path", path)("id", id.str())("type", type));
    // get parent
    std::filesystem::path file_path(path);
    auto dir = file_path.parent_path();
    auto filename = file_path.filename();
    auto file_type = FileType::kFile;
    UUID parent_dir_uuid;
    auto status = _namespace.lookup(dir.c_str(), &parent_dir_uuid, &file_type);
    if (!status.ok()) {
        return status;
    }

    if (file_type != FileType::kDirectory) {
        return Status(EINVAL, fmt::format("{} is not a directory", dir.c_str()));
    }

    UUID file_uuid(id.high(), id.low());
    status = _namespace.create(parent_dir_uuid, filename, type, file_uuid);
    if (!status.ok()) {
        return status;
    }

    return Status::OK();
}

DEVA_METHOD(CreateFile) {
    SPAN(span);
    PLOG_DEBUG(("desc", "create_file")("version", version)("index", index)("request", request->DebugString()));
    auto& path = request->path();
    auto& file_id = request->file_id();
    UUID file_uuid(file_id.high(), file_id.low());
    auto status = create(path, file_uuid, FileType::kFile);
    if (!status.ok()) {
        return status;
    }
    auto file_info = response->mutable_file_info();
    file_info->mutable_file_id()->set_high(file_uuid.high());
    file_info->mutable_file_id()->set_low(file_uuid.low());
    file_info->set_type(pain::proto::FileType::FILE_TYPE_FILE);
    file_info->set_size(0);
    file_info->set_atime(request->atime());
    file_info->set_mtime(request->mtime());
    file_info->set_ctime(request->ctime());
    file_info->set_mode(request->mode());
    file_info->set_uid(request->uid());
    file_info->set_gid(request->gid());
    _file_infos[file_uuid] = *file_info;
    return Status::OK();
}

DEVA_METHOD(CreateDir) {
    SPAN(span);
    PLOG_DEBUG(("desc", "create_dir")("version", version)("index", index)("request", request->DebugString()));
    auto& path = request->path();
    auto& dir_id = request->dir_id();
    UUID dir_uuid(dir_id.high(), dir_id.low());
    auto status = create(path, dir_uuid, FileType::kDirectory);
    if (!status.ok()) {
        return status;
    }
    auto file_info = response->mutable_file_info();
    file_info->mutable_file_id()->set_high(dir_uuid.high());
    file_info->mutable_file_id()->set_low(dir_uuid.low());
    file_info->set_type(pain::proto::FileType::FILE_TYPE_DIRECTORY);
    file_info->set_size(0);
    file_info->set_atime(request->atime());
    file_info->set_mtime(request->mtime());
    file_info->set_ctime(request->ctime());
    file_info->set_mode(request->mode());
    file_info->set_uid(request->uid());
    file_info->set_gid(request->gid());
    _file_infos[dir_uuid] = *file_info;
    return Status::OK();
}

DEVA_METHOD(ReadDir) {
    SPAN(span);
    PLOG_DEBUG(("desc", "read_dir")("version", version)("index", index)("request", request->DebugString()));
    auto& path = request->path();
    UUID parent_dir_uuid;
    FileType file_type = FileType::kNone;
    auto status = _namespace.lookup(path.c_str(), &parent_dir_uuid, &file_type);
    if (!status.ok()) {
        return status;
    }
    if (file_type != FileType::kDirectory) {
        return Status(EINVAL, fmt::format("{} is not a directory", path.c_str()));
    }
    std::list<DirEntry> entries;
    _namespace.list(parent_dir_uuid, &entries);
    for (auto& entry : entries) {
        auto dir_entry = response->add_entries();
        dir_entry->mutable_file_id()->set_high(entry.inode.high());
        dir_entry->mutable_file_id()->set_low(entry.inode.low());
        dir_entry->set_type(static_cast<pain::proto::FileType>(entry.type));
        dir_entry->set_name(std::move(entry.name));
    }
    return Status::OK();
}

DEVA_METHOD(RemoveFile) {
    SPAN(span);
    PLOG_INFO(("desc", "remove_file")("version", version)("index", index));
    return Status::OK();
}

DEVA_METHOD(SealFile) {
    SPAN(span);
    PLOG_INFO(("desc", "seal_file")("version", version)("index", index));
    return Status::OK();
}

DEVA_METHOD(CreateChunk) {
    SPAN(span);
    PLOG_INFO(("desc", "remove")("version", version)("index", index));
    return Status::OK();
}

DEVA_METHOD(CheckInChunk) {
    SPAN(span);
    PLOG_INFO(("desc", "seal")("version", version)("index", index));
    return Status::OK();
}

DEVA_METHOD(SealChunk) {
    SPAN(span);
    PLOG_INFO(("desc", "create_chunk")("version", version)("index", index));
    return Status::OK();
}

DEVA_METHOD(SealAndNewChunk) {
    SPAN(span);
    PLOG_INFO(("desc", "remove_chunk")("version", version)("index", index));
    return Status::OK();
}

Status Deva::save_snapshot(std::string_view path, std::vector<std::string>* files) {
    return _store->check_point(path.data(), files);
}

Status Deva::load_snapshot(std::string_view path) {
    return _store->recover(path.data());
}

} // namespace pain::deva

1	#include "deva/deva.h"
2	#include <pain/base/plog.h>
3	#include <pain/base/uuid.h>
4	#include "deva/macro.h"
5
6	#define DEVA_METHOD(name) \
7	Status Deva::name([[maybe_unused]] int32_t version, \
8	[[maybe_unused]] const pain::proto::deva::store::name##Request* request, \
9	[[maybe_unused]] pain::proto::deva::store::name##Response* response, \
10	[[maybe_unused]] int64_t index)
11
12	namespace pain::deva {
13
14	Status Deva::create(const std::string& path, const UUID& id, FileType type) {	74✔
15	SPAN(span);	369!
16	PLOG_DEBUG(("desc", "create")("path", path)("id", id.str())("type", type));	74✔
17	// get parent
18	std::filesystem::path file_path(path);	74!
19	auto dir = file_path.parent_path();	74!
20	auto filename = file_path.filename();	74!
21	auto file_type = FileType::kFile;	74✔
22	UUID parent_dir_uuid;	74✔
23	auto status = _namespace.lookup(dir.c_str(), &parent_dir_uuid, &file_type);	73!
24	if (!status.ok()) {	74✔
25	return status;	2!
26	}
27
28	if (file_type != FileType::kDirectory) {	72!
29	return Status(EINVAL, fmt::format("{} is not a directory", dir.c_str()));	×
30	}
31
32	UUID file_uuid(id.high(), id.low());	72✔
33	status = _namespace.create(parent_dir_uuid, filename, type, file_uuid);	72!
34	if (!status.ok()) {	74!
35	return status;	×
36	}
37
38	return Status::OK();	74✔
39	}	218✔
40
41	DEVA_METHOD(CreateFile) {	36✔
42	SPAN(span);	183!
43	PLOG_DEBUG(("desc", "create_file")("version", version)("index", index)("request", request->DebugString()));	37✔
44	auto& path = request->path();	37!
45	auto& file_id = request->file_id();	37!
46	UUID file_uuid(file_id.high(), file_id.low());	37!
47	auto status = create(path, file_uuid, FileType::kFile);	37!
48	if (!status.ok()) {	37!
UNCOV 49	return status;	×
50	}
51	auto file_info = response->mutable_file_info();	37!
52	file_info->mutable_file_id()->set_high(file_uuid.high());	37!
53	file_info->mutable_file_id()->set_low(file_uuid.low());	37!
54	file_info->set_type(pain::proto::FileType::FILE_TYPE_FILE);	37!
55	file_info->set_size(0);	37!
56	file_info->set_atime(request->atime());	37!
57	file_info->set_mtime(request->mtime());	37!
58	file_info->set_ctime(request->ctime());	37!
59	file_info->set_mode(request->mode());	37!
60	file_info->set_uid(request->uid());	37!
61	file_info->set_gid(request->gid());	37!
62	_file_infos[file_uuid] = *file_info;	37!
63	return Status::OK();	37✔
64	}	111✔
65
66	DEVA_METHOD(CreateDir) {	37✔
67	SPAN(span);	184!
68	PLOG_DEBUG(("desc", "create_dir")("version", version)("index", index)("request", request->DebugString()));	36✔
69	auto& path = request->path();	37!
70	auto& dir_id = request->dir_id();	37!
71	UUID dir_uuid(dir_id.high(), dir_id.low());	37!
72	auto status = create(path, dir_uuid, FileType::kDirectory);	37!
73	if (!status.ok()) {	37!
UNCOV 74	return status;	×
75	}
76	auto file_info = response->mutable_file_info();	37!
77	file_info->mutable_file_id()->set_high(dir_uuid.high());	37!
78	file_info->mutable_file_id()->set_low(dir_uuid.low());	37!
79	file_info->set_type(pain::proto::FileType::FILE_TYPE_DIRECTORY);	37!
80	file_info->set_size(0);	37!
81	file_info->set_atime(request->atime());	37!
82	file_info->set_mtime(request->mtime());	37!
83	file_info->set_ctime(request->ctime());	37!
84	file_info->set_mode(request->mode());	37!
85	file_info->set_uid(request->uid());	37!
86	file_info->set_gid(request->gid());	37!
87	_file_infos[dir_uuid] = *file_info;	37!
88	return Status::OK();	37✔
89	}	111✔
90
91	DEVA_METHOD(ReadDir) {	2✔
92	SPAN(span);	10!
93	PLOG_DEBUG(("desc", "read_dir")("version", version)("index", index)("request", request->DebugString()));	2✔
94	auto& path = request->path();	2!
95	UUID parent_dir_uuid;	2✔
96	FileType file_type = FileType::kNone;	2✔
97	auto status = _namespace.lookup(path.c_str(), &parent_dir_uuid, &file_type);	2!
98	if (!status.ok()) {	2!
99	return status;	×
100	}
101	if (file_type != FileType::kDirectory) {	2!
102	return Status(EINVAL, fmt::format("{} is not a directory", path.c_str()));	×
103	}
104	std::list<DirEntry> entries;	2✔
105	_namespace.list(parent_dir_uuid, &entries);	2!
106	for (auto& entry : entries) {	23✔
107	auto dir_entry = response->add_entries();	21!
108	dir_entry->mutable_file_id()->set_high(entry.inode.high());	21!
109	dir_entry->mutable_file_id()->set_low(entry.inode.low());	21!
110	dir_entry->set_type(static_cast<pain::proto::FileType>(entry.type));	21!
111	dir_entry->set_name(std::move(entry.name));	21✔
112	}
113	return Status::OK();	2✔
114	}	6✔
115
116	DEVA_METHOD(RemoveFile) {	×
117	SPAN(span);	×
118	PLOG_INFO(("desc", "remove_file")("version", version)("index", index));	×
119	return Status::OK();	×
120	}	×
121
122	DEVA_METHOD(SealFile) {	×
123	SPAN(span);	×
124	PLOG_INFO(("desc", "seal_file")("version", version)("index", index));	×
125	return Status::OK();	×
126	}	×
127
128	DEVA_METHOD(CreateChunk) {	×
129	SPAN(span);	×
130	PLOG_INFO(("desc", "remove")("version", version)("index", index));	×
131	return Status::OK();	×
132	}	×
133
134	DEVA_METHOD(CheckInChunk) {	×
135	SPAN(span);	×
136	PLOG_INFO(("desc", "seal")("version", version)("index", index));	×
137	return Status::OK();	×
138	}	×
139
140	DEVA_METHOD(SealChunk) {	×
141	SPAN(span);	×
142	PLOG_INFO(("desc", "create_chunk")("version", version)("index", index));	×
143	return Status::OK();	×
144	}	×
145
146	DEVA_METHOD(SealAndNewChunk) {	×
147	SPAN(span);	×
148	PLOG_INFO(("desc", "remove_chunk")("version", version)("index", index));	×
149	return Status::OK();	×
150	}	×
151
152	Status Deva::save_snapshot(std::string_view path, std::vector<std::string>* files) {	4✔
153	return _store->check_point(path.data(), files);	4✔
154	}
155
156	Status Deva::load_snapshot(std::string_view path) {	3✔
157	return _store->recover(path.data());	3✔
158	}
159
160	} // namespace pain::deva

paticcaa / pain / 17455418213

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous