diff --git a/arangod/GeneralServer/GeneralServer.cpp b/arangod/GeneralServer/GeneralServer.cpp
index cdac14573d..5a38607c3e 100644
--- a/arangod/GeneralServer/GeneralServer.cpp
+++ b/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),
-      _stopped(false) {
+      _asioWork(_asioIoContext) {
   _thread.start();
 }
 
diff --git a/arangod/GeneralServer/GeneralServer.h b/arangod/GeneralServer/GeneralServer.h
index 7cca2d868e..d9f012abfb 100644
--- a/arangod/GeneralServer/GeneralServer.h
+++ b/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();
diff --git a/arangod/GeneralServer/GeneralServerFeature.cpp b/arangod/GeneralServer/GeneralServerFeature.cpp
index 020f5a2bec..9ef61f8365 100644
--- a/arangod/GeneralServer/GeneralServerFeature.cpp
+++ b/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) {
-    delete server;
-  }
-
+  _servers.clear();
   _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() {
diff --git a/arangod/GeneralServer/GeneralServerFeature.h b/arangod/GeneralServer/GeneralServerFeature.h
index 896deaaef4..ed5649bf82 100644
--- a/arangod/GeneralServer/GeneralServerFeature.h
+++ b/arangod/GeneralServer/GeneralServerFeature.h
@@ -95,30 +95,27 @@ class GeneralServerFeature final : public application_features::ApplicationFeatu
   void start() override final;
   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; }
-
+ 
  private:
   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;
 };
 
 }  // namespace arangodb
 
-#endif
\ No newline at end of file
+#endif
diff --git a/arangod/GeneralServer/IoTask.h b/arangod/GeneralServer/IoTask.h
index 2241583ec2..4b942adc6a 100644
--- a/arangod/GeneralServer/IoTask.h
+++ b/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;
diff --git a/arangod/GeneralServer/ListenTask.cpp b/arangod/GeneralServer/ListenTask.cpp
index 253a3a2bed..273a084d79 100644
--- a/arangod/GeneralServer/ListenTask.cpp
+++ b/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);
diff --git a/arangod/Scheduler/SchedulerFeature.cpp b/arangod/Scheduler/SchedulerFeature.cpp
index 427bc2d3b9..5c1e756922 100644
--- a/arangod/Scheduler/SchedulerFeature.cpp
+++ b/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");
diff --git a/arangosh/Restore/RestoreFeature.cpp b/arangosh/Restore/RestoreFeature.cpp
index d3bb5873d3..3ce36619a6 100644
--- a/arangosh/Restore/RestoreFeature.cpp
+++ b/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: '" +
-                originalRequest + "'"};
+                "' while executing " + requestAction + (originalRequest.empty() ? "" : " with this payload: '" +
+                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,22 +624,18 @@ 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(
-      cname + ".data.json.gz");
-    isGzip = true;
-  } // if
+    datafile = jobData.directory.readableFile(cname + ".data.json.gz");
+  } 
   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());
 
   if (jobData.options.progress) {
@@ -651,6 +646,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) {
diff --git a/arangosh/Utils/ManagedDirectory.cpp b/arangosh/Utils/ManagedDirectory.cpp
index 8d0cba729a..06f80e52f7 100644
--- a/arangosh/Utils/ManagedDirectory.cpp
+++ b/arangosh/Utils/ManagedDirectory.cpp
@@ -305,21 +305,19 @@ 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;
-  }
-
-  try {
-    bool gzFlag = (0 == filename.substr(filename.size() - 3).compare(".gz"));
-    file = std::make_unique<File>(*this, filename,
-                                  (ManagedDirectory::DefaultReadFlags ^ flags), gzFlag);
-  } catch (...) {
-    _status.reset(TRI_ERROR_CANNOT_READ_FILE, "error opening file " +
-                                                  ::filePath(*this, filename) +
-                                                  " for reading");
-    return {nullptr};
+  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,
+                                    (ManagedDirectory::DefaultReadFlags ^ flags), gzFlag);
+    } catch (...) {
+      _status.reset(TRI_ERROR_CANNOT_READ_FILE, "error opening file " +
+                                                    ::filePath(*this, filename) +
+                                                    " for reading");
+      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()) {
-    gzwrite(_gzFile, data, length);
-  } else {
-    ::rawWrite(_fd, data, length, _status, _path, _flags);
+    return;
   }
-#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,38 +484,31 @@ ssize_t ManagedDirectory::File::read(char* buffer, size_t length) {
     if (bytesRead < 0) {
       _status = _context->status();
     }
-  } else if (isGzip()) {
-    bytesRead = gzread(_gzFile, buffer, length);
-  } else {
-    bytesRead = ::rawRead(_fd, buffer, length, _status, _path, _flags);
+    return bytesRead;
   }
-#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)) {
-    return content;
-  }
-
-  char buffer[::DefaultIOChunkSize];
-  while (true) {
-    ssize_t bytesRead = read(buffer, ::DefaultIOChunkSize);
-    if (_status.ok()) {
-      content.append(buffer, bytesRead);
-    }
-    if (bytesRead <= 0) {
-      break;
+  if (::isReadable(_fd, _flags, _path, _status)) {
+    char buffer[::DefaultIOChunkSize];
+    while (true) {
+      ssize_t bytesRead = read(buffer, ::DefaultIOChunkSize);
+      if (_status.ok()) {
+        content.append(buffer, bytesRead);
+      }
+      if (bytesRead <= 0) {
+        break;
+      }
     }
   }
-
   return content;
 }
 
diff --git a/arangosh/Utils/ManagedDirectory.h b/arangosh/Utils/ManagedDirectory.h
index dd0d684bf0..20a2d9e8a8 100644
--- a/arangosh/Utils/ManagedDirectory.h
+++ b/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
diff --git a/lib/Rest/Version.cpp b/lib/Rest/Version.cpp
index 38e0ef31cd..24dd6bdb86 100644
--- a/lib/Rest/Version.cpp
+++ b/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();