fix a few issues in BackupNoAuthSysTest (#8868)

arangod/GeneralServer/GeneralServer.cpp

@@ -97,11 +97,11 @@ bool GeneralServer::openEndpoint(IoContext& ioContext, Endpoint* endpoint) {
   return true;
 }
 
-GeneralServer::IoThread::~IoThread() { shutdown(); }
-
 GeneralServer::IoThread::IoThread(IoContext& iocontext)
     : Thread("Io"), _iocontext(iocontext) {}
 
+GeneralServer::IoThread::~IoThread() { shutdown(); }
+
 void GeneralServer::IoThread::run() {
   // run the asio io context
   _iocontext._asioIoContext.run();
@@ -111,8 +111,7 @@ GeneralServer::IoContext::IoContext()
     : _clients(0),
       _thread(*this),
       _asioIoContext(1),  // only a single thread per context
-      _asioWork(_asioIoContext),
+      _asioWork(_asioIoContext) {
-      _stopped(false) {
   _thread.start();
 }
 

arangod/GeneralServer/GeneralServer.h

@@ -73,7 +73,6 @@ class GeneralServer {
     IoThread _thread;
     asio_ns::io_context _asioIoContext;
     asio_ns::io_context::work _asioWork;
-    std::atomic<bool> _stopped;
 
    public:
     IoContext();

arangod/GeneralServer/GeneralServerFeature.cpp

@@ -120,7 +120,6 @@ GeneralServerFeature::GeneralServerFeature(application_features::ApplicationServ
       _numIoThreads(0) {
   setOptional(true);
   startsAfter("AQLPhase");
-
   startsAfter("Endpoint");
   startsAfter("Upgrade");
   startsAfter("SslServer");
@@ -249,10 +248,7 @@ void GeneralServerFeature::stop() {
 }
 
 void GeneralServerFeature::unprepare() {
-  for (auto& server : _servers) {
+  _servers.clear();
-    delete server;
-  }
-
   _jobManager.reset();
 
   GENERAL_SERVER = nullptr;
@@ -284,10 +280,9 @@ void GeneralServerFeature::buildServers() {
     ssl->SSL->verifySslOptions();
   }
 
-  GeneralServer* server = new GeneralServer(_numIoThreads);
+  auto server = std::make_unique<GeneralServer>(_numIoThreads);
-
   server->setEndpointList(&endpointList);
-  _servers.push_back(server);
+  _servers.push_back(std::move(server));
 }
 
 void GeneralServerFeature::defineHandlers() {

arangod/GeneralServer/GeneralServerFeature.h

@@ -96,15 +96,6 @@ class GeneralServerFeature final : public application_features::ApplicationFeatu
   void stop() override final;
   void unprepare() override final;
  
- private:
-  double _keepAliveTimeout = 300.0;
-  bool _allowMethodOverride;
-
-  bool _proxyCheck;
-  std::vector<std::string> _trustedProxies;
-  std::vector<std::string> _accessControlAllowOrigins;
-
- public:
   bool proxyCheck() const { return _proxyCheck; }
   std::vector<std::string> trustedProxies() const { return _trustedProxies; }
  
@@ -112,10 +103,16 @@ class GeneralServerFeature final : public application_features::ApplicationFeatu
   void buildServers();
   void defineHandlers();
 
+ private:
+  double _keepAliveTimeout = 300.0;
+  bool _allowMethodOverride;
+  bool _proxyCheck;
+  std::vector<std::string> _trustedProxies;
+  std::vector<std::string> _accessControlAllowOrigins;
   std::unique_ptr<rest::RestHandlerFactory> _handlerFactory;
   std::unique_ptr<rest::AsyncJobManager> _jobManager;
   std::unique_ptr<std::pair<aql::QueryRegistry*, traverser::TraverserEngineRegistry*>> _combinedRegistries;
-  std::vector<rest::GeneralServer*> _servers;
+  std::vector<std::unique_ptr<rest::GeneralServer>> _servers;
   uint64_t _numIoThreads;
 };
 

arangod/GeneralServer/IoTask.h

@@ -46,10 +46,6 @@ class IoTask : public std::enable_shared_from_this<IoTask> {
  public:
   std::string const& name() const { return _name; }
 
-  // get a VelocyPack representation of the IoTask for reporting
-  std::shared_ptr<arangodb::velocypack::Builder> toVelocyPack() const;
-  void toVelocyPack(arangodb::velocypack::Builder&) const;
-
  protected:
   GeneralServer::IoContext& _context;
   GeneralServer& _server;

arangod/GeneralServer/ListenTask.cpp

@@ -72,7 +72,7 @@ bool ListenTask::start() {
 }
 
 void ListenTask::accept() {
-  auto self(shared_from_this());
+  auto self = shared_from_this();
 
   auto handler = [this, self](asio_ns::error_code const& ec) {
     TRI_ASSERT(_acceptor != nullptr);

arangod/Scheduler/SchedulerFeature.cpp

@@ -68,7 +68,8 @@ namespace arangodb {
 Scheduler* SchedulerFeature::SCHEDULER = nullptr;
 
 SchedulerFeature::SchedulerFeature(application_features::ApplicationServer& server)
-    : ApplicationFeature(server, "Scheduler"), _scheduler(nullptr) {
+    : ApplicationFeature(server, "Scheduler"), 
+      _scheduler(nullptr) {
   setOptional(false);
   startsAfter("GreetingsPhase");
   startsAfter("FileDescriptors");

arangosh/Restore/RestoreFeature.cpp

@@ -156,8 +156,8 @@ arangodb::Result checkHttpResponse(arangodb::httpclient::SimpleHttpClient& clien
   if (response == nullptr || !response->isComplete()) {
     return {TRI_ERROR_INTERNAL,
             "got invalid response from server: '" + client.getErrorMessage() +
-                "' while executing " + requestAction + " with this payload: '" +
+                "' while executing " + requestAction + (originalRequest.empty() ? "" : " with this payload: '" +
-                originalRequest + "'"};
+                originalRequest + "'")};
   }
   if (response->wasHttpError()) {
     int errorNum = TRI_ERROR_INTERNAL;
@@ -171,7 +171,7 @@ arangodb::Result checkHttpResponse(arangodb::httpclient::SimpleHttpClient& clien
     return {errorNum, "got invalid response from server: HTTP " +
                           itoa(response->getHttpReturnCode()) + ": '" +
                           errorMsg + "' while executing '" + requestAction +
-                          "' with this payload: '" + originalRequest + "'"};
+                          (originalRequest.empty() ? "" : "' with this payload: '" + originalRequest + "'")};
   }
   return {TRI_ERROR_NO_ERROR};
 }
@@ -609,7 +609,6 @@ arangodb::Result restoreData(arangodb::httpclient::SimpleHttpClient& httpClient,
 
   arangodb::Result result;
   StringBuffer buffer(true);
-  bool isGzip(false);
 
   VPackSlice const parameters = jobData.collection.get("parameters");
   std::string const cname =
@@ -625,20 +624,16 @@ arangodb::Result restoreData(arangodb::httpclient::SimpleHttpClient& httpClient,
   if (!datafile || datafile->status().fail()) {
     datafile = jobData.directory.readableFile(
       cname + "_" + arangodb::rest::SslInterface::sslMD5(cname) + ".data.json.gz");
-    isGzip = true;
+  }
-  } // if
   if (!datafile || datafile->status().fail()) {
-    datafile = jobData.directory.readableFile(
+    datafile = jobData.directory.readableFile(cname + ".data.json.gz");
-      cname + ".data.json.gz");
+  } 
-    isGzip = true;
-  } // if
   if (!datafile || datafile->status().fail()) {
     datafile = jobData.directory.readableFile(cname + ".data.json");
-    isGzip = false;
-    if (!datafile || datafile->status().fail()) {
-      result = {TRI_ERROR_CANNOT_READ_FILE, "could not open file"};
-      return result;
   }
+  if (!datafile || datafile->status().fail()) {
+    result = {TRI_ERROR_CANNOT_READ_FILE, "could not open data file for collection '" + cname + "'"};
+    return result;
   }
   
   int64_t const fileSize = TRI_SizeFile(datafile->path().c_str());
@@ -652,6 +647,8 @@ arangodb::Result restoreData(arangodb::httpclient::SimpleHttpClient& httpClient,
   int64_t numReadForThisCollection = 0;
   int64_t numReadSinceLastReport = 0;
   
+  bool const isGzip = (0 == datafile->path().substr(datafile->path().size() - 3).compare(".gz"));
+
   buffer.clear();
   while (true) {
     if (buffer.reserve(16384) != TRI_ERROR_NO_ERROR) {

arangosh/Utils/ManagedDirectory.cpp

@@ -305,12 +305,9 @@ EncryptionFeature const* ManagedDirectory::encryptionFeature() const {
 
 std::unique_ptr<ManagedDirectory::File> ManagedDirectory::readableFile(std::string const& filename,
                                                                        int flags) {
-  std::unique_ptr<File> file{nullptr};
+  std::unique_ptr<File> file;
-
-  if (_status.fail()) {  // directory is in a bad state
-    return file;
-  }
 
+  if (!_status.fail()) {  // directory is in a bad state?
     try {
       bool gzFlag = (0 == filename.substr(filename.size() - 3).compare(".gz"));
       file = std::make_unique<File>(*this, filename,
@@ -319,7 +316,8 @@ std::unique_ptr<ManagedDirectory::File> ManagedDirectory::readableFile(std::stri
       _status.reset(TRI_ERROR_CANNOT_READ_FILE, "error opening file " +
                                                     ::filePath(*this, filename) +
                                                     " for reading");
-    return {nullptr};
+      file.reset();
+    }
   }
 
   return file;
@@ -327,7 +325,7 @@ std::unique_ptr<ManagedDirectory::File> ManagedDirectory::readableFile(std::stri
 
 std::unique_ptr<ManagedDirectory::File> ManagedDirectory::writableFile(
   std::string const& filename, bool overwrite, int flags, bool gzipOk) {
-  std::unique_ptr<File> file{nullptr};
+  std::unique_ptr<File> file;
 
   if (_status.fail()) {  // directory is in a bad state
     return file;
@@ -352,7 +350,7 @@ std::unique_ptr<ManagedDirectory::File> ManagedDirectory::writableFile(
       }
     }
 
-    file = std::make_unique<File>(*this, filename,
+    file = std::make_unique<File>(*this, filenameCopy,
                                   (ManagedDirectory::DefaultWriteFlags ^ flags), _writeGzip && gzipOk);
   } catch (...) {
     return {nullptr};
@@ -464,18 +462,14 @@ void ManagedDirectory::File::write(char const* data, size_t length) {
     if (!written) {
       _status = _context->status();
     }
-  } else if (isGzip()) {
+    return;
-    gzwrite(_gzFile, data, length);
-  } else {
-    ::rawWrite(_fd, data, length, _status, _path, _flags);
   }
-#else
+#endif
   if (isGzip()) {
     gzwrite(_gzFile, data, length);
   } else {
     ::rawWrite(_fd, data, length, _status, _path, _flags);
-  } // else
+  }
-#endif
 }
 
 ssize_t ManagedDirectory::File::read(char* buffer, size_t length) {
@@ -490,27 +484,20 @@ ssize_t ManagedDirectory::File::read(char* buffer, size_t length) {
     if (bytesRead < 0) {
       _status = _context->status();
     }
-  } else if (isGzip()) {
+    return bytesRead;
-    bytesRead = gzread(_gzFile, buffer, length);
-  } else {
-    bytesRead = ::rawRead(_fd, buffer, length, _status, _path, _flags);
   }
-#else
+#endif
   if (isGzip()) {
     bytesRead = gzread(_gzFile, buffer, length);
   } else {
     bytesRead = ::rawRead(_fd, buffer, length, _status, _path, _flags);
   } // else
-#endif
   return bytesRead;
 }
 
 std::string ManagedDirectory::File::slurp() {
   std::string content;
-  if (!::isReadable(_fd, _flags, _path, _status)) {
+  if (::isReadable(_fd, _flags, _path, _status)) {
-    return content;
-  }
-
     char buffer[::DefaultIOChunkSize];
     while (true) {
       ssize_t bytesRead = read(buffer, ::DefaultIOChunkSize);
@@ -521,7 +508,7 @@ std::string ManagedDirectory::File::slurp() {
         break;
       }
     }
-
+  }
   return content;
 }
 

arangosh/Utils/ManagedDirectory.h

@@ -220,7 +220,7 @@ class ManagedDirectory {
    * @return           Unique pointer to file, if opened
    */
   std::unique_ptr<File> writableFile(std::string const& filename,
-                                     bool overwrite, int flags = 0, bool gzipOk = true );
+                                     bool overwrite, int flags = 0, bool gzipOk = true);
 
   /**
    * @brief Write a string to file

lib/Rest/Version.cpp

@@ -120,6 +120,11 @@ void Version::initialize() {
   Values["icu-version"] = getICUVersion();
   Values["openssl-version-compile-time"] = getOpenSSLVersion(true);
   Values["openssl-version-run-time"] = getOpenSSLVersion(false);
+#ifdef __pie__
+  Values["pie"] = std::to_string(__pie__);
+#else 
+  Values["pie"] = "none";
+#endif
   Values["platform"] = TRI_PLATFORM;
   Values["reactor-type"] = getBoostReactorType();
   Values["server-version"] = getServerVersion();