Merge pull request #1212 from Project-OSRM/fix_997

implements and fixes #997: support base path for c'tor

Library/OSRM.h

@@ -46,7 +46,7 @@ class OSRM
     std::unique_ptr<OSRM_impl> OSRM_pimpl_;
 
   public:
-    explicit OSRM(const ServerPaths &paths, const bool use_shared_memory = false);
+    explicit OSRM(ServerPaths paths, const bool use_shared_memory = false);
     ~OSRM();
     void RunQuery(RouteParameters &route_parameters, http::Reply &reply);
 };

Library/OSRM_impl.cpp

@@ -46,6 +46,7 @@ namespace boost { namespace interprocess { class named_mutex; } }
 #include "../Server/DataStructures/SharedBarriers.h"
 #include "../Server/DataStructures/SharedDataFacade.h"
 #include "../Util/make_unique.hpp"
+#include "../Util/ProgramOptions.h"
 #include "../Util/SimpleLogger.h"
 
 #include <boost/assert.hpp>
@@ -57,16 +58,17 @@ namespace boost { namespace interprocess { class named_mutex; } }
 #include <utility>
 #include <vector>
 
-OSRM_impl::OSRM_impl(const ServerPaths &server_paths, const bool use_shared_memory)
+OSRM_impl::OSRM_impl(ServerPaths server_paths, const bool use_shared_memory)
-    : use_shared_memory(use_shared_memory)
 {
     if (use_shared_memory)
     {
-        barrier = new SharedBarriers();
+        barrier = osrm::make_unique<SharedBarriers>();
         query_data_facade = new SharedDataFacade<QueryEdge::EdgeData>();
     }
     else
     {
+        // populate base path
+        populate_base_path(server_paths);
         query_data_facade = new InternalDataFacade<QueryEdge::EdgeData>(server_paths);
     }
 
@@ -86,10 +88,6 @@ OSRM_impl::~OSRM_impl()
     {
         delete plugin_pointer.second;
     }
-    if (use_shared_memory)
-    {
-        delete barrier;
-    }
 }
 
 void OSRM_impl::RegisterPlugin(BasePlugin *plugin)
@@ -109,7 +107,7 @@ void OSRM_impl::RunQuery(RouteParameters &route_parameters, http::Reply &reply)
     if (plugin_map.end() != iter)
     {
         reply.status = http::Reply::ok;
-        if (use_shared_memory)
+        if (barrier)
         {
             // lock update pending
             boost::interprocess::scoped_lock<boost::interprocess::named_mutex> pending_lock(
@@ -130,7 +128,7 @@ void OSRM_impl::RunQuery(RouteParameters &route_parameters, http::Reply &reply)
         }
 
         iter->second->HandleRequest(route_parameters, reply);
-        if (use_shared_memory)
+        if (barrier)
         {
             // lock query
             boost::interprocess::scoped_lock<boost::interprocess::named_mutex> query_lock(
@@ -155,7 +153,7 @@ void OSRM_impl::RunQuery(RouteParameters &route_parameters, http::Reply &reply)
 
 // proxy code for compilation firewall
 
-OSRM::OSRM(const ServerPaths &paths, const bool use_shared_memory)
+OSRM::OSRM(ServerPaths paths, const bool use_shared_memory)
     : OSRM_pimpl_(osrm::make_unique<OSRM_impl>(paths, use_shared_memory))
 {
 }

Library/OSRM_impl.h

@@ -36,6 +36,7 @@ struct RouteParameters;
 
 #include "../DataStructures/QueryEdge.h"
 
+#include <memory>
 #include <unordered_map>
 #include <string>
 
@@ -48,7 +49,7 @@ class OSRM_impl
     using PluginMap = std::unordered_map<std::string, BasePlugin *>;
 
   public:
-    OSRM_impl(const ServerPaths &paths, const bool use_shared_memory);
+    OSRM_impl(ServerPaths paths, const bool use_shared_memory);
     OSRM_impl(const OSRM_impl &) = delete;
     virtual ~OSRM_impl();
     void RunQuery(RouteParameters &route_parameters, http::Reply &reply);
@@ -56,8 +57,8 @@ class OSRM_impl
   private:
     void RegisterPlugin(BasePlugin *plugin);
     PluginMap plugin_map;
-    bool use_shared_memory;
+    // will only be initialized if shared memory is used
-    SharedBarriers *barrier;
+    std::unique_ptr<SharedBarriers> barrier;
     // base class pointer to the objects
     BaseDataFacade<QueryEdge::EdgeData> *query_data_facade;
 };

Util/ProgramOptions.h

@@ -45,6 +45,104 @@ const static unsigned INIT_OK_START_ENGINE = 0;
 const static unsigned INIT_OK_DO_NOT_START_ENGINE = 1;
 const static unsigned INIT_FAILED = -1;
 
+inline void populate_base_path(ServerPaths &server_paths)
+{
+    // populate the server_path object
+    auto path_iterator = server_paths.find("base");
+
+    // if a base path has been set, we populate it.
+    if (path_iterator != server_paths.end())
+    {
+        const std::string base_string = path_iterator->second.string();
+        SimpleLogger().Write() << "populating base path: " << base_string;
+
+        server_paths["hsgrdata"] = base_string + ".hsgr";
+        BOOST_ASSERT(server_paths.find("hsgrdata") != server_paths.end());
+        server_paths["nodesdata"] = base_string + ".nodes";
+        BOOST_ASSERT(server_paths.find("nodesdata") != server_paths.end());
+        server_paths["edgesdata"] = base_string + ".edges";
+        BOOST_ASSERT(server_paths.find("edgesdata") != server_paths.end());
+        server_paths["geometries"] = base_string + ".geometry";
+        BOOST_ASSERT(server_paths.find("geometries") != server_paths.end());
+        server_paths["ramindex"] = base_string + ".ramIndex";
+        BOOST_ASSERT(server_paths.find("ramindex") != server_paths.end());
+        server_paths["fileindex"] = base_string + ".fileIndex";
+        BOOST_ASSERT(server_paths.find("fileindex") != server_paths.end());
+        server_paths["namesdata"] = base_string + ".names";
+        BOOST_ASSERT(server_paths.find("namesdata") != server_paths.end());
+        server_paths["timestamp"] = base_string + ".timestamp";
+        BOOST_ASSERT(server_paths.find("timestamp") != server_paths.end());
+    }
+
+    // check if files are give and whether they exist at all
+    path_iterator = server_paths.find("hsgrdata");
+    if (path_iterator == server_paths.end() ||
+        !boost::filesystem::is_regular_file(path_iterator->second))
+    {
+        if (path_iterator == server_paths.end())
+        {
+            SimpleLogger().Write() << "hsgrdata unset";
+        }
+        if (!boost::filesystem::is_regular_file(path_iterator->second))
+        {
+            SimpleLogger().Write() << "not a regular file";
+        }
+
+        throw OSRMException(".hsgr not found: " + path_iterator->second.string());
+    }
+
+    path_iterator = server_paths.find("nodesdata");
+    if (path_iterator == server_paths.end() ||
+        !boost::filesystem::is_regular_file(path_iterator->second))
+    {
+        throw OSRMException(".nodes not found");
+    }
+
+    path_iterator = server_paths.find("edgesdata");
+    if (path_iterator == server_paths.end() ||
+        !boost::filesystem::is_regular_file(path_iterator->second))
+    {
+        throw OSRMException(".edges not found");
+    }
+
+    path_iterator = server_paths.find("geometries");
+    if (path_iterator == server_paths.end() ||
+        !boost::filesystem::is_regular_file(path_iterator->second))
+    {
+        throw OSRMException(".geometry not found");
+    }
+
+    path_iterator = server_paths.find("ramindex");
+    if (path_iterator == server_paths.end() ||
+        !boost::filesystem::is_regular_file(path_iterator->second))
+    {
+        throw OSRMException(".ramIndex not found");
+    }
+
+    path_iterator = server_paths.find("fileindex");
+    if (path_iterator == server_paths.end() ||
+        !boost::filesystem::is_regular_file(path_iterator->second))
+    {
+        throw OSRMException(".fileIndex not found");
+    }
+
+    path_iterator = server_paths.find("namesdata");
+    if (path_iterator == server_paths.end() ||
+        !boost::filesystem::is_regular_file(path_iterator->second))
+    {
+        throw OSRMException(".namesIndex not found");
+    }
+
+    SimpleLogger().Write() << "HSGR file:\t" << server_paths["hsgrdata"];
+    SimpleLogger().Write(logDEBUG) << "Nodes file:\t" << server_paths["nodesdata"];
+    SimpleLogger().Write(logDEBUG) << "Edges file:\t" << server_paths["edgesdata"];
+    SimpleLogger().Write(logDEBUG) << "Geometry file:\t" << server_paths["geometries"];
+    SimpleLogger().Write(logDEBUG) << "RAM file:\t" << server_paths["ramindex"];
+    SimpleLogger().Write(logDEBUG) << "Index file:\t" << server_paths["fileindex"];
+    SimpleLogger().Write(logDEBUG) << "Names file:\t" << server_paths["namesdata"];
+    SimpleLogger().Write(logDEBUG) << "Timestamp file:\t" << server_paths["timestamp"];
+}
+
 // generate boost::program_options object for the routing part
 inline unsigned GenerateServerProgramOptions(const int argc,
                                              const char *argv[],
@@ -55,7 +153,6 @@ inline unsigned GenerateServerProgramOptions(const int argc,
                                              bool &use_shared_memory,
                                              bool &trial)
 {
-
     // declare a group of options that will be allowed only on command line
     boost::program_options::options_description generic_options("Options");
     generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message")(
@@ -169,94 +266,6 @@ inline unsigned GenerateServerProgramOptions(const int argc,
 
     if (!use_shared_memory && option_variables.count("base"))
     {
-        path_iterator = paths.find("base");
-        BOOST_ASSERT(paths.end() != path_iterator);
-        std::string base_string = path_iterator->second.string();
-
-        path_iterator = paths.find("hsgrdata");
-        if (path_iterator != paths.end() &&
-            !boost::filesystem::is_regular_file(path_iterator->second))
-        {
-            path_iterator->second = base_string + ".hsgr";
-        }
-        else
-        {
-            throw OSRMException(base_string + ".hsgr not found");
-        }
-
-        path_iterator = paths.find("nodesdata");
-        if (path_iterator != paths.end() &&
-            !boost::filesystem::is_regular_file(path_iterator->second))
-        {
-            path_iterator->second = base_string + ".nodes";
-        }
-        else
-        {
-            throw OSRMException(base_string + ".nodes not found");
-        }
-
-        path_iterator = paths.find("edgesdata");
-        if (path_iterator != paths.end() &&
-            !boost::filesystem::is_regular_file(path_iterator->second))
-        {
-            path_iterator->second = base_string + ".edges";
-        }
-        else
-        {
-            throw OSRMException(base_string + ".edges not found");
-        }
-
-        path_iterator = paths.find("geometries");
-        if (path_iterator != paths.end() &&
-            !boost::filesystem::is_regular_file(path_iterator->second))
-        {
-            path_iterator->second = base_string + ".geometry";
-        }
-        else
-        {
-            throw OSRMException(base_string + ".geometry not found");
-        }
-
-        path_iterator = paths.find("ramindex");
-        if (path_iterator != paths.end() &&
-            !boost::filesystem::is_regular_file(path_iterator->second))
-        {
-            path_iterator->second = base_string + ".ramIndex";
-        }
-        else
-        {
-            throw OSRMException(base_string + ".ramIndex not found");
-        }
-
-        path_iterator = paths.find("fileindex");
-        if (path_iterator != paths.end() &&
-            !boost::filesystem::is_regular_file(path_iterator->second))
-        {
-            path_iterator->second = base_string + ".fileIndex";
-        }
-        else
-        {
-            throw OSRMException(base_string + ".fileIndex not found");
-        }
-
-        path_iterator = paths.find("namesdata");
-        if (path_iterator != paths.end() &&
-            !boost::filesystem::is_regular_file(path_iterator->second))
-        {
-            path_iterator->second = base_string + ".names";
-        }
-        else
-        {
-            throw OSRMException(base_string + ".namesIndex not found");
-        }
-
-        path_iterator = paths.find("timestamp");
-        if (path_iterator != paths.end() &&
-            !boost::filesystem::is_regular_file(path_iterator->second))
-        {
-            path_iterator->second = base_string + ".timestamp";
-        }
-
         return INIT_OK_START_ENGINE;
     }
     if (use_shared_memory && !option_variables.count("base"))

routed.cpp

@@ -108,20 +108,10 @@ int main(int argc, const char *argv[])
         {
             SimpleLogger().Write(logDEBUG) << "Loading from shared memory";
         }
-        else
+
-        {
-            SimpleLogger().Write() << "HSGR file:\t" << server_paths["hsgrdata"];
-            SimpleLogger().Write(logDEBUG) << "Nodes file:\t" << server_paths["nodesdata"];
-            SimpleLogger().Write(logDEBUG) << "Edges file:\t" << server_paths["edgesdata"];
-            SimpleLogger().Write(logDEBUG) << "Geometry file:\t" << server_paths["geometries"];
-            SimpleLogger().Write(logDEBUG) << "RAM file:\t" << server_paths["ramindex"];
-            SimpleLogger().Write(logDEBUG) << "Index file:\t" << server_paths["fileindex"];
-            SimpleLogger().Write(logDEBUG) << "Names file:\t" << server_paths["namesdata"];
-            SimpleLogger().Write(logDEBUG) << "Timestamp file:\t" << server_paths["timestamp"];
         SimpleLogger().Write(logDEBUG) << "Threads:\t" << requested_thread_num;
         SimpleLogger().Write(logDEBUG) << "IP address:\t" << ip_address;
         SimpleLogger().Write(logDEBUG) << "IP port:\t" << ip_port;
-        }
 #ifndef _WIN32
         int sig = 0;
         sigset_t new_mask;