update

Former-commit-id: 1cbe55a405e356f7361cd807a80662b81ee522f8

cpp/CMakeLists.txt

@@ -113,21 +113,13 @@ link_directories(${MILVUS_BINARY_DIR})
 
 set(MILVUS_ENGINE_INCLUDE ${PROJECT_SOURCE_DIR}/include)
 set(MILVUS_ENGINE_SRC ${PROJECT_SOURCE_DIR}/src)
-#set(MILVUS_THIRD_PARTY ${CMAKE_CURRENT_SOURCE_DIR}/third_party)
-#set(MILVUS_THIRD_PARTY_BUILD ${CMAKE_CURRENT_SOURCE_DIR}/third_party/build)
 
 add_compile_definitions(PROFILER=${PROFILER})
 
 include_directories(${MILVUS_ENGINE_INCLUDE})
 include_directories(${MILVUS_ENGINE_SRC})
-include_directories(/usr/local/cuda/include)
-#include_directories(${MILVUS_THIRD_PARTY_BUILD}/include)
 
 link_directories(${CMAKE_CURRRENT_BINARY_DIR})
-#link_directories(${MILVUS_THIRD_PARTY_BUILD}/lib)
-#link_directories(${MILVUS_THIRD_PARTY_BUILD}/lib64)
-#execute_process(COMMAND bash build.sh
-#                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/third_party)
 
 add_subdirectory(src)
 

cpp/mysqlNotes

-sudo apt-get install mysql-server
-sudo apt-get install libmysqlclient-dev
-sudo ln -s libmysqlclient.so libmysqlclient_r.so
-
-Install MySQL++
-./configure --enable-thread-check LDFLAGS='-pthread'
-make
-sudo make install

cpp/src/db/DBImpl.cpp

@@ -139,7 +139,7 @@ DBImpl::DBImpl(const Options& options)
     meta_ptr_ = DBMetaImplFactory::Build(options.meta, options.mode);
     mem_mgr_ = std::make_shared<MemManager>(meta_ptr_, options_);
     // mem_mgr_ = (MemManagerPtr)(new MemManager(meta_ptr_, options_));
-    if (options.mode != "read_only") {
+    if (options.mode != Options::MODE::READ_ONLY) {
         StartTimerTasks();
     }
 }
@@ -600,7 +600,7 @@ void DBImpl::BackgroundCompaction(std::set<std::string> table_ids) {
     meta_ptr_->Archive();
 
     int ttl = 1;
-    if (options_.mode == "cluster") {
+    if (options_.mode == Options::MODE::CLUSTER) {
         ttl = meta::D_SEC;
 //        ENGINE_LOG_DEBUG << "Server mode is cluster. Clean up files with ttl = " << std::to_string(ttl) << "seconds.";
     }

cpp/src/db/Factories.cpp

@@ -29,15 +29,8 @@ DBMetaOptions DBMetaOptionsFactory::Build(const std::string& path) {
         p = ss.str();
     }
 
-//    std::string uri;
-//    const char* uri_p = getenv("MILVUS_DB_META_URI");
-//    if (uri_p) {
-//        uri = uri_p;
-//    }
-
     DBMetaOptions meta;
     meta.path = p;
-//    meta.backend_uri = uri;
     return meta;
 }
 
@@ -54,14 +47,9 @@ std::shared_ptr<meta::DBMetaImpl> DBMetaImplFactory::Build() {
 }
 
 std::shared_ptr<meta::Meta> DBMetaImplFactory::Build(const DBMetaOptions& metaOptions,
-                                                     const std::string& mode) {
+                                                     const int& mode) {
 
     std::string uri = metaOptions.backend_uri;
-//    if (uri.empty()) {
-//        //Default to sqlite if uri is empty
-////        return std::make_shared<meta::DBMetaImpl>(new meta::DBMetaImpl(metaOptions));
-//        return std::shared_ptr<meta::DBMetaImpl>(new meta::DBMetaImpl(metaOptions));
-//    }
 
     std::string dialectRegex = "(.*)";
     std::string usernameRegex = "(.*)";

cpp/src/db/Factories.h

@@ -28,7 +28,7 @@ struct OptionsFactory {
 
 struct DBMetaImplFactory {
     static std::shared_ptr<meta::DBMetaImpl> Build();
-    static std::shared_ptr<meta::Meta> Build(const DBMetaOptions& metaOptions, const std::string& mode);
+    static std::shared_ptr<meta::Meta> Build(const DBMetaOptions& metaOptions, const int& mode);
 };
 
 struct DBFactory {

cpp/src/db/MySQLConnectionPool.h

@@ -20,12 +20,12 @@ public:
                         password_(passWord),
                         server_(serverIp),
                         port_(port),
-                        maxPoolSize_(maxPoolSize)
+                        max_pool_size_(maxPoolSize)
                         {
 
         conns_in_use_ = 0;
 
-        maxIdleTime_ = 300; //300ms
+        max_idle_time_ = 10; //10 seconds
     }
 
     // The destructor.  We _must_ call ConnectionPool::clear() here,
@@ -40,12 +40,10 @@ public:
     // connections actually in use, not those created.  Also note that
     // we keep our own count; ConnectionPool::size() isn't the same!
     mysqlpp::Connection* grab() override {
-        while (conns_in_use_ > maxPoolSize_) {
-//            cout.put('R'); cout.flush(); // indicate waiting for release
+        while (conns_in_use_ > max_pool_size_) {
             sleep(1);
         }
 
-//        ENGINE_LOG_DEBUG << "conns_in_use_ in grab: " << conns_in_use_ << std::endl;
         ++conns_in_use_;
         return mysqlpp::ConnectionPool::grab();
     }
@@ -63,7 +61,7 @@ public:
     }
 
     void set_max_idle_time(int max_idle) {
-        maxIdleTime_ = max_idle;
+        max_idle_time_ = max_idle;
     }
 
 protected:
@@ -72,7 +70,6 @@ protected:
     mysqlpp::Connection* create() override {
         // Create connection using the parameters we were passed upon
         // creation.
-//        cout.put('C'); cout.flush(); // indicate connection creation
         mysqlpp::Connection* conn = new mysqlpp::Connection();
         conn->set_option(new mysqlpp::ReconnectOption(true));
         conn->connect(db_.empty() ? 0 : db_.c_str(),
@@ -86,12 +83,11 @@ protected:
     void destroy(mysqlpp::Connection* cp) override {
         // Our superclass can't know how we created the Connection, so
         // it delegates destruction to us, to be safe.
-//        cout.put('D'); cout.flush(); // indicate connection destruction
         delete cp;
     }
 
     unsigned int max_idle_time() override {
-        return maxIdleTime_;
+        return max_idle_time_;
     }
 
 private:
@@ -102,7 +98,7 @@ private:
     std::string db_, user_, password_, server_;
     int port_;
 
-    int maxPoolSize_;
+    int max_pool_size_;
 
-    unsigned int maxIdleTime_;
+    unsigned int max_idle_time_;
 };
\ No newline at end of file

cpp/src/db/MySQLMetaImpl.h

@@ -22,7 +22,7 @@ namespace meta {
 
     class MySQLMetaImpl : public Meta {
     public:
-        MySQLMetaImpl(const DBMetaOptions& options_, const std::string& mode);
+        MySQLMetaImpl(const DBMetaOptions& options_, const int& mode);
 
         virtual Status CreateTable(TableSchema& table_schema) override;
         virtual Status DescribeTable(TableSchema& group_info_) override;
@@ -77,9 +77,9 @@ namespace meta {
         Status Initialize();
 
         const DBMetaOptions options_;
-        const std::string mode_;
+        const int mode_;
 
-        std::shared_ptr<MySQLConnectionPool> mySQLConnectionPool_;
+        std::shared_ptr<MySQLConnectionPool> mysql_connection_pool_;
         bool safe_grab = false;
 
 //        std::mutex connectionMutex_;

cpp/src/db/Options.h

@@ -45,15 +45,23 @@ struct DBMetaOptions {
     std::string path;
     std::string backend_uri;
     ArchiveConf archive_conf = ArchiveConf("delete");
+    bool sql_echo = false;
 }; // DBMetaOptions
 
 struct Options {
+
+    typedef enum {
+        SINGLE,
+        CLUSTER,
+        READ_ONLY
+    } MODE;
+
     Options();
     uint16_t  memory_sync_interval = 1;             //unit: second
     uint16_t  merge_trigger_number = 2;
     size_t  index_trigger_size = ONE_GB;            //unit: byte
     DBMetaOptions meta;
-    std::string mode;
+    int mode = MODE::SINGLE;
 }; // Options
 
 

cpp/src/server/DBWrapper.cpp

@@ -23,9 +23,30 @@ DBWrapper::DBWrapper() {
     if(index_size > 0) {//ensure larger than zero, unit is MB
         opt.index_trigger_size = (size_t)index_size * engine::ONE_MB;
     }
+    std::string sql_echo = config.GetValue(CONFIG_DB_SQL_ECHO, "off");
+    if (sql_echo == "on") {
+        opt.meta.sql_echo = true;
+    }
+    else if (sql_echo == "off") {
+        opt.meta.sql_echo = false;
+    }
+    else {
+        std::cout << "ERROR: sql_echo specified in db_config is not one of ['on', 'off']" << std::endl;
+        kill(0, SIGUSR1);
+    }
+
     ConfigNode& serverConfig = ServerConfig::GetInstance().GetConfig(CONFIG_SERVER);
-    opt.mode = serverConfig.GetValue(CONFIG_CLUSTER_MODE, "single");
-    if (opt.mode != "single" && opt.mode != "cluster" && opt.mode != "read_only") {
+    std::string mode = serverConfig.GetValue(CONFIG_CLUSTER_MODE, "single");
+    if (mode == "single") {
+        opt.mode = zilliz::milvus::engine::Options::MODE::SINGLE;
+    }
+    else if (mode == "cluster") {
+        opt.mode = zilliz::milvus::engine::Options::MODE::CLUSTER;
+    }
+    else if (mode == "read_only") {
+        opt.mode = zilliz::milvus::engine::Options::MODE::READ_ONLY;
+    }
+    else {
         std::cout << "ERROR: mode specified in server_config is not one of ['single', 'cluster', 'read_only']" << std::endl;
         kill(0, SIGUSR1);
     }

cpp/src/server/ServerConfig.h

@@ -27,6 +27,7 @@ static const std::string CONFIG_DB_PATH = "db_path";
 static const std::string CONFIG_DB_INDEX_TRIGGER_SIZE = "index_building_threshold";
 static const std::string CONFIG_DB_ARCHIVE_DISK = "archive_disk_threshold";
 static const std::string CONFIG_DB_ARCHIVE_DAYS = "archive_days_threshold";
+static const std::string CONFIG_DB_SQL_ECHO = "sql_echo";
 
 static const std::string CONFIG_LOG = "log_config";