diff --git a/DataStructures/NodeInformationHelpDesk.h b/DataStructures/NodeInformationHelpDesk.h index d0721d03f..147c5985a 100644 --- a/DataStructures/NodeInformationHelpDesk.h +++ b/DataStructures/NodeInformationHelpDesk.h @@ -29,10 +29,11 @@ or see http://www.gnu.org/licenses/agpl.txt. #include "../typedefs.h" #include +#include +#include #include #include -#include #include #include @@ -137,19 +138,29 @@ public: private: void LoadNodesAndEdges( - const std::string & nodes_file, - const std::string & edges_file + const std::string & nodes_filename, + const std::string & edges_filename ) { - std::ifstream nodes_input_stream(nodes_file.c_str(), std::ios::binary); - if(!nodes_input_stream) { - throw OSRMException("nodes file not found"); + boost::filesystem::path nodes_file(nodes_filename); + if ( !boost::filesystem::exists( nodes_file ) ) { + throw OSRMException("nodes file does not exist"); } - std::ifstream edges_input_stream(edges_file.c_str(), std::ios::binary); - if(!edges_input_stream) { - throw OSRMException("edges file not found"); + if ( 0 == boost::filesystem::file_size( nodes_file ) ) { + throw OSRMException("nodes file is empty"); } - SimpleLogger().Write(logDEBUG) << "Loading node data" << nodes_file.length() << " ->" << nodes_file << "<-"; + boost::filesystem::path edges_file(edges_filename); + if ( !boost::filesystem::exists( edges_file ) ) { + throw OSRMException("edges file does not exist"); + } + if ( 0 == boost::filesystem::file_size( edges_file ) ) { + throw OSRMException("edges file is empty"); + } + + boost::filesystem::ifstream nodes_input_stream(nodes_file, std::ios::binary); + boost::filesystem::ifstream edges_input_stream(edges_file, std::ios::binary); + + SimpleLogger().Write(logDEBUG) << "Loading node data"; NodeInfo b; while(!nodes_input_stream.eof()) { nodes_input_stream.read((char *)&b, sizeof(NodeInfo)); diff --git a/DataStructures/StaticRTree.h b/DataStructures/StaticRTree.h index 02b372403..57c099b98 100644 --- a/DataStructures/StaticRTree.h +++ b/DataStructures/StaticRTree.h @@ -26,6 +26,7 @@ or see http://www.gnu.org/licenses/agpl.txt. #include "PhantomNodes.h" #include "DeallocatingVector.h" #include "HilbertValue.h" +#include "../Util/OSRMException.h" #include "../Util/SimpleLogger.h" #include "../Util/TimingUtil.h" #include "../typedefs.h" @@ -33,6 +34,8 @@ or see http://www.gnu.org/licenses/agpl.txt. #include #include #include +#include +#include #include #include #include @@ -44,7 +47,6 @@ or see http://www.gnu.org/licenses/agpl.txt. #include #include -#include #include #include #include @@ -55,7 +57,7 @@ const static uint32_t RTREE_LEAF_NODE_SIZE = 1170; // Implements a static, i.e. packed, R-tree -static boost::thread_specific_ptr thread_local_rtree_stream; +static boost::thread_specific_ptr thread_local_rtree_stream; template class StaticRTree : boost::noncopyable { @@ -309,7 +311,7 @@ public: } //open leaf file - std::ofstream leaf_node_file(leaf_node_filename.c_str(), std::ios::binary); + boost::filesystem::ofstream leaf_node_file(leaf_node_filename, std::ios::binary); leaf_node_file.write((char*) &m_element_count, sizeof(uint64_t)); //sort the hilbert-value representatives @@ -390,7 +392,11 @@ public: } //open tree file - std::ofstream tree_node_file(tree_node_filename.c_str(), std::ios::binary); + boost::filesystem::ofstream tree_node_file( + tree_node_filename, + std::ios::binary + ); + uint32_t size_of_tree = m_search_tree.size(); BOOST_ASSERT_MSG(0 < size_of_tree, "tree empty"); tree_node_file.write((char *)&size_of_tree, sizeof(uint32_t)); @@ -408,7 +414,16 @@ public: const std::string & leaf_filename ) : m_leaf_node_filename(leaf_filename) { //open tree node file and load into RAM. - std::ifstream tree_node_file(node_filename.c_str(), std::ios::binary); + boost::filesystem::path node_file(node_filename); + + if ( !boost::filesystem::exists( node_file ) ) { + throw OSRMException("ram index file does not exist"); + } + if ( 0 == boost::filesystem::file_size( node_file ) ) { + throw OSRMException("ram index file is empty"); + } + boost::filesystem::ifstream tree_node_file( node_file, std::ios::binary ); + uint32_t tree_size = 0; tree_node_file.read((char*)&tree_size, sizeof(uint32_t)); //SimpleLogger().Write() << "reading " << tree_size << " tree nodes in " << (sizeof(TreeNode)*tree_size) << " bytes"; @@ -417,7 +432,15 @@ public: tree_node_file.close(); //open leaf node file and store thread specific pointer - std::ifstream leaf_node_file(leaf_filename.c_str(), std::ios::binary); + boost::filesystem::path leaf_file(leaf_filename); + if ( !boost::filesystem::exists( leaf_file ) ) { + throw OSRMException("mem index file does not exist"); + } + if ( 0 == boost::filesystem::file_size( leaf_file ) ) { + throw OSRMException("mem index file is empty"); + } + + boost::filesystem::ifstream leaf_node_file( leaf_file, std::ios::binary ); leaf_node_file.read((char*)&m_element_count, sizeof(uint64_t)); leaf_node_file.close(); @@ -729,8 +752,8 @@ private: inline void LoadLeafFromDisk(const uint32_t leaf_id, LeafNode& result_node) { if(!thread_local_rtree_stream.get() || !thread_local_rtree_stream->is_open()) { thread_local_rtree_stream.reset( - new std::ifstream( - m_leaf_node_filename.c_str(), + new boost::filesystem::ifstream( + m_leaf_node_filename, std::ios::in | std::ios::binary ) ); diff --git a/Server/DataStructures/QueryObjectsStorage.cpp b/Server/DataStructures/QueryObjectsStorage.cpp index 258071e91..393fd1bf7 100644 --- a/Server/DataStructures/QueryObjectsStorage.cpp +++ b/Server/DataStructures/QueryObjectsStorage.cpp @@ -50,20 +50,15 @@ QueryObjectsStorage::QueryObjectsStorage( } SimpleLogger().Write() << "loading graph data"; - std::ifstream hsgrInStream(hsgrPath.c_str(), std::ios::binary); - if(!hsgrInStream) { - throw OSRMException("hsgr not found"); - } //Deserialize road network graph std::vector< QueryGraph::_StrNode> nodeList; std::vector< QueryGraph::_StrEdge> edgeList; const int n = readHSGRFromStream( - hsgrInStream, + hsgrPath, nodeList, edgeList, &checkSum ); - hsgrInStream.close(); SimpleLogger().Write() << "Data checksum is " << checkSum; graph = new QueryGraph(nodeList, edgeList); @@ -100,23 +95,31 @@ QueryObjectsStorage::QueryObjectsStorage( //deserialize street name list SimpleLogger().Write() << "Loading names index"; - std::ifstream namesInStream(namesPath.c_str(), std::ios::binary); - if(!namesInStream) { - throw OSRMException("names file not found"); + boost::filesystem::path names_file(namesPath); + + if ( !boost::filesystem::exists( names_file ) ) { + throw OSRMException("names file does not exist"); } - unsigned size(0); - namesInStream.read((char *)&size, sizeof(unsigned)); + if ( 0 == boost::filesystem::file_size( names_file ) ) { + throw OSRMException("names file is empty"); + } + + boost::filesystem::ifstream name_stream(names_file, std::ios::binary); + unsigned size = 0; + name_stream.read((char *)&size, sizeof(unsigned)); + BOOST_ASSERT_MSG(0 != size, "name file empty"); char buf[1024]; - for(unsigned i = 0; i < size; ++i) { - unsigned sizeOfString = 0; - namesInStream.read((char *)&sizeOfString, sizeof(unsigned)); - buf[sizeOfString] = '\0'; // instead of memset - namesInStream.read(buf, sizeOfString); + for( unsigned i = 0; i < size; ++i ) { + unsigned size_of_string = 0; + name_stream.read((char *)&size_of_string, sizeof(unsigned)); + buf[size_of_string] = '\0'; // instead of memset + name_stream.read(buf, size_of_string); names.push_back(buf); } std::vector(names).swap(names); - namesInStream.close(); + BOOST_ASSERT_MSG(0 != names.size(), "could not load any names"); + name_stream.close(); SimpleLogger().Write() << "All query data structures loaded"; } diff --git a/Server/DataStructures/QueryObjectsStorage.h b/Server/DataStructures/QueryObjectsStorage.h index 9d2429c0b..0f7ba2a6d 100644 --- a/Server/DataStructures/QueryObjectsStorage.h +++ b/Server/DataStructures/QueryObjectsStorage.h @@ -22,8 +22,6 @@ or see http://www.gnu.org/licenses/agpl.txt. #ifndef QUERYOBJECTSSTORAGE_H_ #define QUERYOBJECTSSTORAGE_H_ -#include -#include #include "../../Util/GraphLoader.h" #include "../../Util/OSRMException.h" #include "../../Util/SimpleLogger.h" @@ -31,6 +29,14 @@ or see http://www.gnu.org/licenses/agpl.txt. #include "../../DataStructures/QueryEdge.h" #include "../../DataStructures/StaticGraph.h" +#include +#include +#include + +#include +#include + + struct QueryObjectsStorage { typedef StaticGraph QueryGraph; typedef QueryGraph::InputEdge InputEdge; diff --git a/Util/GraphLoader.h b/Util/GraphLoader.h index c3c9a5c44..dcf78386a 100644 --- a/Util/GraphLoader.h +++ b/Util/GraphLoader.h @@ -31,6 +31,8 @@ or see http://www.gnu.org/licenses/agpl.txt. #include "../typedefs.h" #include +#include +#include #include #include @@ -398,40 +400,51 @@ NodeID readDDSGGraphFromStream(std::istream &in, std::vector& edgeList, s template unsigned readHSGRFromStream( - std::istream &hsgr_input_stream, + const std::string & hsgr_filename, std::vector & node_list, std::vector & edge_list, unsigned * check_sum ) { + boost::filesystem::path hsgr_file(hsgr_filename); + if ( !boost::filesystem::exists( hsgr_file ) ) { + throw OSRMException("hsgr file does not exist"); + } + if ( 0 == boost::filesystem::file_size( hsgr_file ) ) { + throw OSRMException("hsgr file is empty"); + } + + boost::filesystem::ifstream hsgr_input_stream(hsgr_file, std::ios::binary); + UUID uuid_loaded, uuid_orig; hsgr_input_stream.read((char *)&uuid_loaded, sizeof(UUID)); if( !uuid_loaded.TestGraphUtil(uuid_orig) ) { SimpleLogger().Write(logWARNING) << - ".hsgr was prepared with different build.\n" + ".hsgr was prepared with different build. " "Reprocess to get rid of this warning."; } unsigned number_of_nodes = 0; hsgr_input_stream.read((char*) check_sum, sizeof(unsigned)); hsgr_input_stream.read((char*) & number_of_nodes, sizeof(unsigned)); + BOOST_ASSERT_MSG( 0 != number_of_nodes, "number of nodes is zero"); node_list.resize(number_of_nodes + 1); hsgr_input_stream.read( (char*) &(node_list[0]), number_of_nodes*sizeof(NodeT) ); - unsigned number_of_edges = 0; hsgr_input_stream.read( (char*) &number_of_edges, sizeof(unsigned) ); + BOOST_ASSERT_MSG( 0 != number_of_edges, "number of edges is zero"); edge_list.resize(number_of_edges); hsgr_input_stream.read( (char*) &(edge_list[0]), number_of_edges*sizeof(EdgeT) ); - + hsgr_input_stream.close(); return number_of_nodes; }