Merge pull request #174 from grc-iit/56-python-chronolog-client-bindings

56 python chronolog client bindings
grc-iit · Jun 7, 2024 · 7c1078a · 7c1078a
2 parents dc629db + 05be454
commit 7c1078a
Show file tree

Hide file tree

Showing 27 changed files with 333 additions and 149 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.19)
+cmake_minimum_required(VERSION 3.25)
 
 # Set a consistent MACOSX_RPATH default across all CMake versions.
 if(NOT DEFINED CMAKE_MACOSX_RPATH)
@@ -218,3 +218,8 @@ if(CHRONOLOG_BUILD_TESTING)
     enable_testing()
     add_subdirectory(test)
 endif()
+
+#if(CHRONOLOG_ENABLE_PYTHON_BINDINGS)
+message("Python binding enabled")
+add_subdirectory(python_client)
+#endif()
diff --git a/ChronoAPI/ChronoLog/include/log.h b/ChronoAPI/ChronoLog/include/log.h
@@ -54,7 +54,6 @@
 #define LOG_ERROR(...) Logger::getInstance().error(__VA_ARGS__)
 #define LOG_CRITICAL(...) Logger::getInstance().critical(__VA_ARGS__)
 
-
 /**
  * @class Logger
  * @brief The Logger class provides a singleton logger with customizable configuration.
@@ -86,8 +85,10 @@ class Logger
      *                     and returns 1 if there was an error during initialization.
      */
     static int initialize(const std::string &logType, const std::string &location, spdlog::level::level_enum logLevel
-                          , const std::string &loggerName, const std::size_t &logFileSize, const std::size_t &logFileNum
-                          , spdlog::level::level_enum flushLevel);
+                          , const std::string &loggerName
+                , const std::size_t &logFileSize = 104857600
+                , const std::size_t &logFileNum = 3
+                , spdlog::level::level_enum flushLevel = spdlog::level::warn);
 
 
     /**

diff --git a/ChronoVisor/include/Chronicle.h b/ChronoVisor/include/Chronicle.h
@@ -187,7 +187,7 @@ class Chronicle
     }
 
     std::pair <int, Story*>
-    addStory(const std::string &story_name, const std::unordered_map <std::string, std::string> &attrs)
+    addStory(const std::string &story_name, const std::map <std::string, std::string> &attrs)
     {
         /* Check if Story exists */
         std::string story_name_for_hash = name_ + story_name;

diff --git a/ChronoVisor/include/ChronicleMetaDirectory.h b/ChronoVisor/include/ChronicleMetaDirectory.h
@@ -26,17 +26,15 @@ class ChronicleMetaDirectory
     std::unordered_map <uint64_t, Chronicle*>*getChronicleMap()
     { return chronicleMap_; }
 
-    int create_chronicle(const std::string &name);
-
-    int create_chronicle(const std::string &name, const std::unordered_map <std::string, std::string> &attrs);
+    int create_chronicle(const std::string &name, const std::map <std::string, std::string> &attrs);
 
     int destroy_chronicle(const std::string &name);
 
     int destroy_story(std::string const &chronicle_name, const std::string &story_name);
 
     int
     acquire_story(chronolog::ClientId const &client_id, const std::string &chronicle_name, const std::string &story_name
-                  , const std::unordered_map <std::string, std::string> &attrs, int &flags, StoryId &);
+                  , const std::map <std::string, std::string> &attrs, int &flags, StoryId &);
 
     int
     release_story(chronolog::ClientId const &client_id, const std::string &chronicle_name, const std::string &story_name
@@ -54,8 +52,6 @@ class ChronicleMetaDirectory
     std::unordered_map <uint64_t, Chronicle*>*chronicleMap_;
     std::mutex g_chronicleMetaDirectoryMutex_;
     ClientRegistryManager*clientRegistryManager_ = nullptr;
-//    std::unordered_map<std::string, uint64_t> *chronicleName2IdMap_;
-//    std::unordered_map<uint64_t, std::string> *chronicleId2NameMap_;
 };
 
 #endif //CHRONOLOG_CHRONICLEMETADIRECTORY_H
diff --git a/ChronoVisor/include/ClientPortalService.h b/ChronoVisor/include/ClientPortalService.h
@@ -53,7 +53,7 @@ class ClientPortalService: public thallium::provider <ClientPortalService>
     }
 
     void CreateChronicle(tl::request const &request, ClientId const &client_id, std::string const &chronicle_name
-                         , const std::unordered_map <std::string, std::string> &attrs, int &flags)//old
+                         , const std::map <std::string, std::string> &attrs, int &flags)
     {
         int return_code = theVisorClientPortal.CreateChronicle(client_id, chronicle_name, attrs, flags);
         request.respond(return_code);
@@ -66,7 +66,7 @@ class ClientPortalService: public thallium::provider <ClientPortalService>
     }
 
     void AcquireStory(tl::request const &request, ClientId const &client_id, std::string const &chronicle_name
-                      , std::string const &story_name, const std::unordered_map <std::string, std::string> &attrs
+                      , std::string const &story_name, const std::map <std::string, std::string> &attrs
                       , int &flags)
     {
         AcquireStoryResponseMsg acquire_response = theVisorClientPortal.AcquireStory(client_id, chronicle_name

diff --git a/ChronoVisor/include/Story.h b/ChronoVisor/include/Story.h
@@ -6,6 +6,7 @@
 #define CHRONOLOG_STORY_H
 
 #include <unordered_map>
+#include <map>
 #include <atomic>
 #include <Event.h>
 #include <city.h>
@@ -132,7 +133,7 @@ class Story
         }
     }
 
-    void setProperty(const std::unordered_map <std::string, std::string> &attrs)
+    void setProperty(const std::map <std::string, std::string> &attrs)
     {
         for(auto const &entry: attrs)
         {

diff --git a/ChronoVisor/include/VisorClientPortal.h b/ChronoVisor/include/VisorClientPortal.h
@@ -42,25 +42,21 @@ class VisorClientPortal
 
     void ShutdownServices();
 
-//int ClientConnect( const std::string &uri, std::string const &client_account, uint32_t client_host_ip, ClientId &, uint64_t &clock_offset); //old
-
     int ClientConnect(uint32_t client_account, uint32_t client_host_ip, uint32_t client_pid, ClientId &
                       , uint64_t &clock_offset);
 
     int ClientDisconnect(ClientId const &client_id);
 
     int CreateChronicle(ClientId const &name, ChronicleName const &
-                        , const std::unordered_map <std::string, std::string> &attrs, int &flags);
+                        , const std::map <std::string, std::string> &attrs, int &flags);
 
     int DestroyChronicle(ClientId const &client_id, ChronicleName const &chronicle_name);
 
     int DestroyStory(ClientId const &client_id, std::string const &chronicle_name, std::string const &story_name);
 
     AcquireStoryResponseMsg AcquireStory(ClientId const &client_id,
-            //std::string const& client_id,
             std::string const &chronicle_name, std::string const &story_name
-                                         , const std::unordered_map <std::string, std::string> &attrs, int &flags);
-    //, AcquireStoryResponseMsg &);
+            , const std::map <std::string, std::string> &attrs, int &flags);
 
     int ReleaseStory(ClientId const &client_id, std::string const &chronicle_name, std::string const &story_name);
 

diff --git a/ChronoVisor/src/ChronicleMetaDirectory.cpp b/ChronoVisor/src/ChronicleMetaDirectory.cpp
@@ -13,28 +13,11 @@ ChronicleMetaDirectory::ChronicleMetaDirectory()
     LOG_DEBUG("[ChronicleMetaDirectory] Constructor is called. Object created at {} in thread PID={}"
          , static_cast<const void*>(this), getpid());
     chronicleMap_ = new std::unordered_map <uint64_t, Chronicle*>();
-//    chronicleName2IdMap_ = new std::unordered_map<std::string, uint64_t>();
-//    chronicleId2NameMap_ = new std::unordered_map<uint64_t, std::string>();
 }
 
 ChronicleMetaDirectory::~ChronicleMetaDirectory()
 {
     delete chronicleMap_;
-//    delete chronicleName2IdMap_;
-//    delete chronicleId2NameMap_;
-}
-
-/**
- * Create a Chronicle
- * @param name: name of the Chronicle
- * @return CL_SUCCESS if succeed to create the Chronicle \n
- *         CL_ERR_CHRONICLE_EXISTS if a Chronicle with the same name already exists \n
- *         CL_ERR_UNKNOWN otherwise
- */
-int ChronicleMetaDirectory::create_chronicle(const std::string &name)
-{
-    std::unordered_map <std::string, std::string> attrs;
-    return create_chronicle(name, attrs);
 }
 
 /**
@@ -46,25 +29,17 @@ int ChronicleMetaDirectory::create_chronicle(const std::string &name)
  *         CL_ERR_UNKNOWN otherwise
  */
 int ChronicleMetaDirectory::create_chronicle(const std::string &name
-                                             , const std::unordered_map <std::string, std::string> &attrs)
+                                             , const std::map <std::string, std::string> &attrs)
 {
     LOG_DEBUG("[ChronicleMetaDirectory] Creating Chronicle Name={}", name.c_str());
     for(auto iter = attrs.begin(); iter != attrs.end(); ++iter)
     {
         LOG_DEBUG("[ChronicleMetaDirectory] Attribute of Chronicle {}: {}={}", name.c_str(), iter->first.c_str()
              , iter->second.c_str());
     }
-    std::chrono::steady_clock::time_point t1, t2;
-    t1 = std::chrono::steady_clock::now();
     std::lock_guard <std::mutex> chronicleMapLock(g_chronicleMetaDirectoryMutex_);
     /* Check if Chronicle already exists, fail if true */
     uint64_t cid;
-//    auto name2IdRecord = chronicleName2IdMap_->find(name);
-//    if (name2IdRecord != chronicleName2IdMap_->end()) {
-//        return CL_ERR_CHRONICLE_EXISTS;
-//    } else {
-//        cid = CityHash64(name.c_str(), name.length());
-//    }
     cid = CityHash64(name.c_str(), name.length());
     auto chronicleMapRecord = chronicleMap_->find(cid);
     if(chronicleMapRecord != chronicleMap_->end())
@@ -76,11 +51,6 @@ int ChronicleMetaDirectory::create_chronicle(const std::string &name
     pChronicle->setName(name);
     pChronicle->setCid(cid);
     auto res = chronicleMap_->emplace(cid, pChronicle);
-//    chronicleName2IdMap_->insert_or_assign(name, cid);
-//    chronicleId2NameMap_->insert_or_assign(cid, name);
-    t2 = std::chrono::steady_clock::now();
-    std::chrono::duration <double, std::nano> duration = (t2 - t1);
-    LOG_DEBUG("[ChronicleMetaDirectory] Chronicle created in {} ns", duration.count());
     if(res.second)
     {
         LOG_DEBUG("[ChronicleMetaDirectory] ChronicleName={} is created", name.c_str());
@@ -106,14 +76,9 @@ int ChronicleMetaDirectory::create_chronicle(const std::string &name
 int ChronicleMetaDirectory::destroy_chronicle(const std::string &name)
 {
     LOG_DEBUG("[ChronicleMetaDirectory] Destroying ChronicleName={}", name.c_str());
-    std::chrono::steady_clock::time_point t1, t2;
-    t1 = std::chrono::steady_clock::now();
     std::lock_guard <std::mutex> chronicleMapLock(g_chronicleMetaDirectoryMutex_);
     /* First check if Chronicle exists, fail if false */
     uint64_t cid;
-//    auto name2IdRecord = chronicleName2IdMap_->find(name);
-//    if (name2IdRecord != chronicleName2IdMap_->end()) {
-//        cid = name2IdRecord->second;
     cid = CityHash64(name.c_str(), name.length());
     auto chronicleMapRecord = chronicleMap_->find(cid);
     if(chronicleMapRecord != chronicleMap_->end())
@@ -148,11 +113,6 @@ int ChronicleMetaDirectory::destroy_chronicle(const std::string &name)
         /* No Stories in Chronicle is acquired, ready to destroy */
         delete pChronicle;
         auto nErased = chronicleMap_->erase(cid);
-//        chronicleName2IdMap_->erase(name);
-//        chronicleId2NameMap_->erase(cid);
-        t2 = std::chrono::steady_clock::now();
-        std::chrono::duration <double, std::nano> duration = (t2 - t1);
-        LOG_DEBUG("[ChronicleMetaDirectory] Chronicle destroyed in {} ns", duration.count());
         if(nErased == 1)
         {
             LOG_DEBUG("[ChronicleMetaDirectory] ChronicleName={} is destroyed", name.c_str());
@@ -189,9 +149,6 @@ int ChronicleMetaDirectory::destroy_story(std::string const &chronicle_name, con
     std::lock_guard <std::mutex> chronicleMapLock(g_chronicleMetaDirectoryMutex_);
     /* First check if Chronicle exists, fail if false */
     uint64_t cid;
-//    auto name2IdRecord = chronicleName2IdMap_->find(chronicle_name);
-//    if (name2IdRecord != chronicleName2IdMap_->end()) {
-//        cid = name2IdRecord->second;
     cid = CityHash64(chronicle_name.c_str(), chronicle_name.length());
     auto chronicleMapRecord = chronicleMap_->find(cid);
     if(chronicleMapRecord != chronicleMap_->end())
@@ -244,7 +201,7 @@ int ChronicleMetaDirectory::destroy_story(std::string const &chronicle_name, con
  */
 int ChronicleMetaDirectory::acquire_story(chl::ClientId const &client_id, const std::string &chronicle_name
                                           , const std::string &story_name
-                                          , const std::unordered_map <std::string, std::string> &attrs, int &flags
+                                          , const std::map <std::string, std::string> &attrs, int &flags
                                           , StoryId &story_id)
 {
     LOG_DEBUG("[ChronicleMetaDirectory] ClientID={} acquiring StoryName={} in ChronicleName={} with Flags={}", client_id
@@ -253,9 +210,6 @@ int ChronicleMetaDirectory::acquire_story(chl::ClientId const &client_id, const
     std::lock_guard <std::mutex> chronicleMapLock(g_chronicleMetaDirectoryMutex_);
     /* First check if Chronicle exists, fail if false */
     uint64_t cid;
-//    auto name2IdRecord = chronicleName2IdMap_->find(chronicle_name);
-//    if (name2IdRecord != chronicleName2IdMap_->end()) {
-//        cid = name2IdRecord->second;
     cid = CityHash64(chronicle_name.c_str(), chronicle_name.length());
     auto chronicleMapRecord = chronicleMap_->find(cid);
     if(chronicleMapRecord == chronicleMap_->end())
@@ -314,9 +268,6 @@ int ChronicleMetaDirectory::release_story(chl::ClientId const &client_id, const
     std::lock_guard <std::mutex> chronicleMapLock(g_chronicleMetaDirectoryMutex_);
     /* First check if Chronicle exists, fail if false */
     uint64_t cid;
-//    auto name2IdRecord = chronicleName2IdMap_->find(chronicle_name);
-//    if (name2IdRecord != chronicleName2IdMap_->end()) {
-//        cid = name2IdRecord->second;
     cid = CityHash64(chronicle_name.c_str(), chronicle_name.length());
     int ret = chronolog::CL_ERR_NOT_EXIST;
     auto chronicleRecord = chronicleMap_->find(cid);
@@ -364,9 +315,6 @@ int ChronicleMetaDirectory::get_chronicle_attr(std::string const &name, const st
     std::lock_guard <std::mutex> chronicleMapLock(g_chronicleMetaDirectoryMutex_);
     /* First check if Chronicle exists, fail if false */
     uint64_t cid;
-//    auto name2IdRecord = chronicleName2IdMap_->find(name);
-//    if (name2IdRecord != chronicleName2IdMap_->end()) {
-//        cid = name2IdRecord->second;
     cid = CityHash64(name.c_str(), name.length());
     auto chronicleMapRecord = chronicleMap_->find(cid);
     if(chronicleMapRecord != chronicleMap_->end())
@@ -409,9 +357,6 @@ ChronicleMetaDirectory::edit_chronicle_attr(std::string const &name, const std::
     std::lock_guard <std::mutex> chronicleMapLock(g_chronicleMetaDirectoryMutex_);
     /* First check if Chronicle exists, fail if false */
     uint64_t cid;
-//    auto name2IdRecord = chronicleName2IdMap_->find(name);
-//    if (name2IdRecord != chronicleName2IdMap_->end()) {
-//        cid = name2IdRecord->second;
     cid = CityHash64(name.c_str(), name.length());
     auto chronicleMapRecord = chronicleMap_->find(cid);
     if(chronicleMapRecord != chronicleMap_->end())
@@ -489,9 +434,6 @@ int ChronicleMetaDirectory::show_stories(const std::string &chronicle_name, std:
     /* First check if Chronicle exists, fail if false */
 
     uint64_t cid;
-//    auto name2IdRecord = chronicleName2IdMap_->find(chronicle_name);
-//    if (name2IdRecord != chronicleName2IdMap_->end()) {
-//        cid = name2IdRecord->second;
     cid = CityHash64(chronicle_name.c_str(), chronicle_name.length());
     auto chronicleMapRecord = chronicleMap_->find(cid);
     if(chronicleMapRecord == chronicleMap_->end())

diff --git a/ChronoVisor/src/VisorClientPortal.cpp b/ChronoVisor/src/VisorClientPortal.cpp
@@ -131,7 +131,7 @@ int chronolog::VisorClientPortal::ClientDisconnect(chronolog::ClientId const &cl
  * Metadata APIs
  */
 int chronolog::VisorClientPortal::CreateChronicle(chl::ClientId const &client_id, std::string const &chronicle_name
-                                                  , const std::unordered_map <std::string, std::string> &attrs
+                                                  , const std::map <std::string, std::string> &attrs
                                                   , int &flags)
 {
     if(chronicle_name.empty())
@@ -140,7 +140,7 @@ int chronolog::VisorClientPortal::CreateChronicle(chl::ClientId const &client_id
     if(!chronicle_action_is_authorized(client_id, chronicle_name))
     { return CL_ERR_NOT_AUTHORIZED; }
 
-    int return_code = chronicleMetaDirectory.create_chronicle(chronicle_name);
+    int return_code = chronicleMetaDirectory.create_chronicle(chronicle_name, attrs);
     if(return_code == CL_SUCCESS)
     {
         LOG_INFO("[VisorClientPortal] Chronicle created: PID={}, ClientID={}, Name={}", getpid(), client_id
@@ -191,7 +191,7 @@ int chronolog::VisorClientPortal::DestroyStory(chl::ClientId const &client_id, s
 chl::AcquireStoryResponseMsg
 chronolog::VisorClientPortal::AcquireStory(chl::ClientId const &client_id, std::string const &chronicle_name
                                            , std::string const &story_name
-                                           , const std::unordered_map <std::string, std::string> &attrs, int &flags)
+                                           , const std::map <std::string, std::string> &attrs, int &flags)
 {
     chronolog::StoryId story_id{0};
     std::vector <chronolog::KeeperIdCard> recording_keepers;

diff --git a/Client/CMakeLists.txt b/Client/CMakeLists.txt
@@ -42,8 +42,7 @@ target_include_directories(chronolog_client PUBLIC include
 
 target_link_libraries(chronolog_client thallium)
 
-add_subdirectory(storyteller_test)
-add_subdirectory(ChronoAdmin)
+################################
 
 # install library
 install(
@@ -52,15 +51,8 @@ install(
 
 # Install header files
 install(
-    FILES ${HEADER_FILES}
-    DESTINATION ${HEADER_DEST_DIR}
+    FILES ${HEADER_FILES} DESTINATION include
 )
 
-#include/client.h
-#include/RPCClient.h
-#../ChronoAPI/ChronoLog/include/macro.h
-#../ChronoAPI/ChronoLog/include/rpc.h
-#../ChronoAPI/ChronoLog/include/RPCFactory.h
-#../ChronoAPI/ChronoLog/include/singleton.h
-#../ChronoAPI/ChronoLog/src/city.cpp
-#../ChronoAPI/ChronoLog/include/city.h)
+add_subdirectory(storyteller_test)
+add_subdirectory(ChronoAdmin)
diff --git a/Client/ChronoAdmin/client_admin.cpp b/Client/ChronoAdmin/client_admin.cpp
@@ -175,7 +175,7 @@ void random_sleep()
 void test_create_chronicle(chronolog::Client &client, const std::string &chronicle_name)
 {
     int ret, flags = 0;
-    std::unordered_map <std::string, std::string> chronicle_attrs;
+    std::map <std::string, std::string> chronicle_attrs;
     chronicle_attrs.emplace("Priority", "High");
     chronicle_attrs.emplace("IndexGranularity", "Millisecond");
     chronicle_attrs.emplace("TieringPolicy", "Hot");
@@ -188,7 +188,7 @@ test_acquire_story(chronolog::Client &client, const std::string &chronicle_name,
 {
 //    random_sleep();
     int flags = 0;
-    std::unordered_map <std::string, std::string> story_acquisition_attrs;
+    std::map <std::string, std::string> story_acquisition_attrs;
     story_acquisition_attrs.emplace("Priority", "High");
     story_acquisition_attrs.emplace("IndexGranularity", "Millisecond");
     story_acquisition_attrs.emplace("TieringPolicy", "Hot");
@@ -535,4 +535,4 @@ std::vector <std::string> &command_subs)
     MPI_Finalize();
 
     return 0;
-}
+}