From: Brian Warner Date: Wed, 10 Sep 2008 01:08:27 +0000 (-0700) Subject: immutable verifier: provide some dummy results so deep-check works, make the tests... X-Git-Url: https://git.rkrishnan.org/pf/content/it.html?a=commitdiff_plain;h=04513e3ac56b030723854efabff3a37457f8918a;p=tahoe-lafs%2Ftahoe-lafs.git immutable verifier: provide some dummy results so deep-check works, make the tests ignore these results until we finish it off --- diff --git a/src/allmydata/immutable/checker.py b/src/allmydata/immutable/checker.py index 954ede16..ff0c603a 100644 --- a/src/allmydata/immutable/checker.py +++ b/src/allmydata/immutable/checker.py @@ -141,7 +141,6 @@ class VerifyingOutput: def finish(self): self._results.set_healthy(True) - self._results.set_needs_rebalancing(False) # TODO: wrong # the return value of finish() is passed out of FileDownloader._done, # but SimpleCHKFileVerifier overrides this with the CheckerResults # instance instead. @@ -166,6 +165,9 @@ class SimpleCHKFileVerifier(download.FileDownloader): self.init_logging() self._check_results = r = CheckerResults(self._storage_index) + r.set_data({"count-shares-needed": k, + "count-shares-expected": N, + }) self._output = VerifyingOutput(self._size, r) self._paused = False self._stopped = False @@ -219,6 +221,25 @@ class SimpleCHKFileVerifier(download.FileDownloader): # once we know that, we can download blocks from everybody d.addCallback(self._download_all_segments) d.addCallback(self._done) - d.addCallback(lambda ignored: self._check_results) + d.addCallback(self._verify_done) return d + def _verify_done(self, ignored): + # TODO: The following results are just stubs, and need to be replaced + # with actual values. These exist to make things like deep-check not + # fail. + self._check_results.set_needs_rebalancing(False) + N = self._total_shares + data = { + "count-shares-good": N, + "count-good-share-hosts": N, + "count-corrupt-shares": 0, + "list-corrupt-shares": [], + "servers-responding": [], + "sharemap": {}, + "count-wrong-shares": 0, + "count-recoverable-versions": 1, + "count-unrecoverable-versions": 0, + } + self._check_results.set_data(data) + return self._check_results diff --git a/src/allmydata/test/test_system.py b/src/allmydata/test/test_system.py index df400a09..ac6cf2f9 100644 --- a/src/allmydata/test/test_system.py +++ b/src/allmydata/test/test_system.py @@ -2023,7 +2023,7 @@ class DeepCheck(SystemTestMixin, unittest.TestCase): d.addCallback(lambda ign: self.root.set_node(u"loop", self.root)) return d - def check_is_healthy(self, cr, n, where): + def check_is_healthy(self, cr, n, where, incomplete=False): self.failUnless(ICheckerResults.providedBy(cr), where) self.failUnless(cr.is_healthy(), where) self.failUnlessEqual(cr.get_storage_index(), n.get_storage_index(), @@ -2031,29 +2031,32 @@ class DeepCheck(SystemTestMixin, unittest.TestCase): self.failUnlessEqual(cr.get_storage_index_string(), base32.b2a(n.get_storage_index()), where) needs_rebalancing = bool( len(self.clients) < 10 ) - self.failUnlessEqual(cr.needs_rebalancing(), needs_rebalancing, where) + if not incomplete: + self.failUnlessEqual(cr.needs_rebalancing(), needs_rebalancing, where) d = cr.get_data() self.failUnlessEqual(d["count-shares-good"], 10, where) self.failUnlessEqual(d["count-shares-needed"], 3, where) self.failUnlessEqual(d["count-shares-expected"], 10, where) - self.failUnlessEqual(d["count-good-share-hosts"], len(self.clients), where) + if not incomplete: + self.failUnlessEqual(d["count-good-share-hosts"], len(self.clients), where) self.failUnlessEqual(d["count-corrupt-shares"], 0, where) self.failUnlessEqual(d["list-corrupt-shares"], [], where) - self.failUnlessEqual(sorted(d["servers-responding"]), - sorted([idlib.nodeid_b2a(c.nodeid) - for c in self.clients]), where) - self.failUnless("sharemap" in d, where) + if not incomplete: + self.failUnlessEqual(sorted(d["servers-responding"]), + sorted([idlib.nodeid_b2a(c.nodeid) + for c in self.clients]), where) + self.failUnless("sharemap" in d, where) self.failUnlessEqual(d["count-wrong-shares"], 0, where) self.failUnlessEqual(d["count-recoverable-versions"], 1, where) self.failUnlessEqual(d["count-unrecoverable-versions"], 0, where) - def check_and_repair_is_healthy(self, cr, n, where): + def check_and_repair_is_healthy(self, cr, n, where, incomplete=False): self.failUnless(ICheckAndRepairResults.providedBy(cr), where) self.failUnless(cr.get_pre_repair_results().is_healthy(), where) - #self.check_is_healthy(cr.get_pre_repair_results(), n, where) + self.check_is_healthy(cr.get_pre_repair_results(), n, where, incomplete) self.failUnless(cr.get_post_repair_results().is_healthy(), where) - #self.check_is_healthy(cr.get_post_repair_results(), n, where) + self.check_is_healthy(cr.get_post_repair_results(), n, where, incomplete) self.failIf(cr.get_repair_attempted(), where) def deep_check_is_healthy(self, cr, num_healthy, where): @@ -2094,8 +2097,9 @@ class DeepCheck(SystemTestMixin, unittest.TestCase): d.addCallback(self.check_is_healthy, self.root, "root") d.addCallback(lambda ign: self.mutable.check(verify=True)) d.addCallback(self.check_is_healthy, self.mutable, "mutable") - #d.addCallback(lambda ign: self.large.check(verify=True)) - #d.addCallback(self.check_is_healthy, self.large, "large") + d.addCallback(lambda ign: self.large.check(verify=True)) + d.addCallback(self.check_is_healthy, self.large, "large", + incomplete=True) d.addCallback(lambda ign: self.small.check(verify=True)) d.addCallback(self.failUnlessEqual, None, "small") @@ -2115,7 +2119,8 @@ class DeepCheck(SystemTestMixin, unittest.TestCase): d.addCallback(lambda ign: self.mutable.check_and_repair(verify=True)) d.addCallback(self.check_and_repair_is_healthy, self.mutable, "mutable") d.addCallback(lambda ign: self.large.check_and_repair(verify=True)) - d.addCallback(self.check_and_repair_is_healthy, self.large, "large") + d.addCallback(self.check_and_repair_is_healthy, self.large, "large", + incomplete=True) d.addCallback(lambda ign: self.small.check_and_repair(verify=True)) d.addCallback(self.failUnlessEqual, None, "small")