From: Joel Rosdahl Date: Thu, 9 Dec 2021 20:10:10 +0000 (+0100) Subject: enhance: Add Result::write_data method X-Git-Tag: v4.6~66 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6dd3064795885f9d1b2c8fd914ed1e9e8eda407d;p=thirdparty%2Fccache.git enhance: Add Result::write_data method --- diff --git a/src/Result.cpp b/src/Result.cpp index 24a0dbe8e..f03e6d152 100644 --- a/src/Result.cpp +++ b/src/Result.cpp @@ -308,9 +308,15 @@ Writer::Writer(Context& ctx, const std::string& result_path) } void -Writer::write(FileType file_type, const std::string& file_path) +Writer::write_data(const FileType file_type, const std::string& data) { - m_entries_to_write.emplace_back(file_type, file_path); + m_entries_to_write.push_back(Entry{file_type, ValueType::data, data}); +} + +void +Writer::write_file(const FileType file_type, const std::string& path) +{ + m_entries_to_write.push_back(Entry{file_type, ValueType::path, path}); } nonstd::expected @@ -330,14 +336,14 @@ Writer::do_finalize() uint64_t payload_size = 0; payload_size += 1; // format_ver payload_size += 1; // n_entries - for (const auto& pair : m_entries_to_write) { - const auto& path = pair.second; - auto st = Stat::stat(path, Stat::OnError::throw_error); - - payload_size += 1; // embedded_file_marker - payload_size += 1; // embedded_file_type - payload_size += 8; // data_len - payload_size += st.size(); // data + for (const auto& entry : m_entries_to_write) { + payload_size += 1; // embedded_file_marker + payload_size += 1; // embedded_file_type + payload_size += 8; // data_len + payload_size += // data + entry.value_type == ValueType::data + ? entry.value.size() + : Stat::stat(entry.value, Stat::OnError::throw_error).size(); } AtomicFile atomic_result_file(m_result_path, AtomicFile::Mode::binary); @@ -356,30 +362,35 @@ Writer::do_finalize() writer.write_int(m_entries_to_write.size()); uint32_t entry_number = 0; - for (const auto& pair : m_entries_to_write) { - const auto file_type = pair.first; - const auto& path = pair.second; - LOG("Storing result file {}", path); - - const bool store_raw = should_store_raw_file(m_ctx.config, file_type); - uint64_t file_size = Stat::stat(path, Stat::OnError::throw_error).size(); - - LOG("Storing {} file #{} {} ({} bytes) from {}", + for (const auto& entry : m_entries_to_write) { + const bool store_raw = + entry.value_type == ValueType::path + && should_store_raw_file(m_ctx.config, entry.file_type); + const uint64_t entry_size = + entry.value_type == ValueType::data + ? entry.value.size() + : Stat::stat(entry.value, Stat::OnError::throw_error).size(); + + LOG("Storing {} entry #{} {} ({} bytes){}", store_raw ? "raw" : "embedded", entry_number, - file_type_to_string(file_type), - file_size, - path); + file_type_to_string(entry.file_type), + entry_size, + entry.value_type == ValueType::data ? "" + : FMT(" from {}", entry.value)); writer.write_int(store_raw ? k_raw_file_marker : k_embedded_file_marker); - writer.write_int(UnderlyingFileTypeInt(file_type)); - writer.write_int(file_size); + writer.write_int(UnderlyingFileTypeInt(entry.file_type)); + writer.write_int(entry_size); if (store_raw) { - file_size_and_count_diff += write_raw_file_entry(path, entry_number); + file_size_and_count_diff += + write_raw_file_entry(entry.value, entry_number); + } else if (entry.value_type == ValueType::data) { + writer.write(entry.value.data(), entry.value.size()); } else { - write_embedded_file_entry(writer, path, file_size); + write_embedded_file_entry(writer, entry.value, entry_size); } ++entry_number; @@ -394,7 +405,7 @@ Writer::do_finalize() void Result::Writer::write_embedded_file_entry(core::CacheEntryWriter& writer, const std::string& path, - uint64_t file_size) + const uint64_t file_size) { Fd file(open(path.c_str(), O_RDONLY | O_BINARY)); if (!file) { diff --git a/src/Result.hpp b/src/Result.hpp index cca900f2f..67aadd1c2 100644 --- a/src/Result.hpp +++ b/src/Result.hpp @@ -134,16 +134,28 @@ class Writer public: Writer(Context& ctx, const std::string& result_path); - // Register a file to include in the result. Does not throw. - void write(FileType file_type, const std::string& file_path); + // Register content to include in the result. Does not throw. + void write_data(FileType file_type, const std::string& data); - // Write registered files to the result. Returns an error message on error. + // Register a file path whose content should be included in the result. Does + // not throw. + void write_file(FileType file_type, const std::string& path); + + // Write registered entries to the result. Returns an error message on error. nonstd::expected finalize(); private: + enum class ValueType { data, path }; + struct Entry + { + FileType file_type; + ValueType value_type; + std::string value; + }; + Context& m_ctx; const std::string m_result_path; - std::vector> m_entries_to_write; + std::vector m_entries_to_write; FileSizeAndCountDiff do_finalize(); static void write_embedded_file_entry(core::CacheEntryWriter& writer, diff --git a/src/ccache.cpp b/src/ccache.cpp index a01f2bd88..980209fda 100644 --- a/src/ccache.cpp +++ b/src/ccache.cpp @@ -801,40 +801,44 @@ write_result(Context& ctx, } if (stderr_stat.size() > 0) { - result_writer.write(Result::FileType::stderr_output, stderr_path); + result_writer.write_file(Result::FileType::stderr_output, stderr_path); } // Write stdout only after stderr (better with MSVC), as ResultRetriever // will later print process them in the order they are read. if (stdout_stat.size() > 0) { - result_writer.write(Result::FileType::stdout_output, stdout_path); + result_writer.write_file(Result::FileType::stdout_output, stdout_path); } if (obj_stat) { - result_writer.write(Result::FileType::object, ctx.args_info.output_obj); + result_writer.write_file(Result::FileType::object, + ctx.args_info.output_obj); } if (ctx.args_info.generating_dependencies) { - result_writer.write(Result::FileType::dependency, ctx.args_info.output_dep); + result_writer.write_file(Result::FileType::dependency, + ctx.args_info.output_dep); } if (ctx.args_info.generating_coverage) { const auto coverage_file = find_coverage_file(ctx); if (!coverage_file.found) { return false; } - result_writer.write(coverage_file.mangled - ? Result::FileType::coverage_mangled - : Result::FileType::coverage_unmangled, - coverage_file.path); + result_writer.write_file(coverage_file.mangled + ? Result::FileType::coverage_mangled + : Result::FileType::coverage_unmangled, + coverage_file.path); } if (ctx.args_info.generating_stackusage) { - result_writer.write(Result::FileType::stackusage, ctx.args_info.output_su); + result_writer.write_file(Result::FileType::stackusage, + ctx.args_info.output_su); } if (ctx.args_info.generating_diagnostics) { - result_writer.write(Result::FileType::diagnostic, ctx.args_info.output_dia); + result_writer.write_file(Result::FileType::diagnostic, + ctx.args_info.output_dia); } if (ctx.args_info.seen_split_dwarf && Stat::stat(ctx.args_info.output_dwo)) { // Only store .dwo file if it was created by the compiler (GCC and Clang // behave differently e.g. for "-gsplit-dwarf -g1"). - result_writer.write(Result::FileType::dwarf_object, - ctx.args_info.output_dwo); + result_writer.write_file(Result::FileType::dwarf_object, + ctx.args_info.output_dwo); } const auto file_size_and_count_diff = result_writer.finalize();