Ephemeral relationsmaster-old

1 files changed, 196 insertions, 0 deletions

diff --git a/src/EphemeralRelation.cpp b/src/EphemeralRelation.cpp
new file mode 100644
index 0000000..5cb2dd7
--- /dev/null
+++ b/src/EphemeralRelation.cpp
@@ -0,0 +1,196 @@
+#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