Method open

nodedb/src/engine/array/store/segment_handle.rs:71–125

Open and validate a segment file. When `kek` is `Some` the file is read into memory and AES-256-GCM decrypted; the resulting plaintext is used as the backing buffer. An encrypted (`SEGA`) segment without a KEK or a plaintext (`NDAS`) segment with a KEK both return a typed error from the array crate. When `kek` is `None` the file is memory-mapped directly (zero-copy) and must be a plaintext (`NDA

(
        path: &Path,
        id: String,
        expected_schema_hash: u64,
        kek: Option<&WalEncryptionKey>,
    )

    /// When `kek` is `None` the file is memory-mapped directly (zero-copy)
    /// and must be a plaintext (`NDAS`) segment.
    pub fn open(
        path: &Path,
        id: String,
        expected_schema_hash: u64,
        kek: Option<&WalEncryptionKey>,
    ) -> Result<Self, SegmentHandleError> {
        let backing: Arc<Backing> = if let Some(key) = kek {
            // Encrypted path: read raw bytes, decrypt via OwnedSegmentReader.
            let raw = std::fs::read(path).map_err(|e| SegmentHandleError::Open {
                detail: format!("{path:?}: {e}"),
            })?;
            let owned =
                nodedb_array::segment::reader::OwnedSegmentReader::open_with_kek(&raw, Some(key))
                    .map_err(|e| SegmentHandleError::Open {
                    detail: format!("{path:?}: {e}"),
                })?;
            // Extract the decrypted plaintext bytes for long-term storage.
            Arc::new(Backing::Decrypted(Arc::new(owned.into_plaintext())))
        } else {
            // Plaintext path: mmap directly.
            let file = std::fs::File::open(path).map_err(|e| SegmentHandleError::Open {
                detail: format!("{path:?}: {e}"),
            })?;
            // Safety: the segment file is treated as read-only; we never
            // mutate it through the mmap and the file is not shared for
            // writing while the handle is alive.
            let mmap = unsafe { Mmap::map(&file) }.map_err(|e| SegmentHandleError::Mmap {
                detail: format!("{path:?}: {e}"),
            })?;
            Arc::new(Backing::Mmap(Arc::new(mmap)))
        };

        let (rtree, schema_hash, tile_count) = {
            let reader =
                SegmentReader::open(backing.bytes()).map_err(|e| SegmentHandleError::Open {
                    detail: format!("{path:?}: {e}"),
                })?;
            if reader.schema_hash() != expected_schema_hash {
                return Err(SegmentHandleError::SchemaHashMismatch {
                    array: expected_schema_hash,
                    seg: reader.schema_hash(),
                });
            }
            let rtree = HilbertPackedRTree::build(reader.tiles());
            (rtree, reader.schema_hash(), reader.tile_count())
        };

        Ok(Self {
            backing,
            rtree: Arc::new(rtree),
            schema_hash,
            tile_count,
            id,
        })
    }

    pub fn id(&self) -> &str {
        &self.id