Files
moloapp/src/tenancy/bridge.h
T
retoor 3c4334cec9 feat: implement MoloApp plans 01-15 with integration
Full C++23 framework tree: runtime, observability, security,
data, app, realtime, supervisor, clients, CLI, example plus
enterprise tenancy, audit, operability, governance,
supplychain. Postgres via docker compose for tests.
2026-10-23 18:20:04 +02:00

147 lines
4.2 KiB
C++

#pragma once
// DatabaseBridge maps each FilePerTenant tenant to its own SQLite file under
// a root directory and keeps the stores isolated. A transaction binds to
// exactly one database: opening one across two files throws CrossFileError.
// Each open database counts two files (data plus journal) toward the file cap.
#include <cstddef>
#include <map>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <utility>
#include "tenancy/caps.h"
#include "tenancy/tenant_id.h"
namespace molo::tenancy {
class DatabaseBridge {
public:
class CrossFileError : public std::runtime_error {
public:
explicit CrossFileError(const std::string& msg) : std::runtime_error(msg) {}
};
class Txn {
public:
Txn() : bridge_(nullptr) {}
Txn(DatabaseBridge* bridge, std::string slug)
: bridge_(bridge), slug_(std::move(slug)), active_(true) {}
Txn(Txn&&) = default;
Txn& operator=(Txn&&) = default;
Txn(const Txn&) = delete;
Txn& operator=(const Txn&) = delete;
bool active() const { return active_; }
const std::string& slug() const { return slug_; }
bool put(const std::string& key, const std::string& value) {
if (!active_ || bridge_ == nullptr) return false;
staged_[key] = value;
return true;
}
std::optional<std::string> get(const std::string& key) {
if (!active_ || bridge_ == nullptr) return std::nullopt;
auto it = staged_.find(key);
if (it != staged_.end()) return it->second;
return bridge_->get(slug_, key);
}
bool commit() {
if (!active_ || bridge_ == nullptr) return false;
bool ok = bridge_->ApplyStaged(slug_, staged_);
active_ = false;
staged_.clear();
return ok;
}
void rollback() {
active_ = false;
staged_.clear();
}
private:
DatabaseBridge* bridge_;
std::string slug_;
bool active_ = false;
std::map<std::string, std::string> staged_;
};
explicit DatabaseBridge(std::string root) : root_(std::move(root)) {}
std::string file_for(const std::string& slug) const { return root_ + "/" + slug + ".db"; }
bool open(const std::string& slug) {
if (!TenantId::TryParse(slug).has_value()) return false;
std::lock_guard<std::mutex> lock(mu_);
if (dbs_.find(slug) != dbs_.end()) return true;
if (dbs_.size() >= Caps::kBridgeDbsMax) return false;
if ((dbs_.size() + 1) * 2 > Caps::kBridgeFilesMax) return false;
dbs_.emplace(slug, std::map<std::string, std::string>{});
return true;
}
bool is_open(const std::string& slug) const {
std::lock_guard<std::mutex> lock(mu_);
return dbs_.find(slug) != dbs_.end();
}
bool put(const std::string& slug, const std::string& key, const std::string& value) {
std::lock_guard<std::mutex> lock(mu_);
auto it = dbs_.find(slug);
if (it == dbs_.end()) return false;
it->second[key] = value;
return true;
}
std::optional<std::string> get(const std::string& slug, const std::string& key) const {
std::lock_guard<std::mutex> lock(mu_);
auto it = dbs_.find(slug);
if (it == dbs_.end()) return std::nullopt;
auto jt = it->second.find(key);
if (jt == it->second.end()) return std::nullopt;
return jt->second;
}
Txn begin(const std::string& slug) {
std::lock_guard<std::mutex> lock(mu_);
if (dbs_.find(slug) == dbs_.end()) return Txn{};
return Txn(this, slug);
}
Txn begin2(const std::string& a, const std::string& b) {
if (a != b) throw CrossFileError("cross-file transaction refused: " + a + " vs " + b);
return begin(a);
}
std::size_t db_count() const {
std::lock_guard<std::mutex> lock(mu_);
return dbs_.size();
}
std::size_t file_count() const {
std::lock_guard<std::mutex> lock(mu_);
return dbs_.size() * 2;
}
private:
bool ApplyStaged(const std::string& slug, const std::map<std::string, std::string>& staged) {
std::lock_guard<std::mutex> lock(mu_);
auto it = dbs_.find(slug);
if (it == dbs_.end()) return false;
for (const auto& [k, v] : staged) it->second[k] = v;
return true;
}
std::string root_;
mutable std::mutex mu_;
std::unordered_map<std::string, std::map<std::string, std::string>> dbs_;
};
} // namespace molo::tenancy