#include "common/step/filesystem/step_delta_patch.h"
-#include <boost/system/error_code.hpp>
-#include <boost/filesystem/path.hpp>
#include <delta/delta_handler.h>
#include <delta/delta_parser.h>
#include <sys/types.h>
#include <algorithm>
#include <cstdlib>
+#include <filesystem>
#include <memory>
+#include <system_error>
#include "common/utils/file_util.h"
#include "common/utils/glist_range.h"
-namespace bf = boost::filesystem;
-namespace bs = boost::system;
namespace ci = common_installer;
+namespace fs = std::filesystem;
namespace {
return true;
}
-void RemoveBinarySymlinks(const bf::path& dir) {
- for (bf::directory_iterator iter(dir / kBinaryDir);
- iter != bf::directory_iterator(); ++iter) {
- if (bf::is_symlink(symlink_status(iter->path()))) {
+void RemoveBinarySymlinks(const fs::path& dir) {
+ for (fs::directory_iterator iter(dir / kBinaryDir);
+ iter != fs::directory_iterator(); ++iter) {
+ if (fs::is_symlink(symlink_status(iter->path()))) {
// FIXME: note that this assumes that it is not possible to create
// explicitly symlinks in bin/ directory pointing to whatever
- bs::error_code error;
+ std::error_code error;
ci::Remove(iter->path());
}
}
}
-void RemoveStorageDirectories(const bf::path& dir) {
+void RemoveStorageDirectories(const fs::path& dir) {
ci::RemoveAll(dir / kDataDir);
ci::RemoveAll(dir / kCacheDir);
ci::RemoveAll(dir / kSharedData);
ci::RemoveAll(dir / kSharedTrusted);
}
-void RemoveExtraIconFiles(const bf::path& dir, const bf::path& pkg_dir,
+void RemoveExtraIconFiles(const fs::path& dir, const fs::path& pkg_dir,
manifest_x* manifest) {
for (application_x* app : GListRange<application_x*>(manifest->application)) {
if (strcmp("webapp", app->type) != 0)
auto range = GListRange<icon_x*>(app->icon);
auto iter = range.begin();
if (iter != range.end()) {
- bs::error_code error;
+ std::error_code error;
std::string old_path((*iter)->text);
- bf::path icon_copy = dir / old_path.substr(pkg_dir.string().size());
+ fs::path icon_copy = dir / old_path.substr(pkg_dir.string().size());
ci::Remove(icon_copy);
}
}
}
-bool ApplyDeletedFiles(const delta::DeltaInfo& info, const bf::path& app_dir) {
+bool ApplyDeletedFiles(const delta::DeltaInfo& info, const fs::path& app_dir) {
for (auto& relative : info.removed()) {
if (!ci::Remove(app_dir / relative))
return false;
return true;
}
-bool ApplyModifiedFiles(const delta::DeltaInfo& info, const bf::path& app_dir,
- const bf::path& patch_dir, bool is_readonly,
+bool ApplyModifiedFiles(const delta::DeltaInfo& info, const fs::path& app_dir,
+ const fs::path& patch_dir, bool is_readonly,
uid_t uid) {
for (auto& relative : info.modified()) {
- bf::path temp_file = ci::GenerateTemporaryPath(
- bf::path(ci::GetRootAppPath(is_readonly, uid)) / "tmp_file");
- bf::path patch_file = patch_dir / relative;
- bf::path input = app_dir / relative;
- if (!bf::is_regular_file(input)) {
+ fs::path temp_file = ci::GenerateTemporaryPath(
+ fs::path(ci::GetRootAppPath(is_readonly, uid)) / "tmp_file");
+ fs::path patch_file = patch_dir / relative;
+ fs::path input = app_dir / relative;
+ if (!fs::is_regular_file(input)) {
LOG(ERROR) << "Cannot modify. Not a regular file: " << input;
return false;
}
return false;
}
}
- bs::error_code error;
- bf::copy_file(temp_file, input, bf::copy_option::overwrite_if_exists,
+ std::error_code error;
+ fs::copy_file(temp_file, input, fs::copy_options::overwrite_existing,
error);
if (error) {
LOG(ERROR) << "Failed to copy from " << temp_file << " to " << input;
- bf::remove(temp_file, error);
+ fs::remove(temp_file, error);
return false;
}
ci::Remove(temp_file);
return true;
}
-bool ApplyAddedFiles(const delta::DeltaInfo& info, const bf::path& app_dir,
- const bf::path& patch_dir) {
+bool ApplyAddedFiles(const delta::DeltaInfo& info, const fs::path& app_dir,
+ const fs::path& patch_dir) {
for (auto& relative : info.added()) {
- bf::path source = patch_dir / relative;
- bf::path target = app_dir / relative;
- bs::error_code error;
- if (bf::is_directory(source)) {
- bf::create_directories(target, error);
+ fs::path source = patch_dir / relative;
+ fs::path target = app_dir / relative;
+ std::error_code error;
+ if (fs::is_directory(source)) {
+ fs::create_directories(target, error);
if (error) {
LOG(ERROR) << "Failed to add: " << relative;
return false;
} else {
if (!ci::Remove(target))
return false;
- if (!bf::exists(target.parent_path())) {
- bf::create_directories(target.parent_path(), error);
+ if (!fs::exists(target.parent_path())) {
+ fs::create_directories(target.parent_path(), error);
if (error) {
LOG(ERROR) << "Cannot create directory: " << target.parent_path();
return false;
return true;
}
-bool ApplyPatch(const delta::DeltaInfo& info, const bf::path& app_dir,
- const bf::path& patch_dir, bool is_readonly, uid_t uid) {
+bool ApplyPatch(const delta::DeltaInfo& info, const fs::path& app_dir,
+ const fs::path& patch_dir, bool is_readonly, uid_t uid) {
if (!ApplyDeletedFiles(info, app_dir))
return false;
if (!ApplyModifiedFiles(info, app_dir, patch_dir, is_readonly, uid))
return true;
}
-bool CopySkipMount(const bf::path& from, const bf::path& to) {
- bs::error_code error;
- bf::create_directory(to, error);
+bool CopySkipMount(const fs::path& from, const fs::path& to) {
+ std::error_code error;
+ fs::create_directory(to, error);
if (error) {
LOG(ERROR) << "Failed to create target directory";
return false;
}
- for (bf::directory_iterator iter(from); iter != bf::directory_iterator();
+ for (fs::directory_iterator iter(from); iter != fs::directory_iterator();
++iter) {
if (iter->path().filename() == kExternalMemoryMountPoint)
continue;
- if (bf::is_directory(iter->path())) {
+ if (fs::is_directory(iter->path())) {
if (!ci::CopyDir(iter->path(), to / iter->path().filename())) {
LOG(ERROR) << "Failed to create copy of: " << iter->path();
return false;
}
} else {
- bf::copy(iter->path(), to / iter->path().filename(), error);
+ fs::copy(iter->path(), to / iter->path().filename(), error);
if (error) {
LOG(ERROR) << "Failed to create copy of: " << iter->path();
return false;
}
Step::Status StepDeltaPatch::process() {
- bf::path delta_file = context_->unpacked_dir_path.get() / kDeltaFile;
- if (!bf::exists(delta_file)) {
+ fs::path delta_file = context_->unpacked_dir_path.get() / kDeltaFile;
+ if (!fs::exists(delta_file)) {
LOG(ERROR) << "Delta file doesn't exist in package.";
return Status::DELTA_ERROR;
}
projects / platform / core / appfw / app-installers.git / blobdiff