Commit 0951dac1 authored by jan.koester's avatar jan.koester
Browse files

test

parent 10824696

src/admin.cpp

+9 −0
Original line number Diff line number Diff line
@@ -744,6 +744,15 @@ namespace authdb { 
                return;

            }



            auto scrub_lk = g_Cluster->tryScrubLock();

            if (!scrub_lk.owns_lock()) {

                json_object_object_add(jobj, "status", json_object_new_string("error"));

                json_object_object_add(jobj, "message", json_object_new_string("scrub or rebalance already running"));

                sendJson(curreq, jobj);

                json_object_put(jobj);

                return;

            }



            auto rb = client->rebalance();



            json_object_object_add(jobj, "status", json_object_new_string("ok"));

src/cluster.cpp

+9 −0
Original line number Diff line number Diff line
@@ -652,6 +652,8 @@ namespace authdb { 
                    if (++healthy_cycles >= REBALANCE_INTERVAL) {

                        healthy_cycles = 0;

                        std::thread([this](){

                            std::unique_lock<std::mutex> lk(scrub_mutex_, std::try_to_lock);

                            if (!lk.owns_lock()) return; // scrub running, skip

                            try {

                                auto rb = pclient_->rebalance();

                                if (rb.rebalanced > 0) {
@@ -1057,6 +1059,13 @@ namespace authdb { 
        ScrubResult result;

        if (!pclient_) return result;



        // Only one scrub/rebalance at a time

        std::unique_lock<std::mutex> scrub_lk(scrub_mutex_, std::try_to_lock);

        if (!scrub_lk.owns_lock()) {

            std::cerr << "[SCRUB] skipped — another scrub/rebalance is already running" << std::endl;

            return result;

        }



        size_t n = cfg_.data_blocks + cfg_.parity_blocks;



        // Collect known session group IDs so we can skip them.

src/cluster.h

+7 −0
Original line number Diff line number Diff line
@@ -223,6 +223,12 @@ namespace authdb { 
        };

        ScrubResult scrub();



        // Try to acquire the scrub/rebalance lock (non-blocking).

        // Returns a unique_lock that owns the lock on success, or doesn't own it.

        std::unique_lock<std::mutex> tryScrubLock() {

            return std::unique_lock<std::mutex>(scrub_mutex_, std::try_to_lock);

        }



    private:

        ClusterConfig cfg_;

        std::atomic<bool> running_{false};
@@ -236,6 +242,7 @@ namespace authdb { 
        std::condition_variable monitor_cv_;

        std::mutex push_mutex_;

        std::condition_variable push_cv_;

        std::mutex scrub_mutex_;  // prevents concurrent scrub / rebalance



        struct PendingPush {

            std::vector<uint8_t> data;