1 /*

     2  * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include <memory>

    27 #include <algorithm>

    28 #include <shlwapi.h>

    29 

    30 #include "FileUtils.h"

    31 #include "WinErrorHandling.h"

    32 #include "Log.h"

    33 

    34 

    35 // Needed by FileUtils::isDirectoryNotEmpty

    36 #pragma comment(lib, "shlwapi")

    37 

    38 

    39 namespace FileUtils {

    40 

    41 namespace {

    42 

    43 

    44 tstring reservedFilenameChars() {

    45     tstring buf;

    46     for (char charCode = 0; charCode < 32; ++charCode) {

    47         buf.append(1, charCode);

    48     }

    49     buf += _T("<>:\"|?*/\\");

    50     return buf;

    51 }

    52 

    53 } // namespace

    54 

    55 bool isDirSeparator(const tstring::value_type c) {

    56     return (c == '/' || c == '\\');

    57 }

    58 

    59 bool isFileExists(const tstring &filePath) {

    60     return GetFileAttributes(filePath.c_str()) != INVALID_FILE_ATTRIBUTES;

    61 }

    62 

    63 namespace {

    64 bool isDirectoryAttrs(const DWORD attrs) {

    65     return attrs != INVALID_FILE_ATTRIBUTES

    66             && (attrs & FILE_ATTRIBUTE_DIRECTORY) != 0;

    67 }

    68 } // namespace

    69 

    70 bool isDirectory(const tstring &filePath) {

    71     return isDirectoryAttrs(GetFileAttributes(filePath.c_str()));

    72 }

    73 

    74 bool isDirectoryNotEmpty(const tstring &dirPath) {

    75     if (!isDirectory(dirPath)) {

    76         return false;

    77     }

    78     return FALSE == PathIsDirectoryEmpty(dirPath.c_str());

    79 }

    80 

    81 tstring dirname(const tstring &path) {

    82     tstring::size_type pos = path.find_last_of(_T("\\/"));

    83     if (pos != tstring::npos) {

    84         pos = path.find_last_not_of(_T("\\/"), pos); // skip trailing slashes

    85     }

    86     return pos == tstring::npos ? tstring() : path.substr(0, pos + 1);

    87 }

    88 

    89 tstring basename(const tstring &path) {

    90     const tstring::size_type pos = path.find_last_of(_T("\\/"));

    91     if (pos == tstring::npos) {

    92         return path;

    93     }

    94     return path.substr(pos + 1);

    95 }

    96 

    97 tstring suffix(const tstring &path) {

    98     const tstring::size_type pos = path.rfind('.');

    99     if (pos == tstring::npos) {

   100         return tstring();

   101     }

   102     const tstring::size_type dirSepPos = path.find_first_of(_T("\\/"),

   103                                                             pos + 1);

   104     if (dirSepPos != tstring::npos) {

   105         return tstring();

   106     }

   107     // test for '/..' and '..' cases

   108     if (pos != 0 && path[pos - 1] == '.'

   109                             && (pos == 1 || isDirSeparator(path[pos - 2]))) {

   110         return tstring();

   111     }

   112     return path.substr(pos);

   113 }

   114 

   115 tstring combinePath(const tstring& parent, const tstring& child) {

   116     if (parent.empty()) {

   117         return child;

   118     }

   119     if (child.empty()) {

   120         return parent;

   121     }

   122 

   123     tstring parentWOSlash = removeTrailingSlash(parent);

   124     // also handle the case when child contains starting slash

   125     bool childHasSlash = isDirSeparator(child.front());

   126     tstring childWOSlash = childHasSlash ? child.substr(1) : child;

   127 

   128     return parentWOSlash + _T("\\") + childWOSlash;

   129 }

   130 

   131 tstring removeTrailingSlash(const tstring& path) {

   132     if (path.empty()) {

   133         return path;

   134     }

   135     tstring::const_reverse_iterator it = path.rbegin();

   136     tstring::const_reverse_iterator end = path.rend();

   137 

   138     while (it != end && isDirSeparator(*it)) {

   139         ++it;

   140     }

   141     return path.substr(0, end - it);

   142 }

   143 

   144 tstring normalizePath(tstring v) {

   145     std::replace(v.begin(), v.end(), '/', '\\');

   146     return tstrings::toLower(v);

   147 }

   148 

   149 namespace {

   150 

   151 bool createNewFile(const tstring& path) {

   152     HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,

   153             FILE_ATTRIBUTE_NORMAL, NULL);

   154     // if the file exists => h == INVALID_HANDLE_VALUE & GetLastError

   155     // returns ERROR_FILE_EXISTS

   156     if (h != INVALID_HANDLE_VALUE) {

   157         CloseHandle(h);

   158         LOG_TRACE(tstrings::any() << "Created [" << path << "] file");

   159         return true;

   160     }

   161     return false;

   162 }

   163 

   164 } // namespace

   165 

   166 tstring createTempFile(const tstring &prefix, const tstring &suffix,

   167         const tstring &path) {

   168     const tstring invalidChars = reservedFilenameChars();

   169 

   170     if (prefix.find_first_of(invalidChars) != tstring::npos) {

   171         JP_THROW(tstrings::any() << "Illegal characters in prefix=" << prefix);

   172     }

   173 

   174     if (suffix.find_first_of(invalidChars) != tstring::npos) {

   175         JP_THROW(tstrings::any() << "Illegal characters in suffix=" << suffix);

   176     }

   177 

   178     int rnd = (int)GetTickCount();

   179 

   180     // do no more than 100 attempts

   181     for (int i=0; i<100; i++) {

   182         const tstring filePath = mkpath() << path << (prefix

   183                 + (tstrings::any() << (rnd + i)).tstr() + suffix);

   184         if (createNewFile(filePath)) {

   185             return filePath;

   186         }

   187     }

   188 

   189     // 100 attempts failed

   190     JP_THROW(tstrings::any() << "createTempFile("  << prefix << ", "

   191                                                     << suffix << ", "

   192                                                     << path << ") failed");

   193 }

   194 

   195 tstring createTempDirectory(const tstring &prefix, const tstring &suffix,

   196         const tstring &basedir) {

   197     const tstring filePath = createTempFile(prefix, suffix, basedir);

   198     // delete the file and create directory with the same name

   199     deleteFile(filePath);

   200     createDirectory(filePath);

   201     return filePath;

   202 }

   203 

   204 tstring createUniqueFile(const tstring &prototype) {

   205     if (createNewFile(prototype)) {

   206         return prototype;

   207     }

   208 

   209     return createTempFile(replaceSuffix(basename(prototype)),

   210             suffix(prototype), dirname(prototype));

   211 }

   212 

   213 namespace {

   214 

   215 void createDir(const tstring path, LPSECURITY_ATTRIBUTES saAttr,

   216         tstring_array* createdDirs=0) {

   217     if (CreateDirectory(path.c_str(), saAttr)) {

   218         LOG_TRACE(tstrings::any() << "Created [" << path << "] directory");

   219         if (createdDirs) {

   220             createdDirs->push_back(removeTrailingSlash(path));

   221         }

   222     } else {

   223         const DWORD createDirectoryErr = GetLastError();

   224         // if saAttr is specified, fail even if the directory exists

   225         if (saAttr != NULL || !isDirectory(path)) {

   226             JP_THROW(SysError(tstrings::any() << "CreateDirectory("

   227                 << path << ") failed", CreateDirectory, createDirectoryErr));

   228         }

   229     }

   230 }

   231 

   232 }

   233 

   234 void createDirectory(const tstring &path, tstring_array* createdDirs) {

   235     const tstring dirPath = removeTrailingSlash(path) + _T("\\");

   236 

   237     tstring::size_type pos = dirPath.find_first_of(_T("\\/"));

   238     while (pos != tstring::npos) {

   239         const tstring subdirPath = dirPath.substr(0, pos + 1);

   240         createDir(subdirPath, NULL, createdDirs);

   241         pos = dirPath.find_first_of(_T("\\/"), pos + 1);

   242     }

   243 }

   244 

   245 

   246 void copyFile(const tstring& fromPath, const tstring& toPath,

   247         bool failIfExists) {

   248     createDirectory(dirname(toPath));

   249     if (!CopyFile(fromPath.c_str(), toPath.c_str(),

   250             (failIfExists ? TRUE : FALSE))) {

   251         JP_THROW(SysError(tstrings::any()

   252                 << "CopyFile(" << fromPath << ", " << toPath << ", "

   253                 << failIfExists << ") failed", CopyFile));

   254     }

   255     LOG_TRACE(tstrings::any() << "Copied [" << fromPath << "] file to ["

   256             << toPath << "]");

   257 }

   258 

   259 

   260 namespace {

   261 

   262 void moveFileImpl(const tstring& fromPath, const tstring& toPath,

   263         DWORD flags) {

   264     const bool isDir = isDirectory(fromPath);

   265     if (!MoveFileEx(fromPath.c_str(), toPath.empty() ? NULL : toPath.c_str(),

   266             flags)) {

   267         JP_THROW(SysError(tstrings::any() << "MoveFileEx(" << fromPath

   268                 << ", " << toPath << ", " << flags << ") failed", MoveFileEx));

   269     }

   270 

   271     const bool onReboot = 0 != (flags & MOVEFILE_DELAY_UNTIL_REBOOT);

   272 

   273     const LPCTSTR label = isDir ? _T("folder") : _T("file");

   274 

   275     tstrings::any msg;

   276     if (!toPath.empty()) {

   277         if (onReboot) {

   278             msg << "Move";

   279         } else {

   280             msg << "Moved";

   281         }

   282         msg << " '" << fromPath << "' " << label << " to '" << toPath << "'";

   283     } else {

   284         if (onReboot) {

   285             msg << "Delete";

   286         } else {

   287             msg << "Deleted";

   288         }

   289         msg << " '" << fromPath << "' " << label;

   290     }

   291     if (onReboot) {

   292         msg << " on reboot";

   293     }

   294     LOG_TRACE(msg);

   295 }

   296 

   297 } // namespace

   298 

   299 

   300 void moveFile(const tstring& fromPath, const tstring& toPath,

   301         bool failIfExists) {

   302     createDirectory(dirname(toPath));

   303 

   304     DWORD flags = MOVEFILE_COPY_ALLOWED;

   305     if (!failIfExists) {

   306         flags |= MOVEFILE_REPLACE_EXISTING;

   307     }

   308 

   309     moveFileImpl(fromPath, toPath, flags);

   310 }

   311 

   312 void deleteFile(const tstring &path)

   313 {

   314     if (!deleteFile(path, std::nothrow)) {

   315         JP_THROW(SysError(tstrings::any()

   316                 << "DeleteFile(" << path << ") failed", DeleteFile));

   317     }

   318 }

   319 

   320 namespace {

   321 

   322 bool notFound(const DWORD status=GetLastError()) {

   323     return status == ERROR_FILE_NOT_FOUND || status == ERROR_PATH_NOT_FOUND;

   324 }

   325 

   326 bool deleteFileImpl(const std::nothrow_t &, const tstring &path) {

   327     const bool deleted = (DeleteFile(path.c_str()) != 0);

   328     if (deleted) {

   329         LOG_TRACE(tstrings::any() << "Deleted [" << path << "] file");

   330         return true;

   331     }

   332     return notFound();

   333 }

   334 

   335 } // namespace

   336 

   337 bool deleteFile(const tstring &path, const std::nothrow_t &) throw()

   338 {

   339     bool deleted = deleteFileImpl(std::nothrow, path);

   340     const DWORD status = GetLastError();

   341     if (!deleted && status == ERROR_ACCESS_DENIED) {

   342         DWORD attrs = GetFileAttributes(path.c_str());

   343         SetLastError(status);

   344         if (attrs == INVALID_FILE_ATTRIBUTES) {

   345             return false;

   346         }

   347         if (attrs & FILE_ATTRIBUTE_READONLY) {

   348             // DeleteFile() failed because file is R/O.

   349             // Remove R/O attribute and retry DeleteFile().

   350             attrs &= ~FILE_ATTRIBUTE_READONLY;

   351             if (SetFileAttributes(path.c_str(), attrs)) {

   352                 LOG_TRACE(tstrings::any() << "Discarded R/O attribute from ["

   353                                                         << path << "] file");

   354                 deleted = deleteFileImpl(std::nothrow, path);

   355             } else {

   356                 LOG_WARNING(SysError(tstrings::any()

   357                             << "Failed to discard R/O attribute from ["

   358                             << path << "] file. File will not be deleted",

   359                             SetFileAttributes).what());

   360                 SetLastError(status);

   361             }

   362         }

   363     }

   364 

   365     return deleted || notFound();

   366 }

   367 

   368 void deleteDirectory(const tstring &path)

   369 {

   370     if (!deleteDirectory(path, std::nothrow)) {

   371         JP_THROW(SysError(tstrings::any()

   372                 << "RemoveDirectory(" << path << ") failed", RemoveDirectory));

   373     }

   374 }

   375 

   376 bool deleteDirectory(const tstring &path, const std::nothrow_t &) throw()

   377 {

   378     const bool deleted = (RemoveDirectory(path.c_str()) != 0);

   379     if (deleted) {

   380         LOG_TRACE(tstrings::any() << "Deleted [" << path << "] directory");

   381     }

   382     return deleted || notFound();

   383 }

   384 

   385 namespace {

   386 

   387 class DeleteFilesCallback: public DirectoryCallback {

   388 public:

   389     explicit DeleteFilesCallback(bool ff): failfast(ff), failed(false) {

   390     }

   391 

   392     virtual bool onFile(const tstring& path) {

   393         if (failfast) {

   394             deleteFile(path);

   395         } else {

   396             updateStatus(deleteFile(path, std::nothrow));

   397         }

   398         return true;

   399     }

   400 

   401     bool good() const {

   402         return !failed;

   403     }

   404 

   405 protected:

   406     void updateStatus(bool success) {

   407         if (!success) {

   408             failed = true;

   409         }

   410     }

   411 

   412     const bool failfast;

   413 private:

   414     bool failed;

   415 };

   416 

   417 class DeleteAllCallback: public DeleteFilesCallback {

   418 public:

   419     explicit DeleteAllCallback(bool failfast): DeleteFilesCallback(failfast) {

   420     }

   421 

   422     virtual bool onDirectory(const tstring& path) {

   423         if (failfast) {

   424             deleteDirectoryRecursive(path);

   425         } else {

   426             updateStatus(deleteDirectoryRecursive(path, std::nothrow));

   427         }

   428         return true;

   429     }

   430 };

   431 

   432 

   433 class BatchDeleter {

   434     const tstring dirPath;

   435     bool recursive;

   436 public:

   437     explicit BatchDeleter(const tstring& path): dirPath(path) {

   438         deleteSubdirs(false);

   439     }

   440 

   441     BatchDeleter& deleteSubdirs(bool v) {

   442         recursive = v;

   443         return *this;

   444     }

   445 

   446     void execute() const {

   447         if (!isFileExists(dirPath)) {

   448             return;

   449         }

   450         iterateDirectory(true /* fail fast */);

   451         if (recursive) {

   452             deleteDirectory(dirPath);

   453         }

   454     }

   455 

   456     bool execute(const std::nothrow_t&) const {

   457         if (!isFileExists(dirPath)) {

   458             return true;

   459         }

   460 

   461         if (!isDirectory(dirPath)) {

   462             return false;

   463         }

   464 

   465         JP_TRY;

   466         if (!iterateDirectory(false /* ignore errors */)) {

   467             return false;

   468         }

   469         if (recursive) {

   470             return deleteDirectory(dirPath, std::nothrow);

   471         }

   472         return true;

   473         JP_CATCH_ALL;

   474 

   475         return false;

   476     }

   477 

   478 private:

   479     bool iterateDirectory(bool failfast) const {

   480         std::unique_ptr<DeleteFilesCallback> callback;

   481         if (recursive) {

   482             callback = std::unique_ptr<DeleteFilesCallback>(

   483                                             new DeleteAllCallback(failfast));

   484         } else {

   485             callback = std::unique_ptr<DeleteFilesCallback>(

   486                                             new DeleteFilesCallback(failfast));

   487         }

   488 

   489         FileUtils::iterateDirectory(dirPath, *callback);

   490         return callback->good();

   491     }

   492 };

   493 

   494 } // namespace

   495 

   496 void deleteFilesInDirectory(const tstring &dirPath) {

   497     BatchDeleter(dirPath).execute();

   498 }

   499 

   500 bool deleteFilesInDirectory(const tstring &dirPath,

   501                                             const std::nothrow_t &) throw() {

   502     return BatchDeleter(dirPath).execute(std::nothrow);

   503 }

   504 

   505 void deleteDirectoryRecursive(const tstring &dirPath) {

   506     BatchDeleter(dirPath).deleteSubdirs(true).execute();

   507 }

   508 

   509 bool deleteDirectoryRecursive(const tstring &dirPath,

   510                                             const std::nothrow_t &) throw() {

   511     return BatchDeleter(dirPath).deleteSubdirs(true).execute(std::nothrow);

   512 }

   513 

   514 namespace {

   515 

   516 struct FindFileDeleter {

   517     typedef HANDLE pointer;

   518 

   519     void operator()(HANDLE h) {

   520         if (h && h != INVALID_HANDLE_VALUE) {

   521             FindClose(h);

   522         }

   523     }

   524 };

   525 

   526 typedef std::unique_ptr<HANDLE, FindFileDeleter> UniqueFindFileHandle;

   527 

   528 }; // namesace

   529 void iterateDirectory(const tstring &dirPath, DirectoryCallback& callback)

   530 {

   531     const tstring searchString = combinePath(dirPath, _T("*"));

   532     WIN32_FIND_DATA findData;

   533     UniqueFindFileHandle h(FindFirstFile(searchString.c_str(), &findData));

   534     if (h.get() == INVALID_HANDLE_VALUE) {

   535         // GetLastError() == ERROR_FILE_NOT_FOUND is OK

   536         // - no files in the directory

   537         // ERROR_PATH_NOT_FOUND is returned

   538         // if the parent directory does not exist

   539         if (GetLastError() != ERROR_FILE_NOT_FOUND) {

   540             JP_THROW(SysError(tstrings::any() << "FindFirstFile("

   541                     << dirPath << ") failed", FindFirstFile));

   542         }

   543         return;

   544     }

   545 

   546     do {

   547         const tstring fname(findData.cFileName);

   548         const tstring filePath = combinePath(dirPath, fname);

   549         if (!isDirectoryAttrs(findData.dwFileAttributes)) {

   550             if (!callback.onFile(filePath)) {

   551                 return;

   552             }

   553         } else if (fname != _T(".") && fname != _T("..")) {

   554             if (!callback.onDirectory(filePath)) {

   555                 return;

   556             }

   557         }

   558     } while (FindNextFile(h.get(), &findData));

   559 

   560     // expect GetLastError() == ERROR_NO_MORE_FILES

   561     if (GetLastError() != ERROR_NO_MORE_FILES) {

   562         JP_THROW(SysError(tstrings::any() << "FindNextFile("

   563                 << dirPath << ") failed", FindNextFile));

   564     }

   565 }

   566 

   567 

   568 tstring replaceSuffix(const tstring& path, const tstring& newSuffix) {

   569     return (path.substr(0, path.size() - suffix(path).size()) + newSuffix);

   570 }

   571 

   572 

   573 DirectoryIterator& DirectoryIterator::findItems(tstring_array& v) {

   574     if (!isDirectory(root)) {

   575         return *this;

   576     }

   577 

   578     iterateDirectory(root, *this);

   579     v.insert(v.end(), items.begin(), items.end());

   580     items = tstring_array();

   581     return *this;

   582 }

   583 

   584 bool DirectoryIterator::onFile(const tstring& path) {

   585     if (theWithFiles) {

   586         items.push_back(path);

   587     }

   588     return true;

   589 }

   590 

   591 bool DirectoryIterator::onDirectory(const tstring& path) {

   592     if (theWithFolders) {

   593         items.push_back(path);

   594     }

   595     if (theRecurse) {

   596         DirectoryIterator(path).recurse(theRecurse)

   597                 .withFiles(theWithFiles)

   598                 .withFolders(theWithFolders)

   599                 .findItems(items);

   600     }

   601     return true;

   602 }

   603 

   604 

   605 namespace {

   606 

   607 struct DeleterFunctor {

   608     // Order of items in the following enum is important!

   609     // It controls order in which items of particular type will be deleted.

   610     // See Deleter::execute().

   611     enum {

   612         File,

   613         FilesInDirectory,

   614         RecursiveDirectory,

   615         EmptyDirectory

   616     };

   617 

   618     void operator () (const Deleter::Path& path) const {

   619         switch (path.second) {

   620 #define DELETE_SOME(o, f)\

   621         case o:\

   622             f(path.first, std::nothrow);\

   623             break

   624 

   625         DELETE_SOME(File, deleteFile);

   626         DELETE_SOME(EmptyDirectory, deleteDirectory);

   627         DELETE_SOME(FilesInDirectory, deleteFilesInDirectory);

   628         DELETE_SOME(RecursiveDirectory, deleteDirectoryRecursive);

   629 

   630 #undef DELETE_SOME

   631         default:

   632             break;

   633         }

   634     }

   635 };

   636 

   637 } // namespace

   638 

   639 void Deleter::execute() {

   640     Paths tmp;

   641     tmp.swap(paths);

   642 

   643     // Reorder items to delete.

   644     std::stable_sort(tmp.begin(), tmp.end(), [] (const Paths::value_type& a,

   645                                                 const Paths::value_type& b) {

   646         return a.second < b.second;

   647     });

   648 

   649     std::for_each(tmp.begin(), tmp.end(), DeleterFunctor());

   650 }

   651 

   652 Deleter& Deleter::appendFile(const tstring& path) {

   653     paths.push_back(std::make_pair(path, DeleterFunctor::File));

   654     return *this;

   655 }

   656 

   657 Deleter& Deleter::appendEmptyDirectory(const Directory& dir) {

   658      tstring path =  normalizePath(removeTrailingSlash(dir));

   659      const tstring parent = normalizePath(removeTrailingSlash(dir.parent));

   660      while(parent != path) {

   661          appendEmptyDirectory(path);

   662          path = dirname(path);

   663      }

   664 

   665     return *this;

   666 }

   667 

   668 Deleter& Deleter::appendEmptyDirectory(const tstring& path) {

   669     paths.push_back(std::make_pair(path, DeleterFunctor::EmptyDirectory));

   670     return *this;

   671 }

   672 

   673 Deleter& Deleter::appendAllFilesInDirectory(const tstring& path) {

   674     paths.push_back(std::make_pair(path, DeleterFunctor::FilesInDirectory));

   675     return *this;

   676 }

   677 

   678 Deleter& Deleter::appendRecursiveDirectory(const tstring& path) {

   679     paths.push_back(std::make_pair(path, DeleterFunctor::RecursiveDirectory));

   680     return *this;

   681 }

   682 

   683 

   684 FileWriter::FileWriter(const tstring& path): dstPath(path) {

   685     tmpFile = FileUtils::createTempFile(_T("jds"), _T(".tmp"),

   686             FileUtils::dirname(path));

   687 

   688     cleaner.appendFile(tmpFile);

   689 

   690     // we want to get exception on error

   691     tmp.exceptions(std::ifstream::failbit | std::ifstream::badbit);

   692     tmp.open(tmpFile, std::ios::binary | std::ios::trunc);

   693 }

   694 

   695 FileWriter& FileWriter::write(const void* buf, size_t bytes) {

   696     tmp.write(static_cast<const char*>(buf), bytes);

   697     return *this;

   698 }

   699 

   700 void FileWriter::finalize() {

   701     tmp.close();

   702 

   703     FileUtils::moveFile(tmpFile, dstPath, false);

   704 

   705     // cancel file deletion

   706     cleaner.cancel();

   707 }

   708 

   709 } //  namespace FileUtils