Obtaining and releasing locks

Change-Id: Ib37d2af387f7d1b219432fc7d917d25afabcdf50
Bug: sysrepo#19

Author: jktjkt

include/sysrepo-cpp/Session.hpp

@@ -161,4 +161,29 @@ class Session {
     std::shared_ptr<sr_conn_ctx_s> m_conn;
     std::shared_ptr<sr_session_ctx_s> m_sess;
 };
+
+/**
+ * @brief Lock the current datastore, or a specified module in a datastore
+ *
+ * Lock release is controlled through [RAII](https://en.cppreference.com/w/cpp/language/raii).
+ */
+class Lock {
+public:
+    /** @brief Obtain a lock
+     *
+     * Wraps `sr_lock`.
+     */
+    explicit Lock(Session session, std::optional<std::string> module = std::nullopt, std::optional<std::chrono::milliseconds> timeout = std::nullopt);
+    /** @brief Release the lock
+     *
+     * Wraps `sr_unlock`.
+     */
+    ~Lock();
+
+    Lock& operator=(const Lock& other) = delete;
+    Lock(const Lock& other) = delete;
+private:
+    Session m_session;
+    std::optional<std::string> m_module;
+};
 }

src/Session.cpp

@@ -695,6 +695,20 @@ uint32_t Session::getId() const
     return sr_session_get_id(m_sess.get());
 }
 
+Lock::Lock(Session session, std::optional<std::string> module, std::optional<std::chrono::milliseconds> timeout)
+    : m_session(session)
+    , m_module(module)
+{
+    auto res = sr_lock(getRawSession(m_session), module ? module->c_str() : nullptr, timeout ? timeout->count() : 0);
+    throwIfError(res, "Cannot lock session", getRawSession(m_session));
+}
+
+Lock::~Lock()
+{
+    auto res = sr_unlock(getRawSession(m_session), m_module ? m_module->c_str() : nullptr);
+    throwIfError(res, "Cannot unlock session", getRawSession(m_session));
+}
+
 sr_session_ctx_s* getRawSession(Session sess)
 {
     return sess.m_sess.get();

tests/session.cpp

@@ -12,6 +12,8 @@
 #include <sysrepo-cpp/utils/utils.hpp>
 #include <sysrepo-cpp/utils/exception.hpp>
 
+using namespace std::literals;
+
 TEST_CASE("session")
 {
     sysrepo::setLogLevelStderr(sysrepo::LogLevel::Information);
@@ -219,4 +221,49 @@ TEST_CASE("session")
         REQUIRE(sess.getId() == sess.getId());
         REQUIRE(sess.getId() != conn->sessionStart().getId());
     }
+
+    DOCTEST_SUBCASE("locking")
+    {
+        auto sid = sess.getId();
+
+        {
+            // L1 will be released at the scope exit
+            auto l1 = sysrepo::Lock{sess};
+            const auto start = std::chrono::steady_clock::now();
+            try {
+                // even though we provide a timeout, an attempt to lock by the same session is detected immediately
+                auto l2 = sysrepo::Lock{sess, std::nullopt, 500ms};
+                FAIL("should have thrown (immediately)");
+            } catch (sysrepo::ErrorWithCode& e) {
+                REQUIRE(e.code() == sysrepo::ErrorCode::Locked);
+                std::string msg = e.what();
+                REQUIRE(msg.find("already locked by this session " + std::to_string(sid)) != std::string::npos);
+            }
+            auto shouldBeImmediate = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count();
+            REQUIRE(shouldBeImmediate < 100);
+        }
+        {
+            // ensure that L1 was released
+            sysrepo::Lock l3{sess};
+        }
+        {
+            sysrepo::Lock l4{sess, std::nullopt};
+            const auto start = std::chrono::steady_clock::now();
+            try {
+                // locking through an unrelated session sleeps
+                sysrepo::Lock{conn->sessionStart(), std::nullopt, 500ms};
+                FAIL("should have thrown (after a timeout)");
+            } catch (sysrepo::ErrorWithCode& e) {
+                REQUIRE(e.code() == sysrepo::ErrorCode::Locked);
+                std::string msg = e.what();
+                REQUIRE(msg.find("is DS-locked by session " + std::to_string(sid)) != std::string::npos);
+            }
+            auto processingMS = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count();
+            REQUIRE(processingMS >= 500);
+        }
+        {
+            sysrepo::Lock m1_lock{sess, "test_module"};
+            sysrepo::Lock m2_lock{sess, "ietf-netconf-acm"};
+        }
+    }
 }