#include "EphemeralRelation.h"
#include "Types.h"
#include <picosha2.h>
#include <algorithm>
#include <memory>
namespace nt::Ephemeral {
namespace {
// Object-type descriptor for an EPHEMERAL_RELATION. Ephemeral relations
// are not durable (disposable=true) and never contend (readers compose
// generators independently). The generator and cardinality live on the
// descriptor; the cursor layer copies the generator out at Open time.
std::unique_ptr<ObjectManager::object_type>
make_type(ObjectManager::ephemeral_object_type::Cardinality cardinality,
ObjectManager::ephemeral_object_type::Generator generator) {
auto t = std::make_unique<ObjectManager::ephemeral_object_type>();
t->label = EPHEMERAL_RELATION;
t->disposable = true;
t->methods = {OPEN, CLOSE};
t->exclusive = false;
t->cardinality = cardinality;
t->generator = std::move(generator);
return t;
}
// Reads the merkle_root off a registry entry whose object is a stored or
// ephemeral relation. Empty string for anything else (or missing root).
std::string entry_root(ObjectManager::registry* entry) {
if (entry == nullptr || entry->object == nullptr)
return {};
if (auto* r = dynamic_cast<ObjectManager::Relation*>(entry->object.get()))
return r->merkle_root;
if (auto* e = dynamic_cast<ObjectManager::EphemeralRelation*>(entry->object.get()))
return e->merkle_root;
return {};
}
} // namespace
std::vector<std::string> SplitPath(const std::string& path) {
std::vector<std::string> parts;
std::string seg;
for (char c : path) {
if (c == '/') {
if (!seg.empty())
parts.push_back(seg);
seg.clear();
} else {
seg.push_back(c);
}
}
if (!seg.empty())
parts.push_back(seg);
return parts;
}
std::string ComposeRoot(const std::string& generator_identity,
const std::vector<std::pair<std::string, std::string>>& schema,
const std::vector<std::string>& base_roots) {
// Sort schema and base roots so input order does not change the digest.
std::vector<std::pair<std::string, std::string>> sorted_schema = schema;
std::sort(sorted_schema.begin(), sorted_schema.end());
std::vector<std::string> sorted_roots = base_roots;
std::sort(sorted_roots.begin(), sorted_roots.end());
std::string buf;
buf += generator_identity;
buf.push_back('\0');
// NUL-separate each field so distinct (name, type) splits cannot
// serialize to the same bytes, then a lone NUL to close the schema.
for (const auto& [name, type] : sorted_schema) {
buf += name;
buf.push_back('\0');
buf += type;
buf.push_back('\0');
}
buf.push_back('\0');
for (const auto& root : sorted_roots) {
buf += root;
buf.push_back('\n');
}
return picosha2::hash256_hex_string(buf.begin(), buf.end());
}
ObjectManager::registry* Register(
ObjectManager& objects, LifecycleManager& lifecycles, const std::string& session_hash,
Tier tier, const std::string& name,
ObjectManager::ephemeral_object_type::Generator generator,
ObjectManager::ephemeral_object_type::Cardinality cardinality,
const std::string& generator_identity,
const std::vector<std::pair<std::string, std::string>>& schema,
const std::vector<std::string>& dependencies) {
if (session_hash.empty())
return nullptr;
if (tier == Tier::Named && name.empty())
return nullptr;
// Resolve dependencies up front: read their current roots for the
// identity hash and keep the entries to pin after registration. An
// unresolvable dependency fails the registration; skipping it would
// store a path that was never pinned, and CascadeEphemeral would later
// Unpin a hold it never took.
std::vector<ObjectManager::registry*> dep_entries;
std::vector<std::string> base_roots;
dep_entries.reserve(dependencies.size());
base_roots.reserve(dependencies.size());
for (const auto& dep : dependencies) {
auto* entry = objects.Find(SplitPath(dep));
if (entry == nullptr)
return nullptr;
dep_entries.push_back(entry);
base_roots.push_back(entry_root(entry));
}
const std::string root = ComposeRoot(generator_identity, schema, base_roots);
const std::string subdir = (tier == Tier::Named) ? "ephemeral" : "scratch";
const std::string leaf = (tier == Tier::Named) ? name : root;
const std::vector<std::string> path = {"system", "sessions", session_hash, subdir, leaf};
// Idempotent: an identical scratch result, or a live named binding,
// reuses the existing entry without double-pinning.
if (auto* existing = objects.Find(path))
return existing;
auto er = std::make_unique<ObjectManager::EphemeralRelation>();
er->merkle_root = root;
er->dependencies = dependencies;
objects.Register(path, std::move(er), make_type(cardinality, std::move(generator)));
auto* entry = objects.Find(path);
if (entry == nullptr)
return nullptr;
// Structural pins on the base relations: released by
// LifecycleManager::CascadeEphemeral when this entry is collected.
for (auto* dep : dep_entries)
lifecycles.Pin(dep);
// Tier policy: a named ephemeral is owned by its session and outlives
// its cursor; a scratch intermediate is owned by nobody and dies by
// counters with its cursor.
if (tier == Tier::Named)
lifecycles.Pin(entry);
return entry;
}
std::size_t ReleaseSession(ObjectManager& objects, LifecycleManager& lifecycles,
const std::string& session_hash) {
const std::vector<std::string> named_prefix = {"system", "sessions", session_hash,
"ephemeral"};
const std::vector<std::string> scratch_prefix = {"system", "sessions", session_hash,
"scratch"};
auto is_child = [](const std::vector<std::string>& path,
const std::vector<std::string>& prefix) {
if (path.size() != prefix.size() + 1)
return false;
for (std::size_t i = 0; i < prefix.size(); ++i)
if (path[i] != prefix[i])
return false;
return true;
};
// Collect targets before mutating: Unpin / Collect splice entries out of
// the same list we are walking.
std::vector<ObjectManager::registry*> named;
std::vector<ObjectManager::registry*> scratch;
for (auto* cur = objects.entries.get(); cur != nullptr; cur = cur->next.get()) {
if (cur->head == nullptr)
continue;
const auto& p = cur->head->path;
if (is_child(p, named_prefix))
named.push_back(cur);
else if (is_child(p, scratch_prefix))
scratch.push_back(cur);
}
std::size_t released = 0;
// Named: drop the session-ownership pin; collects if nothing else holds it.
for (auto* entry : named) {
const uint32_t before = entry->head->reference_count;
lifecycles.Unpin(entry);
if (before > 0)
++released;
}
// Scratch: never session-pinned; collect any stragglers whose cursor closed.
for (auto* entry : scratch)
if (lifecycles.Collect(entry))
++released;
return released;
}
} // namespace nt::Ephemeral
