live_swap_transaction.hpp

Go to the documentation of this file.

#pragma once

 
#include <exception>
#include <functional>
#include <string>
#include <vector>
 
namespace pulp::format::reload {

struct SwapStage {
    std::string name;
    std::function<bool()> apply;
    std::function<void()> rollback;   // may be null if this stage is always last
};
 
struct LiveSwapResult {
    bool ok = false;
    std::string failed_stage;   
    std::string detail;         
    bool rollback_clean = true; 
};

inline LiveSwapResult apply_live_swap(const std::vector<SwapStage>& stages) {
    std::vector<const SwapStage*> applied;
    applied.reserve(stages.size());
 
    auto unwind = [&](LiveSwapResult result) {
        // Roll back the applied stages in reverse; a throwing rollback must not
        // abort the unwind of the others (best-effort; flag it).
        for (auto it = applied.rbegin(); it != applied.rend(); ++it) {
            if (!(*it)->rollback) continue;
            try {
                (*it)->rollback();
            } catch (...) {
                result.rollback_clean = false;
            }
        }
        return result;
    };
 
    for (const auto& stage : stages) {
        bool ok = false;
        try {
            ok = stage.apply ? stage.apply() : true;
        } catch (const std::exception& e) {
            return unwind({false, stage.name, std::string("threw: ") + e.what(), true});
        } catch (...) {
            return unwind({false, stage.name, "threw (non-std)", true});
        }
        if (!ok)
            return unwind({false, stage.name, "stage rejected", true});
        applied.push_back(&stage);
    }
    return {true, "", "", true};
}

class SwapUnit {
public:
    virtual ~SwapUnit() = default;

    virtual std::string name() const = 0;

    virtual SwapStage to_stage() = 0;
};

inline LiveSwapResult apply_live_swap(const std::vector<SwapUnit*>& units) {
    std::vector<SwapStage> stages;
    stages.reserve(units.size());
    for (auto* unit : units) {
        if (unit) stages.push_back(unit->to_stage());
    }
    return apply_live_swap(stages);
}
 
}  // namespace pulp::format::reload