Prevent concurrent access during close and delete of archive (#917)

src/cpp/helpers/ArchiveWriter.cpp

@@ -3,6 +3,7 @@
 #include <time.h>
 
 #include <iostream>
+#include <mutex>
 #include <sstream>
 
 #include "LogUtils.h"
@@ -26,12 +27,13 @@ void ArchiveWriter::InitFileInfo() {
 }
 int32_t ArchiveWriter::Open() {
   // disk-spanning is disabled, meaning that only one file is created
+  std::unique_lock lock(mutex_);
   const auto err = mz_zip_writer_open_file(
       pmz_zip_writer_instance_, ArchivePath().string().c_str(),
       0 /* disk-spanning disabled */, 1 /* append */);
   if (err != MZ_OK) {
-    Close();
-    Delete();
+    CloseUnsafe();
+    DeleteUnsafe();
     std::stringstream errMsg;
     errMsg << "Open Archive: " << ArchivePath().string() << std::endl;
     throw ArchiveIOGeneralException(err, errMsg.str(), LOGLOCATION);
@@ -125,6 +127,33 @@ int32_t ArchiveWriter::CloseInternal() {
   return MZ_OK;
 }
 
+/**
+ * @brief Close the archive
+ * Not thread safe
+ * Meant to be used with DeleteUnsafe and both of them guarded by a single mutex
+ * to prevent concurrency issues between Close() and Delete()
+ *
+ * @return int32_t
+ */
+int32_t ArchiveWriter::CloseUnsafe() {
+  if (pmz_zip_writer_instance_) {
+    return mz_zip_writer_close(pmz_zip_writer_instance_);
+  }
+  return MZ_OK;
+}
+
+/**
+ * @brief Delete the archive
+ * Not thread safe
+ * Meant to be used with CloseUnsafe and both of them guarded by a single mutex
+ * to prevent concurrency issues between Close() and Delete()
+ *
+ * @return int32_t
+ */
+void ArchiveWriter::DeleteUnsafe() {
+  return mz_zip_writer_delete(&pmz_zip_writer_instance_);
+}
+
 void ArchiveWriter::DeleteInternal() {
   std::unique_lock lock(mutex_);
   return mz_zip_writer_delete(&pmz_zip_writer_instance_);

src/cpp/helpers/ArchiveWriter.h

@@ -22,6 +22,8 @@ class ArchiveWriter : public ArchiveIO {
 
   int32_t Close() override;
   void Delete() override;
+  int32_t CloseUnsafe();
+  void DeleteUnsafe();
 
   int Open() override;
   void InitFileInfo();