This is an archive of the discontinued Mercurial Phabricator instance.

Differential D6233

rust-discovery: implementing and exposing stats()
ClosedPublic

Authored by gracinet on Apr 12 2019, 2:33 PM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHG1b0be75cb61f: rust-discovery: implementing and exposing stats()
Summary

This time, it's simple enough that we can do it in all layers in
one shot.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

gracinet created this revision.Apr 12 2019, 2:33 PM
kevincox accepted this revision.Apr 14 2019, 4:15 PM
gracinet updated this revision to Diff 14745.Apr 15 2019, 12:52 PM
gracinet updated this revision to Diff 14795.Apr 17 2019, 8:17 AM
yuja added a subscriber: yuja.Apr 17 2019, 7:28 PM

Can't apply by :D6233. Can you rebase?

% hg pimp :D6233
applying patch from stdin
patching file mercurial/setdiscovery.py
Hunk #1 succeeded at 167 with fuzz 2 (offset 5 lines).
Hunk #2 FAILED at 343
1 out of 2 hunks FAILED -- saving rejects to file mercurial/setdiscovery.py.rej
abort: patch failed to apply
Closed by commit rHG1b0be75cb61f: rust-discovery: implementing and exposing stats() (authored by gracinet). · Explain WhyApr 18 2019, 7:26 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 14745

rust/hg-core/src/discovery.rs

pub struct PartialDiscovery<G: Graph + Clone> { pub struct PartialDiscovery<G: Graph + Clone> {
target_heads: Option<Vec<Revision>>, target_heads: Option<Vec<Revision>>,
graph: G, // plays the role of self._repo graph: G, // plays the role of self._repo
common: MissingAncestors<G>, common: MissingAncestors<G>,
undecided: Option<HashSet<Revision>>, undecided: Option<HashSet<Revision>>,
missing: HashSet<Revision>, missing: HashSet<Revision>,
} }
pub struct DiscoveryStats {
pub undecided: Option<usize>,
}
impl<G: Graph + Clone> PartialDiscovery<G> { impl<G: Graph + Clone> PartialDiscovery<G> {
/// Create a PartialDiscovery object, with the intent /// Create a PartialDiscovery object, with the intent
/// of comparing our `::<target_heads>` revset to the contents of another /// of comparing our `::<target_heads>` revset to the contents of another
/// repo. /// repo.
/// ///
/// For now `target_heads` is passed as a vector, and will be used /// For now `target_heads` is passed as a vector, and will be used
/// at the first call to `ensure_undecided()`. /// at the first call to `ensure_undecided()`.
/// ///
if self.undecided.is_some() { if self.undecided.is_some() {
return Ok(()); return Ok(());
} }
let tgt = self.target_heads.take().unwrap(); let tgt = self.target_heads.take().unwrap();
self.undecided = self.undecided =
Some(self.common.missing_ancestors(tgt)?.into_iter().collect()); Some(self.common.missing_ancestors(tgt)?.into_iter().collect());
Ok(()) Ok(())
} }
/// Provide statistics about the current state of the discovery process
pub fn stats(&self) -> DiscoveryStats {
DiscoveryStats {
undecided: self.undecided.as_ref().map(|s| s.len()),
}
}
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::testing::SampleGraph; use crate::testing::SampleGraph;
/// A PartialDiscovery as for pushing all the heads of `SampleGraph` /// A PartialDiscovery as for pushing all the heads of `SampleGraph`
Ok(as_vec) Ok(as_vec)
} }
#[test] #[test]
fn test_add_common_get_undecided() -> Result<(), GraphError> { fn test_add_common_get_undecided() -> Result<(), GraphError> {
let mut disco = full_disco(); let mut disco = full_disco();
assert_eq!(disco.undecided, None); assert_eq!(disco.undecided, None);
assert!(!disco.has_info()); assert!(!disco.has_info());
assert_eq!(disco.stats().undecided, None);
disco.add_common_revisions(vec![11, 12])?; disco.add_common_revisions(vec![11, 12])?;
assert!(disco.has_info()); assert!(disco.has_info());
assert!(!disco.is_complete()); assert!(!disco.is_complete());
assert!(disco.missing.is_empty()); assert!(disco.missing.is_empty());
// add_common_revisions did not trigger a premature computation // add_common_revisions did not trigger a premature computation
// of `undecided`, let's check that and ask for them // of `undecided`, let's check that and ask for them
assert_eq!(disco.undecided, None); assert_eq!(disco.undecided, None);
disco.ensure_undecided()?; disco.ensure_undecided()?;
assert_eq!(sorted_undecided(&disco), vec![5, 8, 10, 13]); assert_eq!(sorted_undecided(&disco), vec![5, 8, 10, 13]);
assert_eq!(disco.stats().undecided, Some(4));
Ok(()) Ok(())
} }
/// in this test, we pretend that our peer misses exactly (8+10):: /// in this test, we pretend that our peer misses exactly (8+10)::
/// and we're comparing all our repo to it (as in a bare push) /// and we're comparing all our repo to it (as in a bare push)
#[test] #[test]
fn test_discovery() -> Result<(), GraphError> { fn test_discovery() -> Result<(), GraphError> {
let mut disco = full_disco(); let mut disco = full_disco();

rust/hg-cpython/src/discovery.rs

// discovery.rs // discovery.rs
// //
// Copyright 2018 Georges Racinet <gracinet@anybox.fr> // Copyright 2018 Georges Racinet <gracinet@anybox.fr>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Bindings for the `hg::discovery` module provided by the //! Bindings for the `hg::discovery` module provided by the
//! `hg-core` crate. From Python, this will be seen as `rustext.discovery` //! `hg-core` crate. From Python, this will be seen as `rustext.discovery`
//! //!
//! # Classes visible from Python: //! # Classes visible from Python:
//! - [`PartialDiscover`] is the Rust implementation of //! - [`PartialDiscover`] is the Rust implementation of
//! `mercurial.setdiscovery.partialdiscovery`. //! `mercurial.setdiscovery.partialdiscovery`.
use crate::conversion::{py_set, rev_pyiter_collect}; use crate::conversion::{py_set, rev_pyiter_collect};
use cindex::Index; use cindex::Index;
use cpython::{ObjectProtocol, PyDict, PyModule, PyObject, PyResult, Python}; use cpython::{
ObjectProtocol, PyDict, PyModule, PyObject, PyResult, Python, ToPyObject,
};
use exceptions::GraphError; use exceptions::GraphError;
use hg::discovery::PartialDiscovery as CorePartialDiscovery; use hg::discovery::PartialDiscovery as CorePartialDiscovery;
use hg::Revision; use hg::Revision;
use std::cell::RefCell; use std::cell::RefCell;
py_class!(pub class PartialDiscovery |py| { py_class!(pub class PartialDiscovery |py| {
data inner: RefCell<Box<CorePartialDiscovery<Index>>>; data inner: RefCell<Box<CorePartialDiscovery<Index>>>;
def hasinfo(&self) -> PyResult<bool> { def hasinfo(&self) -> PyResult<bool> {
Ok(self.inner(py).borrow().has_info()) Ok(self.inner(py).borrow().has_info())
} }
def iscomplete(&self) -> PyResult<bool> { def iscomplete(&self) -> PyResult<bool> {
Ok(self.inner(py).borrow().is_complete()) Ok(self.inner(py).borrow().is_complete())
} }
def stats(&self) -> PyResult<PyDict> {
let stats = self.inner(py).borrow().stats();
let as_dict: PyDict = PyDict::new(py);
as_dict.set_item(py, "undecided",
stats.undecided.map(|l| l.to_py_object(py))
.unwrap_or_else(|| py.None()))?;
Ok(as_dict)
}
def commonheads(&self) -> PyResult<PyObject> { def commonheads(&self) -> PyResult<PyObject> {
py_set( py_set(
py, py,
&self.inner(py).borrow().common_heads() &self.inner(py).borrow().common_heads()
.map_err(|e| GraphError::pynew(py, e))? .map_err(|e| GraphError::pynew(py, e))?
) )
} }
}); });

tests/test-rust-discovery.py

self.assertFalse(disco.iscomplete()) self.assertFalse(disco.iscomplete())
disco.addmissings([2]) disco.addmissings([2])
self.assertTrue(disco.hasinfo()) self.assertTrue(disco.hasinfo())
self.assertTrue(disco.iscomplete()) self.assertTrue(disco.iscomplete())
self.assertEqual(disco.commonheads(), {1}) self.assertEqual(disco.commonheads(), {1})
def testaddmissingsstats(self):
idx = self.parseindex()
disco = PartialDiscovery(idx, [3])
self.assertIsNone(disco.stats()['undecided'], None)
disco.addmissings([2])
self.assertEqual(disco.stats()['undecided'], 2)
def testaddinfocommonfirst(self): def testaddinfocommonfirst(self):
idx = self.parseindex() idx = self.parseindex()
disco = PartialDiscovery(idx, [3]) disco = PartialDiscovery(idx, [3])
disco.addinfo([(1, True), (2, False)]) disco.addinfo([(1, True), (2, False)])
self.assertTrue(disco.hasinfo()) self.assertTrue(disco.hasinfo())
self.assertTrue(disco.iscomplete()) self.assertTrue(disco.iscomplete())
self.assertEqual(disco.commonheads(), {1}) self.assertEqual(disco.commonheads(), {1})