mercurial-scm/hg: comparison rust/hg-cpython/src/revlog.rs

equal deleted inserted replaced

-:bd43465af568
+:72bc29f01570
 use crate::{
 conversion::{rev_pyiter_collect, rev_pyiter_collect_or_else},
 pybytes_deref::{PyBufferDeref, PyBytesDeref},
 utils::{node_from_py_bytes, node_from_py_object},
-vfs::PyVfs,
 PyRevision,
 };
 use cpython::{
 buffer::{Element, PyBuffer},
 exc::{IndexError, ValueError},
 PyModule, PyObject, PyResult, PySet, PyTuple, PyType, Python,
 PythonObject, ToPyObject, UnsafePyLeaked,
 };
 use hg::{
 errors::HgError,
+fncache::FnCache,
 index::{Phase, RevisionDataParams, SnapshotsCache, INDEX_ENTRY_SIZE},
 nodemap::{Block, NodeMapError, NodeTree as CoreNodeTree},
-revlog::compression::CompressionConfig,
+revlog::{
-revlog::inner_revlog::InnerRevlog as CoreInnerRevlog,
+compression::CompressionConfig,
-revlog::inner_revlog::RevisionBuffer,
+inner_revlog::{InnerRevlog as CoreInnerRevlog, RevisionBuffer},
-revlog::options::{
+nodemap::NodeMap,
-RevlogDataConfig, RevlogDeltaConfig, RevlogFeatureConfig,
+options::{
-RevlogOpenOptions,
+RevlogDataConfig, RevlogDeltaConfig, RevlogFeatureConfig,
+RevlogOpenOptions,
+},
+Graph, NodePrefix, RevlogError, RevlogIndex,
 },
-revlog::{nodemap::NodeMap, Graph, NodePrefix, RevlogError, RevlogIndex},
 transaction::Transaction,
 utils::files::{get_bytes_from_path, get_path_from_bytes},
+vfs::FnCacheVfs,
 BaseRevision, Node, Revision, RevlogType, UncheckedRevision,
 NULL_REVISION,
 };
 use std::{
 cell::{Cell, RefCell},
 collections::{HashMap, HashSet},
+sync::atomic::{AtomicBool, Ordering},
 sync::OnceLock,
 };
 use vcsgraph::graph::Graph as VCSGraph;
 pub struct PySharedIndex {
 .exit_writing_context();
 Ok(py.None())
 }
 });
+struct PyFnCache {
+fncache: PyObject,
+}
+impl PyFnCache {
+fn new(fncache: PyObject) -> Self {
+Self { fncache }
+}
+}
+impl Clone for PyFnCache {
+fn clone(&self) -> Self {
+let gil = Python::acquire_gil();
+let py = gil.python();
+Self {
+fncache: self.fncache.clone_ref(py),
+}
+}
+}
+/// Cache whether the fncache is loaded to avoid Python round-trip every time.
+/// Once the fncache is loaded, it stays loaded unless we're in a very
+/// long-running process, none of which we actually support for now.
+static FN_CACHE_IS_LOADED: AtomicBool = AtomicBool::new(false);
+impl FnCache for PyFnCache {
+fn is_loaded(&self) -> bool {
+if FN_CACHE_IS_LOADED.load(Ordering::Relaxed) {
+return true;
+}
+let gil = Python::acquire_gil();
+let py = gil.python();
+// TODO raise in case of error?
+let is_loaded = self
+.fncache
+.getattr(py, "is_loaded")
+.ok()
+.map(|o| {
+o.extract::<bool>(py)
+.expect("is_loaded returned something other than a bool")
+})
+.unwrap_or(false);
+if is_loaded {
+FN_CACHE_IS_LOADED.store(true, Ordering::Relaxed);
+}
+is_loaded
+}
+fn add(&self, path: &std::path::Path) {
+let gil = Python::acquire_gil();
+let py = gil.python();
+// TODO raise in case of error?
+self.fncache
+.call_method(
+py,
+"add",
+(PyBytes::new(py, &get_bytes_from_path(path)),),
+None,
+)
+.ok();
+}
+}
 py_class!(pub class InnerRevlog |py| {
 @shared data inner: CoreInnerRevlog;
 data nt: RefCell<Option<CoreNodeTree>>;
 data docket: RefCell<Option<PyObject>>;
 // Holds a reference to the mmap'ed persistent nodemap data
 data head_node_ids_py_list: RefCell<Option<PyList>>;
 data revision_cache: RefCell<Option<PyObject>>;
 def __new__(
 _cls,
-opener: PyObject,
+vfs_base: PyObject,
+fncache: PyObject,
+vfs_is_readonly: bool,
 index_data: PyObject,
 index_file: PyObject,
 data_file: PyObject,
 sidedata_file: PyObject,
 inline: bool,
 default_compression_header: PyObject,
 revlog_type: usize,
 ) -> PyResult<Self> {
 Self::inner_new(
 py,
-opener,
+vfs_base,
+fncache,
+vfs_is_readonly,
 index_data,
 index_file,
 data_file,
 sidedata_file,
 inline,
 }
 impl InnerRevlog {
 pub fn inner_new(
 py: Python,
-opener: PyObject,
+vfs_base: PyObject,
+fncache: PyObject,
+vfs_is_readonly: bool,
 index_data: PyObject,
 index_file: PyObject,
 data_file: PyObject,
 _sidedata_file: PyObject,
 inline: bool,
 feature_config: PyObject,
 _chunk_cache: PyObject,
 _default_compression_header: PyObject,
 revlog_type: usize,
 ) -> PyResult<Self> {
-let vfs = Box::new(PyVfs::new(py, opener)?);
 let index_file =
 get_path_from_bytes(index_file.extract::<PyBytes>(py)?.data(py))
 .to_owned();
 let data_file =
 get_path_from_bytes(data_file.extract::<PyBytes>(py)?.data(py))
 inline,
 data_config,
 delta_config,
 feature_config,
 );
 // Safety: we keep the buffer around inside the class as `index_mmap`
 let (buf, bytes) = unsafe { mmap_keeparound(py, index_data)? };
 let index = hg::index::Index::new(bytes, options.index_header())
 .map_err(|e| revlog_error_from_msg(py, e))?;
+let base = &vfs_base.extract::<PyBytes>(py)?;
+let base = get_path_from_bytes(base.data(py)).to_owned();
 let core = CoreInnerRevlog::new(
-vfs,
+Box::new(FnCacheVfs::new(
+base,
+vfs_is_readonly,
+Box::new(PyFnCache::new(fncache)),
+)),
 index,
 index_file,
 data_file,
 data_config,
 delta_config,

changeset 52172	72bc29f01570
parent 52163	7346f93be7a4
child 52174	bcd4962e0df9