131 lines
4.6 KiB
C++
131 lines
4.6 KiB
C++
// Copyright 2022 The Pigweed Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
// use this file except in compliance with the License. You may obtain a copy of
|
|
// the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
// License for the specific language governing permissions and limitations under
|
|
// the License.
|
|
#include "pw_transfer/atomic_file_transfer_handler.h"
|
|
|
|
#include <filesystem>
|
|
#include <system_error>
|
|
|
|
#include "pw_log/log.h"
|
|
#include "pw_status/status.h"
|
|
#include "pw_stream/std_file_stream.h"
|
|
#include "pw_transfer_private/filename_generator.h"
|
|
|
|
namespace pw::transfer {
|
|
|
|
namespace {
|
|
// Linux Error code for Cross-Device Link Error.
|
|
constexpr auto CROSS_DEVICE_LINK_ERROR = 18;
|
|
|
|
pw::Status EnsureDirectoryExists(std::string_view filepath) {
|
|
const auto target_directory = std::filesystem::path{filepath}.parent_path();
|
|
return std::filesystem::exists(target_directory) ||
|
|
std::filesystem::create_directories(target_directory)
|
|
? pw::OkStatus()
|
|
: pw::Status::Internal();
|
|
}
|
|
|
|
// Copy file and remove on succes.
|
|
// If the copy fails, the file `input_target` is not removed.
|
|
pw::Status CopyFile(const std::string_view input_target,
|
|
const std::string_view output_target) {
|
|
auto err = std::error_code{};
|
|
std::filesystem::copy(input_target,
|
|
output_target,
|
|
std::filesystem::copy_options::overwrite_existing,
|
|
err);
|
|
if (err) {
|
|
PW_LOG_ERROR("Error with status code: %d (%s) during copy of file %s",
|
|
err.value(),
|
|
err.message().c_str(),
|
|
input_target.data());
|
|
return pw::Status::Internal();
|
|
}
|
|
PW_LOG_INFO("Successfully copied the file.");
|
|
if (!std::filesystem::remove(input_target)) {
|
|
PW_LOG_WARN("Failed to remove tmp file %s", input_target.data());
|
|
}
|
|
return pw::OkStatus();
|
|
}
|
|
|
|
// Uses the same approach as unix `mv` command. First try to rename. If we get
|
|
// a cross-device link error, copies then deletes input_target.
|
|
pw::Status RenameFile(const std::string_view input_target,
|
|
const std::string_view output_target) {
|
|
auto err = std::error_code{};
|
|
std::filesystem::rename(input_target, output_target, err);
|
|
if (err && err.value() == CROSS_DEVICE_LINK_ERROR) {
|
|
PW_LOG_INFO("%s[%d] during rename of file %s. Trying Copy/Remove.",
|
|
err.message().c_str(),
|
|
err.value(),
|
|
input_target.data());
|
|
return CopyFile(input_target, output_target);
|
|
}
|
|
return err ? pw::Status::Internal() : pw::OkStatus();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
Status AtomicFileTransferHandler::PrepareRead() {
|
|
auto file_path = path_.c_str();
|
|
PW_LOG_DEBUG("Preparing read for file %s", file_path);
|
|
if (!std::filesystem::exists(file_path)) {
|
|
PW_LOG_ERROR("File does not exist, path: %s", file_path);
|
|
return Status::NotFound();
|
|
}
|
|
set_reader(stream_.emplace<stream::StdFileReader>(file_path));
|
|
return OkStatus();
|
|
}
|
|
|
|
void AtomicFileTransferHandler::FinalizeRead(Status) {
|
|
std::get<stream::StdFileReader>(stream_).Close();
|
|
}
|
|
|
|
Status AtomicFileTransferHandler::PrepareWrite() {
|
|
const std::string tmp_file = GetTempFilePath(path_);
|
|
PW_LOG_DEBUG("Preparing write for file %s", tmp_file.c_str());
|
|
set_writer(stream_.emplace<stream::StdFileWriter>(tmp_file.c_str()));
|
|
return OkStatus();
|
|
}
|
|
|
|
Status AtomicFileTransferHandler::FinalizeWrite(Status status) {
|
|
std::get<stream::StdFileWriter>(stream_).Close();
|
|
auto tmp_file = GetTempFilePath(path_);
|
|
if (!status.ok() || !std::filesystem::exists(tmp_file) ||
|
|
std::filesystem::is_empty(tmp_file)) {
|
|
PW_LOG_ERROR("Transfer unsuccesful, attempt to remove temp file %s",
|
|
tmp_file.c_str());
|
|
// Remove temp file if transfer fails.
|
|
return std::filesystem::remove(tmp_file) ? status : Status::Aborted();
|
|
}
|
|
|
|
const auto directory_exists_status = EnsureDirectoryExists(path_);
|
|
if (!directory_exists_status.ok()) {
|
|
std::filesystem::remove(tmp_file);
|
|
return directory_exists_status;
|
|
}
|
|
|
|
PW_LOG_DEBUG(
|
|
"Copying file from: %s, to: %s", tmp_file.c_str(), path_.c_str());
|
|
const auto rename_status = RenameFile(tmp_file, path_);
|
|
if (!rename_status.ok()) {
|
|
std::filesystem::remove(tmp_file);
|
|
return rename_status;
|
|
}
|
|
|
|
PW_LOG_INFO("File transfer was successful.");
|
|
return OkStatus();
|
|
}
|
|
|
|
} // namespace pw::transfer
|