src/common/step/filesystem/step_recover_files.cc

   1 // Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   2 // Use of this source code is governed by an apache-2.0 license that can be
   3 // found in the LICENSE file.
   4
   5 #include "common/step/filesystem/step_recover_files.h"
   6
   7 #include <boost/filesystem/operations.hpp>
   8 #include <boost/filesystem/path.hpp>
   9 #include <boost/system/error_code.hpp>
  10
  11 #include "common/utils/paths.h"
  12 #include "common/recovery_file.h"
  13 #include "common/utils/file_util.h"
  14 #include "common/utils/request.h"
  15
  16 namespace bf = boost::filesystem;
  17 namespace bs = boost::system;
  18
  19 namespace {
  20
  21 const char kExternalMemoryMountPoint[] = ".mmc";
  22
  23 bool Move(const boost::filesystem::path& from,
  24     const boost::filesystem::path& to,
  25     common_installer::FSFlag flag = common_installer::FSFlag::FS_NONE) {
  26   if (bf::is_directory(from)) {
  27     if (!common_installer::MoveDir(from, to / from.filename(), flag)) {
  28       LOG(ERROR) << "Failed to move directory: " << from;
  29       return false;
  30     }
  31   } else {
  32     if (!common_installer::MoveFile(from, to / from.filename())) {
  33       LOG(ERROR) << "Fail to move file: " << from;
  34       return false;
  35     }
  36   }
  37
  38   return true;
  39 }
  40
  41 }  // namespace
  42
  43 namespace common_installer {
  44 namespace filesystem {
  45
  46 Step::Status StepRecoverFiles::RecoveryNew() {
  47   if (!ClearPath(context_->GetPkgPath()))
  48     return Status::RECOVERY_ERROR;
  49
  50   LOG(INFO) << "Package files recovery done";
  51   return Status::OK;
  52 }
  53
  54 Step::Status StepRecoverFiles::RecoveryUpdate() {
  55   recovery::RecoveryFile* recovery_file =
  56       context_->recovery_info.get().recovery_file.get();
  57   bool backup_done = recovery_file->backup_done();
  58   bf::path backup_path = GetBackupPathForPackagePath(context_->GetPkgPath());
  59   if (bf::exists(backup_path)) {
  60     // Remove pkgdir only if backup original contents is completely done.
  61     if (backup_done) {
  62       for (bf::directory_iterator iter(context_->GetPkgPath());
  63            iter != bf::directory_iterator(); ++iter) {
  64         if (iter->path().filename() == kExternalMemoryMountPoint)
  65           continue;
  66
  67         if (!ClearPath(iter->path())) {
  68           LOG(ERROR) << "Cannot restore widget files to its correct location";
  69           return Status::RECOVERY_ERROR;
  70         }
  71       }
  72       // it may fail during recovery.
  73       recovery_file->set_backup_done(false);
  74       recovery_file->WriteAndCommitFileContent();
  75     }
  76
  77     // create copy of old package content skipping the external memory mount point
  78     for (bf::directory_iterator iter(backup_path);
  79          iter != bf::directory_iterator(); ++iter) {
  80       if (!Move(iter->path(), context_->GetPkgPath()))
  81         return Status::RECOVERY_ERROR;
  82     }
  83
  84     ClearPath(backup_path);
  85   }
  86   LOG(INFO) << "Package files recovery done";
  87   return Status::OK;
  88 }
  89
  90 Step::Status StepRecoverFiles::RecoveryMountNew() {
  91   bf::path zip_location = GetZipPackageLocation(
  92         context_->GetPkgPath(), context_->pkgid.get());
  93   Remove(zip_location);
  94   ClearPath(context_->GetPkgPath());
  95   LOG(INFO) << "Package files recovery done";
  96   return Status::OK;
  97 }
  98
  99 Step::Status StepRecoverFiles::RecoveryMountUpdate() {
 100   bf::path zip_location = GetZipPackageLocation(
 101         context_->GetPkgPath(), context_->pkgid.get());
 102   bf::path backup_zip_location = GetBackupPathForZipFile(zip_location);
 103   if (bf::exists(backup_zip_location)) {
 104     Remove(zip_location);
 105     MoveFile(backup_zip_location, zip_location);
 106   }
 107
 108   // During mount update some files are still backed up separately from zip
 109   // package file. This is because of the fact that we need to access bin/, lib/
 110   // directories without mounting zip package file. In other words in mount
 111   // install or mount update mode we don't mount everything - some files are
 112   // still unpacked due to necessity.
 113   bf::path backup_path = GetBackupPathForPackagePath(context_->GetPkgPath());
 114   if (bf::exists(backup_path)) {
 115     for (bf::directory_iterator iter(backup_path);
 116          iter != bf::directory_iterator(); ++iter) {
 117       ClearPath(context_->GetPkgPath() / iter->path().filename());
 118       if (!Move(iter->path(), context_->GetPkgPath())) {
 119         LOG(ERROR) << "Failed to recovery backup file(" << iter->path()
 120             << ") in recovery of mount update";
 121         return Status::RECOVERY_ERROR;
 122       }
 123     }
 124     ClearPath(backup_path);
 125   }
 126
 127   LOG(INFO) << "Package files recovery done";
 128   return Status::OK;
 129 }
 130
 131 Step::Status StepRecoverFiles::RecoveryReadonlyUpdateInstall() {
 132   // Remove package directory at RW area
 133   bf::path pkg_path =
 134       bf::path(GetRootAppPath(false, context_->uid.get())) /
 135       context_->pkgid.get();
 136   if (!ClearPath(pkg_path))
 137     return Status::RECOVERY_ERROR;
 138
 139   LOG(INFO) << "Package files recovery done";
 140   return Status::OK;
 141 }
 142
 143 Step::Status StepRecoverFiles::Cleanup() {
 144   recovery::RecoveryFile* recovery_file =
 145       context_->recovery_info.get().recovery_file.get();
 146   bf::path root_path(GetRootAppPath(
 147       context_->is_readonly_package.get(), context_->uid.get()));
 148   bf::path backup_path = GetBackupPathForPackagePath(
 149       root_path / recovery_file->pkgid());
 150   if (!bf::exists(backup_path))
 151     return Status::OK;
 152
 153   if (!ClearPath(backup_path)) {
 154     LOG(ERROR) << "Failed to remove backup path";
 155     return Status::RECOVERY_ERROR;
 156   }
 157
 158   return Status::OK;
 159 }
 160
 161 bool StepRecoverFiles::ClearPath(const bf::path& path) {
 162   return RemoveAll(path);
 163 }
 164
 165 }  // namespace filesystem
 166 }  // namespace common_installer
 167