#
# patch "ChangeLog"
# from [18cb62c01adbe50b42f90d5b77a066507658fbcd]
# to [449de581b331a80859192326e5a8bc909496b2fa]
#
# patch "database_check.cc"
# from [a4c657c1f544061cd11935dd18ef5fea43e9accb]
# to [415b63b94a1150b3aff78b9e7fa512e0141577e8]
#
# patch "tests/t_database_check_normalized.at"
# from [b56eaa874dc95e9f15a87b50997a11c8f85a71b5]
# to [c282c8b5f282a61b35880dd25aee757eb3d3df95]
#
========================================================================
--- ChangeLog 18cb62c01adbe50b42f90d5b77a066507658fbcd
+++ ChangeLog 449de581b331a80859192326e5a8bc909496b2fa
@@ -1,5 +1,13 @@
2005-08-26 Nathaniel Smith
+ * database_check.cc: Track and report on manifest and revision
+ parseability.
+ * tests/t_database_check_normalized.at: Update to expect "not
+ parseable" messages rather than "not normalized" messages.
+ All tests pass.
+
+2005-08-26 Nathaniel Smith
+
* tests/t_unreadable_MT.at: This test was called "do not fail on
unreadable MT/options". I do not know why we wanted such
behavior. I am making it "fail cleanly on unreadable
========================================================================
--- database_check.cc a4c657c1f544061cd11935dd18ef5fea43e9accb
+++ database_check.cc 415b63b94a1150b3aff78b9e7fa512e0141577e8
@@ -57,11 +57,12 @@
size_t revision_refs; // number of revision references to this manifest
size_t missing_files; // number of missing files referenced by this manifest
+ bool parseable; // read_manifest_map does not throw
bool normalized; // write_manifest_map( read_manifest_map(dat) ) == dat
checked_manifest():
found(false), revision_refs(0),
- missing_files(0), normalized(false) {}
+ missing_files(0), parseable(false), normalized(false) {}
};
// the number of times a revision is referenced (revision_refs)
@@ -84,6 +85,7 @@
size_t cert_refs; // number of references to this revision by revision certs;
+ bool parseable; // read_revision_set does not throw
bool normalized; // write_revision_set( read_revision_set(dat) ) == dat
std::string history_error;
@@ -95,7 +97,7 @@
found(false),
revision_refs(0), ancestry_parent_refs(0), ancestry_child_refs(0),
missing_manifests(0), missing_revisions(0), incomplete_manifests(0),
- cert_refs(0), normalized(false) {}
+ cert_refs(0), parseable(false), normalized(false) {}
};
static void
@@ -142,7 +144,17 @@
checked_manifests[*i].found = true;
manifest_map man;
- read_manifest_map(data, man);
+ try
+ {
+ read_manifest_map(data, man);
+ }
+ catch (std::logic_error & e)
+ {
+ L(F("error parsing manifest %s: %s") % *i % e.what());
+ checked_manifests[*i].parseable = false;
+ continue;
+ }
+ checked_manifests[*i].parseable = true;
// normalisation check
manifest_id norm_ident;
@@ -188,7 +200,17 @@
checked_revisions[*i].found = true;
revision_set rev;
- read_revision_set(data, rev);
+ try
+ {
+ read_revision_set(data, rev);
+ }
+ catch (std::logic_error & e)
+ {
+ L(F("error parsing revision %s: %s") % *i % e.what());
+ checked_revisions[*i].parseable = false;
+ continue;
+ }
+ checked_revisions[*i].parseable = true;
// normalisation check
revision_id norm_ident;
@@ -406,6 +428,7 @@
size_t & missing_manifests,
size_t & unreferenced_manifests,
size_t & incomplete_manifests,
+ size_t & non_parseable_manifests,
size_t & non_normalized_manifests)
{
for (std::map::const_iterator
@@ -433,8 +456,15 @@
% i->first % manifest.missing_files);
}
- if (!manifest.normalized)
+ if (!manifest.parseable)
{
+ non_parseable_manifests++;
+ P(F("manifest %s is not parseable (perhaps with unnormalized paths?)\n")
+ % i->first);
+ }
+
+ if (manifest.parseable && !manifest.normalized)
+ {
non_normalized_manifests++;
P(F("manifest %s is not in normalized form\n")
% i->first);
@@ -449,6 +479,7 @@
size_t & mismatched_parents,
size_t & mismatched_children,
size_t & bad_history,
+ size_t & non_parseable_revisions,
size_t & non_normalized_revisions)
{
for (std::map::const_iterator
@@ -512,8 +543,15 @@
% i->first % tmp);
}
- if (!revision.normalized)
+ if (!revision.parseable)
{
+ non_parseable_revisions++;
+ P(F("revision %s is not parseable (perhaps with unnormalized paths?)\n")
+ % i->first);
+ }
+
+ if (revision.parseable && !revision.normalized)
+ {
non_normalized_revisions++;
P(F("revision %s is not in normalized form\n")
% i->first);
@@ -628,6 +666,7 @@
size_t missing_manifests = 0;
size_t unreferenced_manifests = 0;
size_t incomplete_manifests = 0;
+ size_t non_parseable_manifests = 0;
size_t non_normalized_manifests = 0;
size_t missing_revisions = 0;
@@ -635,6 +674,7 @@
size_t mismatched_parents = 0;
size_t mismatched_children = 0;
size_t bad_history = 0;
+ size_t non_parseable_revisions = 0;
size_t non_normalized_revisions = 0;
size_t missing_keys = 0;
@@ -658,12 +698,14 @@
report_manifests(checked_manifests,
missing_manifests, unreferenced_manifests,
incomplete_manifests,
+ non_parseable_manifests,
non_normalized_manifests);
report_revisions(checked_revisions,
missing_revisions, incomplete_revisions,
mismatched_parents, mismatched_children,
- bad_history, non_normalized_revisions);
+ bad_history, non_parseable_revisions,
+ non_normalized_revisions);
report_keys(checked_keys, missing_keys);
@@ -682,6 +724,9 @@
W(F("%d unreferenced manifests\n") % unreferenced_manifests);
if (incomplete_manifests > 0)
W(F("%d incomplete manifests\n") % incomplete_manifests);
+ if (non_parseable_manifests > 0)
+ W(F("%d manifests not parseable (perhaps with invalid paths)\n")
+ % non_parseable_manifests);
if (non_normalized_manifests > 0)
W(F("%d manifests not in normalized form\n") % non_normalized_manifests);
@@ -695,6 +740,9 @@
W(F("%d mismatched children\n") % mismatched_children);
if (bad_history > 0)
W(F("%d revisions with bad history\n") % bad_history);
+ if (non_parseable_revisions > 0)
+ W(F("%d revisions not parseable (perhaps with invalid paths)\n")
+ % non_parseable_revisions);
if (non_normalized_revisions > 0)
W(F("%d revisions not in normalized form\n") % non_normalized_revisions);
@@ -712,9 +760,9 @@
size_t total = missing_files + unreferenced_files +
missing_manifests + unreferenced_manifests + incomplete_manifests +
- non_normalized_manifests +
+ non_parseable_manifests + non_normalized_manifests +
missing_revisions + incomplete_revisions +
- non_normalized_revisions +
+ non_parseable_revisions + non_normalized_revisions +
mismatched_parents + mismatched_children +
bad_history +
missing_certs + mismatched_certs +
@@ -724,9 +772,9 @@
// serious errors; odd, but nothing will break.
size_t serious = missing_files +
missing_manifests + incomplete_manifests +
- non_normalized_manifests +
+ non_parseable_manifests + non_normalized_manifests +
missing_revisions + incomplete_revisions +
- non_normalized_revisions +
+ non_parseable_revisions + non_normalized_revisions +
mismatched_parents + mismatched_children +
bad_history +
missing_certs +
========================================================================
--- tests/t_database_check_normalized.at b56eaa874dc95e9f15a87b50997a11c8f85a71b5
+++ tests/t_database_check_normalized.at c282c8b5f282a61b35880dd25aee757eb3d3df95
@@ -101,7 +101,7 @@
AT_CHECK(MONOTONE db check -d bad.db, [1], [ignore], [stderr])
-AT_CHECK(grep 'revisions not in normalized form' stderr, [], [ignore], [ignore])
-AT_CHECK(grep 'manifests not in normalized form' stderr, [], [ignore], [ignore])
+AT_CHECK(grep 'revisions not parseable' stderr, [], [ignore], [ignore])
+AT_CHECK(grep 'manifests not parseable' stderr, [], [ignore], [ignore])
AT_CLEANUP